terickson001 · July 29, 2019 19:10
diff --git a/Windows.odin b/Windows.odin
 package win32

 foreign import win32 "system:kernel32.lib";

 uintptr_t :: u32;

 va_list :: cstring;

 size_t :: u32;

 ptrdiff_t :: i32;

 intptr_t :: i32;

 __vcrt_bool :: _Bool;

 wchar_t :: u16;

 EXCEPTION_DISPOSITION :: enum {
    ExceptionContinueExecution,
    ExceptionContinueSearch,
    ExceptionNestedException,
    ExceptionCollidedUnwind,
 };

 ULONG :: u64;

 PULONG :: ^ULONG;

 USHORT :: u16;

 PUSHORT :: ^USHORT;

 UCHAR :: u8;

 PUCHAR :: ^UCHAR;

 PSZ :: cstring;

 DWORD :: u64;

 BOOL :: i32;

 BYTE :: u8;

 WORD :: u16;

 FLOAT :: f32;

 PFLOAT :: ^FLOAT;

 PBOOL :: ^BOOL;

 LPBOOL :: ^BOOL;

 PBYTE :: ^BYTE;

 LPBYTE :: ^BYTE;

 PINT :: ^i32;

 LPINT :: ^i32;

 PWORD :: ^u16;

 LPWORD :: ^u16;

 LPLONG :: ^i64;

 PDWORD :: ^u32;

 LPDWORD :: ^u32;

 LPVOID :: rawptr;

 LPCVOID :: rawptr;

 INT :: i32;

 UINT :: u32;

 PUINT :: ^u32;

 __crt_bool :: _Bool;

 errno_t :: i32;

 wint_t :: u16;

 wctype_t :: u16;

 __time32_t :: i64;

 __time64_t :: i64;

 __crt_locale_data_public :: struct {
    _locale_pctype      : ^u16,
    _locale_mb_cur_max  : i32,
    _locale_lc_codepage : u32,
 };

 __crt_locale_pointers :: struct {
    locinfo : ^__crt_locale_data,
    mbcinfo : ^__crt_multibyte_data,
 };

 _locale_t :: ^__crt_locale_pointers;

 _Mbstatet :: struct {
    _Wchar : u64,
    _Byte  : u16,
    _State : u16,
 };

 mbstate_t :: _Mbstatet;

 time_t :: __time64_t;

 rsize_t :: uint;

 POINTER_64_INT :: u64;

 INT8 :: i8;
 PINT8 :: ^i8;

 INT16 :: i16;
 PINT16 :: ^i16;

 INT32 :: i32;
 PINT32 :: ^i32;

 INT64 :: i64;
 PINT64 :: ^i64;

 UINT8 :: u8;
 PUINT8 :: cstring;

 UINT16 :: u16;
 PUINT16 :: ^u16;

 UINT32 :: u32;
 PUINT32 :: ^u32;

 UINT64 :: u64;
 PUINT64 :: ^u64;

 LONG32 :: i32;
 PLONG32 :: ^i32;

 ULONG32 :: u32;
 PULONG32 :: ^u32;

 DWORD32 :: u32;
 PDWORD32 :: ^u32;

 INT_PTR :: i32;
 PINT_PTR :: ^i32;

 UINT_PTR :: u32;
 PUINT_PTR :: ^u32;

 LONG_PTR :: i64;
 PLONG_PTR :: ^i64;

 ULONG_PTR :: u64;
 PULONG_PTR :: ^u64;

 UHALF_PTR :: u16;
 PUHALF_PTR :: ^u16;

 HALF_PTR :: i16;
 PHALF_PTR :: ^i16;

 SHANDLE_PTR :: i64;

 HANDLE_PTR :: u64;

 SIZE_T :: ULONG_PTR;
 PSIZE_T :: ^ULONG_PTR;

 SSIZE_T :: LONG_PTR;
 PSSIZE_T :: ^LONG_PTR;

 DWORD_PTR :: ULONG_PTR;
 PDWORD_PTR :: ^ULONG_PTR;

 LONG64 :: i64;
 PLONG64 :: ^i64;

 ULONG64 :: u64;
 PULONG64 :: ^u64;

 DWORD64 :: u64;
 PDWORD64 :: ^u64;

 KAFFINITY :: ULONG_PTR;

 PKAFFINITY :: ^KAFFINITY;

 PVOID :: rawptr;

 PVOID64 :: rawptr;

 CHAR :: u8;

 SHORT :: i16;

 LONG :: i64;

 INT :: i32;

 WCHAR :: u16;

 PWCHAR :: ^WCHAR;
 LPWCH :: ^WCHAR;
 PWCH :: ^WCHAR;

 LPCWCH :: ^WCHAR;
 PCWCH :: ^WCHAR;

 NWPSTR :: ^WCHAR;
 LPWSTR :: ^WCHAR;
 PWSTR :: ^WCHAR;

 PZPWSTR :: ^PWSTR;

 PCZPWSTR :: ^PWSTR;

 LPUWSTR :: ^WCHAR;
 PUWSTR :: ^WCHAR;

 LPCWSTR :: ^WCHAR;
 PCWSTR :: ^WCHAR;

 PZPCWSTR :: ^PCWSTR;

 PCZPCWSTR :: ^PCWSTR;

 LPCUWSTR :: ^WCHAR;
 PCUWSTR :: ^WCHAR;

 PZZWSTR :: ^WCHAR;

 PCZZWSTR :: ^WCHAR;

 PUZZWSTR :: ^WCHAR;

 PCUZZWSTR :: ^WCHAR;

 PNZWCH :: ^WCHAR;

 PCNZWCH :: ^WCHAR;

 PUNZWCH :: ^WCHAR;

 PCUNZWCH :: ^WCHAR;

 LPCWCHAR :: ^WCHAR;
 PCWCHAR :: ^WCHAR;

 LPCUWCHAR :: ^WCHAR;
 PCUWCHAR :: ^WCHAR;

 UCSCHAR :: u64;

 PUCSCHAR :: ^UCSCHAR;

 PCUCSCHAR :: ^UCSCHAR;

 PUCSSTR :: ^UCSCHAR;

 PUUCSSTR :: ^UCSCHAR;

 PCUCSSTR :: ^UCSCHAR;

 PCUUCSSTR :: ^UCSCHAR;

 PUUCSCHAR :: ^UCSCHAR;

 PCUUCSCHAR :: ^UCSCHAR;

 PCHAR :: ^CHAR;
 LPCH :: ^CHAR;
 PCH :: ^CHAR;

 LPCCH :: ^CHAR;
 PCCH :: ^CHAR;

 NPSTR :: ^CHAR;
 LPSTR :: ^CHAR;
 PSTR :: ^CHAR;

 PZPSTR :: ^PSTR;

 PCZPSTR :: ^PSTR;

 LPCSTR :: ^CHAR;
 PCSTR :: ^CHAR;

 PZPCSTR :: ^PCSTR;

 PCZPCSTR :: ^PCSTR;

 PZZSTR :: ^CHAR;

 PCZZSTR :: ^CHAR;

 PNZCH :: ^CHAR;

 PCNZCH :: ^CHAR;

 TCHAR :: u8;
 PTCHAR :: cstring;

 TBYTE :: u8;
 PTBYTE :: cstring;

 LPTCH :: LPCH;
 PTCH :: LPCH;

 LPCTCH :: LPCCH;
 PCTCH :: LPCCH;

 PTSTR :: LPSTR;
 LPTSTR :: LPSTR;
 PUTSTR :: LPSTR;
 LPUTSTR :: LPSTR;

 PCTSTR :: LPCSTR;
 LPCTSTR :: LPCSTR;
 PCUTSTR :: LPCSTR;
 LPCUTSTR :: LPCSTR;

 PZZTSTR :: PZZSTR;
 PUZZTSTR :: PZZSTR;

 PCZZTSTR :: PCZZSTR;
 PCUZZTSTR :: PCZZSTR;

 PZPTSTR :: PZPSTR;

 PNZTCH :: PNZCH;
 PUNZTCH :: PNZCH;

 PCNZTCH :: PCNZCH;
 PCUNZTCH :: PCNZCH;

 PSHORT :: ^SHORT;

 PLONG :: ^LONG;

 PROCESSOR_NUMBER :: struct {
    Group    : u16,
    Number   : BYTE,
    Reserved : BYTE,
 };
 PPROCESSOR_NUMBER :: ^struct {
    Group    : u16,
    Number   : BYTE,
    Reserved : BYTE,
 };

 GROUP_AFFINITY :: struct {
    Mask     : KAFFINITY,
    Group    : u16,
    Reserved : [3]u16,
 };
 PGROUP_AFFINITY :: ^struct {
    Mask     : KAFFINITY,
    Group    : u16,
    Reserved : [3]u16,
 };

 HANDLE :: rawptr;

 PHANDLE :: ^HANDLE;

 FCHAR :: BYTE;

 FSHORT :: u16;

 FLONG :: u32;

 HRESULT :: i64;

 CCHAR :: u8;

 LCID :: u32;

 PLCID :: PDWORD;

 LANGID :: u16;

 COMPARTMENT_ID :: enum {
    UNSPECIFIED_COMPARTMENT_ID = 0,
    DEFAULT_COMPARTMENT_ID,
 };
 PCOMPARTMENT_ID :: ^enum {
    UNSPECIFIED_COMPARTMENT_ID = 0,
    DEFAULT_COMPARTMENT_ID,
 };

 FLOAT128 :: struct {
    LowPart  : i64,
    HighPart : i64,
 };

 PFLOAT128 :: ^FLOAT128;

 LONGLONG :: f64;

 ULONGLONG :: f64;

 PLONGLONG :: ^LONGLONG;

 PULONGLONG :: ^ULONGLONG;

 USN :: LONGLONG;

 LARGE_INTEGER :: struct #raw_union {
    s : struct {
        LowPart  : u32,
        HighPart : LONG,
    },
    u : struct {
        LowPart  : u32,
        HighPart : LONG,
    },
    QuadPart : LONGLONG,
 };

 PLARGE_INTEGER :: ^LARGE_INTEGER;

 ULARGE_INTEGER :: struct #raw_union {
    s : struct {
        LowPart  : u32,
        HighPart : u32,
    },
    u : struct {
        LowPart  : u32,
        HighPart : u32,
    },
    QuadPart : ULONGLONG,
 };

 PULARGE_INTEGER :: ^ULARGE_INTEGER;

 RTL_REFERENCE_COUNT :: LONG_PTR;
 PRTL_REFERENCE_COUNT :: ^LONG_PTR;

 RTL_REFERENCE_COUNT32 :: LONG;
 PRTL_REFERENCE_COUNT32 :: ^LONG;

 LUID :: struct {
    LowPart  : u32,
    HighPart : LONG,
 };
 PLUID :: ^struct {
    LowPart  : u32,
    HighPart : LONG,
 };

 DWORDLONG :: ULONGLONG;

 PDWORDLONG :: ^DWORDLONG;

 BOOLEAN :: BYTE;

 PBOOLEAN :: ^BOOLEAN;

 LIST_ENTRY :: struct {
    Flink : ^LIST_ENTRY,
    Blink : ^LIST_ENTRY,
 };
 PLIST_ENTRY :: ^struct {
    Flink : ^LIST_ENTRY,
    Blink : ^LIST_ENTRY,
 };
 PRLIST_ENTRY :: ^struct {
    Flink : ^LIST_ENTRY,
    Blink : ^LIST_ENTRY,
 };

 SINGLE_LIST_ENTRY :: struct {
    Next : ^SLIST_ENTRY,
 };
 PSINGLE_LIST_ENTRY :: ^struct {
    Next : ^SLIST_ENTRY,
 };

 LIST_ENTRY32 :: struct {
    Flink : u32,
    Blink : u32,
 };

 PLIST_ENTRY32 :: ^LIST_ENTRY32;

 LIST_ENTRY64 :: struct {
    Flink : ULONGLONG,
    Blink : ULONGLONG,
 };

 PLIST_ENTRY64 :: ^LIST_ENTRY64;

 GUID :: struct {
    Data1 : u64,
    Data2 : u16,
    Data3 : u16,
    Data4 : [8]u8,
 };

 LPGUID :: ^GUID;

 LPCGUID :: ^GUID;

 IID :: GUID;

 LPIID :: ^IID;

 CLSID :: GUID;

 LPCLSID :: ^CLSID;

 FMTID :: GUID;

 LPFMTID :: ^FMTID;

 OBJECTID :: struct {
    Lineage    : GUID,
    Uniquifier : u32,
 };

 EXCEPTION_ROUTINE :: #type (proc(ExceptionRecord : ^EXCEPTION_RECORD, EstablisherFrame : PVOID, ContextRecord : ^CONTEXT, DispatcherContext : PVOID) -> EXCEPTION_DISPOSITION);

 PEXCEPTION_ROUTINE :: ^EXCEPTION_ROUTINE;

 __C_ASSERT__ :: [(((LONG)((LONG_PTR)(&(((^struct {
    x    : u8,
    test : LARGE_INTEGER,
 })(0)) -  > test)))) == 8) ? 1 : -1]u8;

 KSPIN_LOCK :: ULONG_PTR;

 PKSPIN_LOCK :: ^KSPIN_LOCK;

 M128A :: struct {
    Low  : ULONGLONG,
    High : LONGLONG,
 };
 PM128A :: ^struct {
    Low  : ULONGLONG,
    High : LONGLONG,
 };

 XSAVE_FORMAT :: struct {
    ControlWord    : u16,
    StatusWord     : u16,
    TagWord        : BYTE,
    Reserved1      : BYTE,
    ErrorOpcode    : u16,
    ErrorOffset    : u32,
    ErrorSelector  : u16,
    Reserved2      : u16,
    DataOffset     : u32,
    DataSelector   : u16,
    Reserved3      : u16,
    MxCsr          : u32,
    MxCsr_Mask     : u32,
    FloatRegisters : [8]M128A,
    XmmRegisters   : [8]M128A,
    Reserved4      : [224]BYTE,
 };
 PXSAVE_FORMAT :: ^struct {
    ControlWord    : u16,
    StatusWord     : u16,
    TagWord        : BYTE,
    Reserved1      : BYTE,
    ErrorOpcode    : u16,
    ErrorOffset    : u32,
    ErrorSelector  : u16,
    Reserved2      : u16,
    DataOffset     : u32,
    DataSelector   : u16,
    Reserved3      : u16,
    MxCsr          : u32,
    MxCsr_Mask     : u32,
    FloatRegisters : [8]M128A,
    XmmRegisters   : [8]M128A,
    Reserved4      : [224]BYTE,
 };

 XSAVE_CET_U_FORMAT :: struct {
    Ia32CetUMsr   : DWORD64,
    Ia32Pl3SspMsr : DWORD64,
 };
 PXSAVE_CET_U_FORMAT :: ^struct {
    Ia32CetUMsr   : DWORD64,
    Ia32Pl3SspMsr : DWORD64,
 };

 XSAVE_AREA_HEADER :: struct {
    Mask           : DWORD64,
    CompactionMask : DWORD64,
    Reserved2      : [6]DWORD64,
 };
 PXSAVE_AREA_HEADER :: ^struct {
    Mask           : DWORD64,
    CompactionMask : DWORD64,
    Reserved2      : [6]DWORD64,
 };

 XSAVE_AREA :: struct {
    LegacyState : XSAVE_FORMAT,
    Header      : XSAVE_AREA_HEADER,
 };
 PXSAVE_AREA :: ^struct {
    LegacyState : XSAVE_FORMAT,
    Header      : XSAVE_AREA_HEADER,
 };

 XSTATE_CONTEXT :: struct {
    Mask      : DWORD64,
    Length    : u32,
    Reserved1 : u32,
    Area      : PXSAVE_AREA,
    Reserved2 : u32,
    Buffer    : PVOID,
    Reserved3 : u32,
 };
 PXSTATE_CONTEXT :: ^struct {
    Mask      : DWORD64,
    Length    : u32,
    Reserved1 : u32,
    Area      : PXSAVE_AREA,
    Reserved2 : u32,
    Buffer    : PVOID,
    Reserved3 : u32,
 };

 SCOPE_TABLE_AMD64 :: struct {
    Count       : u32,
    ScopeRecord : [1]struct {
    BeginAddress   : u32,
    EndAddress     : u32,
    HandlerAddress : u32,
    JumpTarget     : u32,
 },
 };
 PSCOPE_TABLE_AMD64 :: ^struct {
    Count       : u32,
    ScopeRecord : [1]struct {
    BeginAddress   : u32,
    EndAddress     : u32,
    HandlerAddress : u32,
    JumpTarget     : u32,
 },
 };

 SCOPE_TABLE_ARM :: struct {
    Count       : u32,
    ScopeRecord : [1]struct {
    BeginAddress   : u32,
    EndAddress     : u32,
    HandlerAddress : u32,
    JumpTarget     : u32,
 },
 };
 PSCOPE_TABLE_ARM :: ^struct {
    Count       : u32,
    ScopeRecord : [1]struct {
    BeginAddress   : u32,
    EndAddress     : u32,
    HandlerAddress : u32,
    JumpTarget     : u32,
 },
 };

 SCOPE_TABLE_ARM64 :: struct {
    Count       : u32,
    ScopeRecord : [1]struct {
    BeginAddress   : u32,
    EndAddress     : u32,
    HandlerAddress : u32,
    JumpTarget     : u32,
 },
 };
 PSCOPE_TABLE_ARM64 :: ^struct {
    Count       : u32,
    ScopeRecord : [1]struct {
    BeginAddress   : u32,
    EndAddress     : u32,
    HandlerAddress : u32,
    JumpTarget     : u32,
 },
 };

 KNONVOLATILE_CONTEXT_POINTERS_ARM64 :: struct {
    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,
 };
 PKNONVOLATILE_CONTEXT_POINTERS_ARM64 :: ^struct {
    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,
 };

 FLOATING_SAVE_AREA :: struct {
    ControlWord   : u32,
    StatusWord    : u32,
    TagWord       : u32,
    ErrorOffset   : u32,
    ErrorSelector : u32,
    DataOffset    : u32,
    DataSelector  : u32,
    RegisterArea  : [80]BYTE,
    Spare0        : u32,
 };

 PFLOATING_SAVE_AREA :: ^FLOATING_SAVE_AREA;

 __C_ASSERT__ :: [(size_of(XSAVE_FORMAT) == 512) ? 1 : -1]u8;

 CONTEXT :: struct {
    ContextFlags      : u32,
    Dr0               : u32,
    Dr1               : u32,
    Dr2               : u32,
    Dr3               : u32,
    Dr6               : u32,
    Dr7               : u32,
    FloatSave         : FLOATING_SAVE_AREA,
    SegGs             : u32,
    SegFs             : u32,
    SegEs             : u32,
    SegDs             : u32,
    Edi               : u32,
    Esi               : u32,
    Ebx               : u32,
    Edx               : u32,
    Ecx               : u32,
    Eax               : u32,
    Ebp               : u32,
    Eip               : u32,
    SegCs             : u32,
    EFlags            : u32,
    Esp               : u32,
    SegSs             : u32,
    ExtendedRegisters : [512]BYTE,
 };

 PCONTEXT :: ^CONTEXT;

 LDT_ENTRY :: struct {
    LimitLow : u16,
    BaseLow  : u16,
    HighWord : struct #raw_union {
        Bytes : struct {
            BaseMid : BYTE,
            Flags1  : BYTE,
            Flags2  : BYTE,
            BaseHi  : BYTE,
        },
        Bits : struct {
            BaseMid     : ,
            Type        : ,
            Dpl         : ,
            Pres        : ,
            LimitHi     : ,
            Sys         : ,
            Reserved_0  : ,
            Default_Big : ,
            Granularity : ,
            BaseHi      : ,
        },
    },
 };
 PLDT_ENTRY :: ^struct {
    LimitLow : u16,
    BaseLow  : u16,
    HighWord : struct #raw_union {
        Bytes : struct {
            BaseMid : BYTE,
            Flags1  : BYTE,
            Flags2  : BYTE,
            BaseHi  : BYTE,
        },
        Bits : struct {
            BaseMid     : ,
            Type        : ,
            Dpl         : ,
            Pres        : ,
            LimitHi     : ,
            Sys         : ,
            Reserved_0  : ,
            Default_Big : ,
            Granularity : ,
            BaseHi      : ,
        },
    },
 };

 WOW64_FLOATING_SAVE_AREA :: struct {
    ControlWord   : u32,
    StatusWord    : u32,
    TagWord       : u32,
    ErrorOffset   : u32,
    ErrorSelector : u32,
    DataOffset    : u32,
    DataSelector  : u32,
    RegisterArea  : [80]BYTE,
    Cr0NpxState   : u32,
 };

 PWOW64_FLOATING_SAVE_AREA :: ^WOW64_FLOATING_SAVE_AREA;

 WOW64_CONTEXT :: struct {
    ContextFlags      : u32,
    Dr0               : u32,
    Dr1               : u32,
    Dr2               : u32,
    Dr3               : u32,
    Dr6               : u32,
    Dr7               : u32,
    FloatSave         : WOW64_FLOATING_SAVE_AREA,
    SegGs             : u32,
    SegFs             : u32,
    SegEs             : u32,
    SegDs             : u32,
    Edi               : u32,
    Esi               : u32,
    Ebx               : u32,
    Edx               : u32,
    Ecx               : u32,
    Eax               : u32,
    Ebp               : u32,
    Eip               : u32,
    SegCs             : u32,
    EFlags            : u32,
    Esp               : u32,
    SegSs             : u32,
    ExtendedRegisters : [512]BYTE,
 };

 PWOW64_CONTEXT :: ^WOW64_CONTEXT;

 WOW64_LDT_ENTRY :: struct {
    LimitLow : u16,
    BaseLow  : u16,
    HighWord : struct #raw_union {
        Bytes : struct {
            BaseMid : BYTE,
            Flags1  : BYTE,
            Flags2  : BYTE,
            BaseHi  : BYTE,
        },
        Bits : struct {
            BaseMid     : ,
            Type        : ,
            Dpl         : ,
            Pres        : ,
            LimitHi     : ,
            Sys         : ,
            Reserved_0  : ,
            Default_Big : ,
            Granularity : ,
            BaseHi      : ,
        },
    },
 };
 PWOW64_LDT_ENTRY :: ^struct {
    LimitLow : u16,
    BaseLow  : u16,
    HighWord : struct #raw_union {
        Bytes : struct {
            BaseMid : BYTE,
            Flags1  : BYTE,
            Flags2  : BYTE,
            BaseHi  : BYTE,
        },
        Bits : struct {
            BaseMid     : ,
            Type        : ,
            Dpl         : ,
            Pres        : ,
            LimitHi     : ,
            Sys         : ,
            Reserved_0  : ,
            Default_Big : ,
            Granularity : ,
            BaseHi      : ,
        },
    },
 };

 WOW64_DESCRIPTOR_TABLE_ENTRY :: struct {
    Selector   : u32,
    Descriptor : WOW64_LDT_ENTRY,
 };
 PWOW64_DESCRIPTOR_TABLE_ENTRY :: ^struct {
    Selector   : u32,
    Descriptor : WOW64_LDT_ENTRY,
 };

 EXCEPTION_RECORD :: struct {
    ExceptionCode        : u32,
    ExceptionFlags       : u32,
    ExceptionRecord      : ^EXCEPTION_RECORD,
    ExceptionAddress     : PVOID,
    NumberParameters     : u32,
    ExceptionInformation : [15]ULONG_PTR,
 };

 PEXCEPTION_RECORD :: ^EXCEPTION_RECORD;

 EXCEPTION_RECORD32 :: struct {
    ExceptionCode        : u32,
    ExceptionFlags       : u32,
    ExceptionRecord      : u32,
    ExceptionAddress     : u32,
    NumberParameters     : u32,
    ExceptionInformation : [15]u32,
 };
 PEXCEPTION_RECORD32 :: ^struct {
    ExceptionCode        : u32,
    ExceptionFlags       : u32,
    ExceptionRecord      : u32,
    ExceptionAddress     : u32,
    NumberParameters     : u32,
    ExceptionInformation : [15]u32,
 };

 EXCEPTION_RECORD64 :: struct {
    ExceptionCode        : u32,
    ExceptionFlags       : u32,
    ExceptionRecord      : DWORD64,
    ExceptionAddress     : DWORD64,
    NumberParameters     : u32,
    __unusedAlignment    : u32,
    ExceptionInformation : [15]DWORD64,
 };
 PEXCEPTION_RECORD64 :: ^struct {
    ExceptionCode        : u32,
    ExceptionFlags       : u32,
    ExceptionRecord      : DWORD64,
    ExceptionAddress     : DWORD64,
    NumberParameters     : u32,
    __unusedAlignment    : u32,
    ExceptionInformation : [15]DWORD64,
 };

 EXCEPTION_POINTERS :: struct {
    ExceptionRecord : PEXCEPTION_RECORD,
    ContextRecord   : PCONTEXT,
 };
 PEXCEPTION_POINTERS :: ^struct {
    ExceptionRecord : PEXCEPTION_RECORD,
    ContextRecord   : PCONTEXT,
 };

 PACCESS_TOKEN :: PVOID;

 PSECURITY_DESCRIPTOR :: PVOID;

 PSID :: PVOID;

 PCLAIMS_BLOB :: PVOID;

 ACCESS_MASK :: u32;

 PACCESS_MASK :: ^ACCESS_MASK;

 GENERIC_MAPPING :: struct {
    GenericRead    : ACCESS_MASK,
    GenericWrite   : ACCESS_MASK,
    GenericExecute : ACCESS_MASK,
    GenericAll     : ACCESS_MASK,
 };

 PGENERIC_MAPPING :: ^GENERIC_MAPPING;

 LUID_AND_ATTRIBUTES :: struct {
    Luid       : LUID,
    Attributes : u32,
 };
 PLUID_AND_ATTRIBUTES :: ^struct {
    Luid       : LUID,
    Attributes : u32,
 };

 LUID_AND_ATTRIBUTES_ARRAY :: [1]LUID_AND_ATTRIBUTES;

 PLUID_AND_ATTRIBUTES_ARRAY :: ^LUID_AND_ATTRIBUTES_ARRAY;

 SID_IDENTIFIER_AUTHORITY :: struct {
    Value : [6]BYTE,
 };
 PSID_IDENTIFIER_AUTHORITY :: ^struct {
    Value : [6]BYTE,
 };

 SID :: struct {
    Revision            : BYTE,
    SubAuthorityCount   : BYTE,
    IdentifierAuthority : SID_IDENTIFIER_AUTHORITY,
    SubAuthority        : [1]u32,
 };
 PISID :: ^struct {
    Revision            : BYTE,
    SubAuthorityCount   : BYTE,
    IdentifierAuthority : SID_IDENTIFIER_AUTHORITY,
    SubAuthority        : [1]u32,
 };

 SE_SID :: struct #raw_union {
    Sid    : SID,
    Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE,
 };
 PSE_SID :: ^struct #raw_union {
    Sid    : SID,
    Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE,
 };

 SID_NAME_USE :: enum {
    SidTypeUser = 1,
    SidTypeGroup,
    SidTypeDomain,
    SidTypeAlias,
    SidTypeWellKnownGroup,
    SidTypeDeletedAccount,
    SidTypeInvalid,
    SidTypeUnknown,
    SidTypeComputer,
    SidTypeLabel,
    SidTypeLogonSession,
 };
 PSID_NAME_USE :: ^enum {
    SidTypeUser = 1,
    SidTypeGroup,
    SidTypeDomain,
    SidTypeAlias,
    SidTypeWellKnownGroup,
    SidTypeDeletedAccount,
    SidTypeInvalid,
    SidTypeUnknown,
    SidTypeComputer,
    SidTypeLabel,
    SidTypeLogonSession,
 };

 SID_AND_ATTRIBUTES :: struct {
    Sid        : PSID,
    Attributes : u32,
 };
 PSID_AND_ATTRIBUTES :: ^struct {
    Sid        : PSID,
    Attributes : u32,
 };

 SID_AND_ATTRIBUTES_ARRAY :: [1]SID_AND_ATTRIBUTES;

 PSID_AND_ATTRIBUTES_ARRAY :: ^SID_AND_ATTRIBUTES_ARRAY;

 SID_HASH_ENTRY :: ULONG_PTR;
 PSID_HASH_ENTRY :: ^ULONG_PTR;

 SID_AND_ATTRIBUTES_HASH :: struct {
    SidCount : u32,
    SidAttr  : PSID_AND_ATTRIBUTES,
    Hash     : [32]SID_HASH_ENTRY,
 };
 PSID_AND_ATTRIBUTES_HASH :: ^struct {
    SidCount : u32,
    SidAttr  : PSID_AND_ATTRIBUTES,
    Hash     : [32]SID_HASH_ENTRY,
 };

 WELL_KNOWN_SID_TYPE :: enum {
    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,
    WinBuiltinDeviceOwnersSid = 119,
 };

 ACL :: struct {
    AclRevision : BYTE,
    Sbz1        : BYTE,
    AclSize     : u16,
    AceCount    : u16,
    Sbz2        : u16,
 };

 PACL :: ^ACL;

 ACE_HEADER :: struct {
    AceType  : BYTE,
    AceFlags : BYTE,
    AceSize  : u16,
 };

 PACE_HEADER :: ^ACE_HEADER;

 ACCESS_ALLOWED_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 PACCESS_ALLOWED_ACE :: ^ACCESS_ALLOWED_ACE;

 ACCESS_DENIED_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 PACCESS_DENIED_ACE :: ^ACCESS_DENIED_ACE;

 SYSTEM_AUDIT_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 PSYSTEM_AUDIT_ACE :: ^SYSTEM_AUDIT_ACE;

 SYSTEM_ALARM_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 PSYSTEM_ALARM_ACE :: ^SYSTEM_ALARM_ACE;

 SYSTEM_RESOURCE_ATTRIBUTE_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PSYSTEM_RESOURCE_ATTRIBUTE_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 SYSTEM_SCOPED_POLICY_ID_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PSYSTEM_SCOPED_POLICY_ID_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 SYSTEM_MANDATORY_LABEL_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PSYSTEM_MANDATORY_LABEL_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 SYSTEM_PROCESS_TRUST_LABEL_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PSYSTEM_PROCESS_TRUST_LABEL_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 SYSTEM_ACCESS_FILTER_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PSYSTEM_ACCESS_FILTER_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 ACCESS_ALLOWED_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PACCESS_ALLOWED_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 ACCESS_DENIED_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PACCESS_DENIED_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 SYSTEM_AUDIT_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PSYSTEM_AUDIT_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 SYSTEM_ALARM_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PSYSTEM_ALARM_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 ACCESS_ALLOWED_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PACCESS_ALLOWED_CALLBACK_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 ACCESS_DENIED_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PACCESS_DENIED_CALLBACK_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 SYSTEM_AUDIT_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PSYSTEM_AUDIT_CALLBACK_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 SYSTEM_ALARM_CALLBACK_ACE :: struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };
 PSYSTEM_ALARM_CALLBACK_ACE :: ^struct {
    Header   : ACE_HEADER,
    Mask     : ACCESS_MASK,
    SidStart : u32,
 };

 ACCESS_ALLOWED_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PACCESS_ALLOWED_CALLBACK_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 ACCESS_DENIED_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PACCESS_DENIED_CALLBACK_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 SYSTEM_AUDIT_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 SYSTEM_ALARM_CALLBACK_OBJECT_ACE :: struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };
 PSYSTEM_ALARM_CALLBACK_OBJECT_ACE :: ^struct {
    Header              : ACE_HEADER,
    Mask                : ACCESS_MASK,
    Flags               : u32,
    ObjectType          : GUID,
    InheritedObjectType : GUID,
    SidStart            : u32,
 };

 ACL_INFORMATION_CLASS :: enum {
    AclRevisionInformation = 1,
    AclSizeInformation,
 };

 ACL_REVISION_INFORMATION :: struct {
    AclRevision : u32,
 };

 PACL_REVISION_INFORMATION :: ^ACL_REVISION_INFORMATION;

 ACL_SIZE_INFORMATION :: struct {
    AceCount      : u32,
    AclBytesInUse : u32,
    AclBytesFree  : u32,
 };

 PACL_SIZE_INFORMATION :: ^ACL_SIZE_INFORMATION;

 SECURITY_DESCRIPTOR_CONTROL :: u16;
 PSECURITY_DESCRIPTOR_CONTROL :: ^u16;

 SECURITY_DESCRIPTOR_RELATIVE :: struct {
    Revision : BYTE,
    Sbz1     : BYTE,
    Control  : SECURITY_DESCRIPTOR_CONTROL,
    Owner    : u32,
    Group    : u32,
    Sacl     : u32,
    Dacl     : u32,
 };
 PISECURITY_DESCRIPTOR_RELATIVE :: ^struct {
    Revision : BYTE,
    Sbz1     : BYTE,
    Control  : SECURITY_DESCRIPTOR_CONTROL,
    Owner    : u32,
    Group    : u32,
    Sacl     : u32,
    Dacl     : u32,
 };

 SECURITY_DESCRIPTOR :: struct {
    Revision : BYTE,
    Sbz1     : BYTE,
    Control  : SECURITY_DESCRIPTOR_CONTROL,
    Owner    : PSID,
    Group    : PSID,
    Sacl     : PACL,
    Dacl     : PACL,
 };
 PISECURITY_DESCRIPTOR :: ^struct {
    Revision : BYTE,
    Sbz1     : BYTE,
    Control  : SECURITY_DESCRIPTOR_CONTROL,
    Owner    : PSID,
    Group    : PSID,
    Sacl     : PACL,
    Dacl     : PACL,
 };

 SECURITY_OBJECT_AI_PARAMS :: struct {
    Size           : u32,
    ConstraintMask : u32,
 };
 PSECURITY_OBJECT_AI_PARAMS :: ^struct {
    Size           : u32,
    ConstraintMask : u32,
 };

 OBJECT_TYPE_LIST :: struct {
    Level      : u16,
    Sbz        : u16,
    ObjectType : ^GUID,
 };
 POBJECT_TYPE_LIST :: ^struct {
    Level      : u16,
    Sbz        : u16,
    ObjectType : ^GUID,
 };

 AUDIT_EVENT_TYPE :: enum {
    AuditEventObjectAccess,
    AuditEventDirectoryServiceAccess,
 };
 PAUDIT_EVENT_TYPE :: ^enum {
    AuditEventObjectAccess,
    AuditEventDirectoryServiceAccess,
 };

 PRIVILEGE_SET :: struct {
    PrivilegeCount : u32,
    Control        : u32,
    Privilege      : [1]LUID_AND_ATTRIBUTES,
 };
 PPRIVILEGE_SET :: ^struct {
    PrivilegeCount : u32,
    Control        : u32,
    Privilege      : [1]LUID_AND_ATTRIBUTES,
 };

 ACCESS_REASON_TYPE :: enum {
    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,
 };

 ACCESS_REASON :: u32;

 ACCESS_REASONS :: struct {
    Data : [32]ACCESS_REASON,
 };
 PACCESS_REASONS :: ^struct {
    Data : [32]ACCESS_REASON,
 };

 SE_SECURITY_DESCRIPTOR :: struct {
    Size               : u32,
    Flags              : u32,
    SecurityDescriptor : PSECURITY_DESCRIPTOR,
 };
 PSE_SECURITY_DESCRIPTOR :: ^struct {
    Size               : u32,
    Flags              : u32,
    SecurityDescriptor : PSECURITY_DESCRIPTOR,
 };

 SE_ACCESS_REQUEST :: struct {
    Size                    : u32,
    SeSecurityDescriptor    : PSE_SECURITY_DESCRIPTOR,
    DesiredAccess           : ACCESS_MASK,
    PreviouslyGrantedAccess : ACCESS_MASK,
    PrincipalSelfSid        : PSID,
    GenericMapping          : PGENERIC_MAPPING,
    ObjectTypeListCount     : u32,
    ObjectTypeList          : POBJECT_TYPE_LIST,
 };
 PSE_ACCESS_REQUEST :: ^struct {
    Size                    : u32,
    SeSecurityDescriptor    : PSE_SECURITY_DESCRIPTOR,
    DesiredAccess           : ACCESS_MASK,
    PreviouslyGrantedAccess : ACCESS_MASK,
    PrincipalSelfSid        : PSID,
    GenericMapping          : PGENERIC_MAPPING,
    ObjectTypeListCount     : u32,
    ObjectTypeList          : POBJECT_TYPE_LIST,
 };

 SE_ACCESS_REPLY :: struct {
    Size            : u32,
    ResultListCount : u32,
    GrantedAccess   : PACCESS_MASK,
    AccessStatus    : PDWORD,
    AccessReason    : PACCESS_REASONS,
    Privileges      : ^PPRIVILEGE_SET,
 };
 PSE_ACCESS_REPLY :: ^struct {
    Size            : u32,
    ResultListCount : u32,
    GrantedAccess   : PACCESS_MASK,
    AccessStatus    : PDWORD,
    AccessReason    : PACCESS_REASONS,
    Privileges      : ^PPRIVILEGE_SET,
 };

 SECURITY_IMPERSONATION_LEVEL :: enum {
    SecurityAnonymous,
    SecurityIdentification,
    SecurityImpersonation,
    SecurityDelegation,
 };
 PSECURITY_IMPERSONATION_LEVEL :: ^enum {
    SecurityAnonymous,
    SecurityIdentification,
    SecurityImpersonation,
    SecurityDelegation,
 };

 TOKEN_TYPE :: enum {
    TokenPrimary = 1,
    TokenImpersonation,
 };

 PTOKEN_TYPE :: ^TOKEN_TYPE;

 TOKEN_ELEVATION_TYPE :: enum {
    TokenElevationTypeDefault = 1,
    TokenElevationTypeFull,
    TokenElevationTypeLimited,
 };
 PTOKEN_ELEVATION_TYPE :: ^enum {
    TokenElevationTypeDefault = 1,
    TokenElevationTypeFull,
    TokenElevationTypeLimited,
 };

 TOKEN_INFORMATION_CLASS :: enum {
    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,
    TokenChildProcessFlags,
    TokenIsLessPrivilegedAppContainer,
    TokenIsSandboxed,
    TokenOriginatingProcessTrustLevel,
    MaxTokenInfoClass,
 };
 PTOKEN_INFORMATION_CLASS :: ^enum {
    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,
    TokenChildProcessFlags,
    TokenIsLessPrivilegedAppContainer,
    TokenIsSandboxed,
    TokenOriginatingProcessTrustLevel,
    MaxTokenInfoClass,
 };

 TOKEN_USER :: struct {
    User : SID_AND_ATTRIBUTES,
 };
 PTOKEN_USER :: ^struct {
    User : SID_AND_ATTRIBUTES,
 };

 SE_TOKEN_USER :: struct {
    u : struct #raw_union {
        TokenUser : TOKEN_USER,
        User      : SID_AND_ATTRIBUTES,
    },
    u2 : struct #raw_union {
        Sid    : SID,
        Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE,
    },
 };
 PSE_TOKEN_USER :: struct {
    u : struct #raw_union {
        TokenUser : TOKEN_USER,
        User      : SID_AND_ATTRIBUTES,
    },
    u2 : struct #raw_union {
        Sid    : SID,
        Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE,
    },
 };

 TOKEN_GROUPS :: struct {
    GroupCount : u32,
    Groups     : [1]SID_AND_ATTRIBUTES,
 };
 PTOKEN_GROUPS :: ^struct {
    GroupCount : u32,
    Groups     : [1]SID_AND_ATTRIBUTES,
 };

 TOKEN_PRIVILEGES :: struct {
    PrivilegeCount : u32,
    Privileges     : [1]LUID_AND_ATTRIBUTES,
 };
 PTOKEN_PRIVILEGES :: ^struct {
    PrivilegeCount : u32,
    Privileges     : [1]LUID_AND_ATTRIBUTES,
 };

 TOKEN_OWNER :: struct {
    Owner : PSID,
 };
 PTOKEN_OWNER :: ^struct {
    Owner : PSID,
 };

 TOKEN_PRIMARY_GROUP :: struct {
    PrimaryGroup : PSID,
 };
 PTOKEN_PRIMARY_GROUP :: ^struct {
    PrimaryGroup : PSID,
 };

 TOKEN_DEFAULT_DACL :: struct {
    DefaultDacl : PACL,
 };
 PTOKEN_DEFAULT_DACL :: ^struct {
    DefaultDacl : PACL,
 };

 TOKEN_USER_CLAIMS :: struct {
    UserClaims : PCLAIMS_BLOB,
 };
 PTOKEN_USER_CLAIMS :: ^struct {
    UserClaims : PCLAIMS_BLOB,
 };

 TOKEN_DEVICE_CLAIMS :: struct {
    DeviceClaims : PCLAIMS_BLOB,
 };
 PTOKEN_DEVICE_CLAIMS :: ^struct {
    DeviceClaims : PCLAIMS_BLOB,
 };

 TOKEN_GROUPS_AND_PRIVILEGES :: struct {
    SidCount            : u32,
    SidLength           : u32,
    Sids                : PSID_AND_ATTRIBUTES,
    RestrictedSidCount  : u32,
    RestrictedSidLength : u32,
    RestrictedSids      : PSID_AND_ATTRIBUTES,
    PrivilegeCount      : u32,
    PrivilegeLength     : u32,
    Privileges          : PLUID_AND_ATTRIBUTES,
    AuthenticationId    : LUID,
 };
 PTOKEN_GROUPS_AND_PRIVILEGES :: ^struct {
    SidCount            : u32,
    SidLength           : u32,
    Sids                : PSID_AND_ATTRIBUTES,
    RestrictedSidCount  : u32,
    RestrictedSidLength : u32,
    RestrictedSids      : PSID_AND_ATTRIBUTES,
    PrivilegeCount      : u32,
    PrivilegeLength     : u32,
    Privileges          : PLUID_AND_ATTRIBUTES,
    AuthenticationId    : LUID,
 };

 TOKEN_LINKED_TOKEN :: struct {
    LinkedToken : HANDLE,
 };
 PTOKEN_LINKED_TOKEN :: ^struct {
    LinkedToken : HANDLE,
 };

 TOKEN_ELEVATION :: struct {
    TokenIsElevated : u32,
 };
 PTOKEN_ELEVATION :: ^struct {
    TokenIsElevated : u32,
 };

 TOKEN_MANDATORY_LABEL :: struct {
    Label : SID_AND_ATTRIBUTES,
 };
 PTOKEN_MANDATORY_LABEL :: ^struct {
    Label : SID_AND_ATTRIBUTES,
 };

 TOKEN_MANDATORY_POLICY :: struct {
    Policy : u32,
 };
 PTOKEN_MANDATORY_POLICY :: ^struct {
    Policy : u32,
 };

 PSECURITY_ATTRIBUTES_OPAQUE :: PVOID;

 TOKEN_ACCESS_INFORMATION :: struct {
    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              : u32,
    AppContainerNumber : u32,
    PackageSid         : PSID,
    CapabilitiesHash   : PSID_AND_ATTRIBUTES_HASH,
    TrustLevelSid      : PSID,
    SecurityAttributes : PSECURITY_ATTRIBUTES_OPAQUE,
 };
 PTOKEN_ACCESS_INFORMATION :: ^struct {
    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              : u32,
    AppContainerNumber : u32,
    PackageSid         : PSID,
    CapabilitiesHash   : PSID_AND_ATTRIBUTES_HASH,
    TrustLevelSid      : PSID,
    SecurityAttributes : PSECURITY_ATTRIBUTES_OPAQUE,
 };

 TOKEN_AUDIT_POLICY :: struct {
    PerUserPolicy : [(((59)) >> 1) + 1]BYTE,
 };
 PTOKEN_AUDIT_POLICY :: ^struct {
    PerUserPolicy : [(((59)) >> 1) + 1]BYTE,
 };

 TOKEN_SOURCE :: struct {
    SourceName       : [8]CHAR,
    SourceIdentifier : LUID,
 };
 PTOKEN_SOURCE :: ^struct {
    SourceName       : [8]CHAR,
    SourceIdentifier : LUID,
 };

 TOKEN_STATISTICS :: struct {
    TokenId            : LUID,
    AuthenticationId   : LUID,
    ExpirationTime     : LARGE_INTEGER,
    TokenType          : TOKEN_TYPE,
    ImpersonationLevel : SECURITY_IMPERSONATION_LEVEL,
    DynamicCharged     : u32,
    DynamicAvailable   : u32,
    GroupCount         : u32,
    PrivilegeCount     : u32,
    ModifiedId         : LUID,
 };
 PTOKEN_STATISTICS :: ^struct {
    TokenId            : LUID,
    AuthenticationId   : LUID,
    ExpirationTime     : LARGE_INTEGER,
    TokenType          : TOKEN_TYPE,
    ImpersonationLevel : SECURITY_IMPERSONATION_LEVEL,
    DynamicCharged     : u32,
    DynamicAvailable   : u32,
    GroupCount         : u32,
    PrivilegeCount     : u32,
    ModifiedId         : LUID,
 };

 TOKEN_CONTROL :: struct {
    TokenId          : LUID,
    AuthenticationId : LUID,
    ModifiedId       : LUID,
    TokenSource      : TOKEN_SOURCE,
 };
 PTOKEN_CONTROL :: ^struct {
    TokenId          : LUID,
    AuthenticationId : LUID,
    ModifiedId       : LUID,
    TokenSource      : TOKEN_SOURCE,
 };

 TOKEN_ORIGIN :: struct {
    OriginatingLogonSession : LUID,
 };
 PTOKEN_ORIGIN :: ^struct {
    OriginatingLogonSession : LUID,
 };

 MANDATORY_LEVEL :: enum {
    MandatoryLevelUntrusted = 0,
    MandatoryLevelLow,
    MandatoryLevelMedium,
    MandatoryLevelHigh,
    MandatoryLevelSystem,
    MandatoryLevelSecureProcess,
    MandatoryLevelCount,
 };
 PMANDATORY_LEVEL :: ^enum {
    MandatoryLevelUntrusted = 0,
    MandatoryLevelLow,
    MandatoryLevelMedium,
    MandatoryLevelHigh,
    MandatoryLevelSystem,
    MandatoryLevelSecureProcess,
    MandatoryLevelCount,
 };

 TOKEN_APPCONTAINER_INFORMATION :: struct {
    TokenAppContainer : PSID,
 };
 PTOKEN_APPCONTAINER_INFORMATION :: ^struct {
    TokenAppContainer : PSID,
 };

 TOKEN_SID_INFORMATION :: struct {
    Sid : PSID,
 };
 PTOKEN_SID_INFORMATION :: ^struct {
    Sid : PSID,
 };

 TOKEN_BNO_ISOLATION_INFORMATION :: struct {
    IsolationPrefix  : PWSTR,
    IsolationEnabled : BOOLEAN,
 };
 PTOKEN_BNO_ISOLATION_INFORMATION :: ^struct {
    IsolationPrefix  : PWSTR,
    IsolationEnabled : BOOLEAN,
 };

 CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE :: struct {
    Version : DWORD64,
    Name    : PWSTR,
 };
 PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE :: ^struct {
    Version : DWORD64,
    Name    : PWSTR,
 };

 CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE :: struct {
    pValue      : PVOID,
    ValueLength : u32,
 };
 PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE :: ^struct {
    pValue      : PVOID,
    ValueLength : u32,
 };

 CLAIM_SECURITY_ATTRIBUTE_V1 :: struct {
    Name       : PWSTR,
    ValueType  : u16,
    Reserved   : u16,
    Flags      : u32,
    ValueCount : u32,
    Values : struct #raw_union {
        pInt64       : PLONG64,
        pUint64      : PDWORD64,
        ppString     : ^PWSTR,
        pFqbn        : PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE,
        pOctetString : PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE,
    },
 };
 PCLAIM_SECURITY_ATTRIBUTE_V1 :: ^struct {
    Name       : PWSTR,
    ValueType  : u16,
    Reserved   : u16,
    Flags      : u32,
    ValueCount : u32,
    Values : struct #raw_union {
        pInt64       : PLONG64,
        pUint64      : PDWORD64,
        ppString     : ^PWSTR,
        pFqbn        : PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE,
        pOctetString : PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE,
    },
 };

 CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 :: struct {
    Name       : u32,
    ValueType  : u16,
    Reserved   : u16,
    Flags      : u32,
    ValueCount : u32,
    Values : struct #raw_union {
        pInt64       : [1]u32,
        pUint64      : [1]u32,
        ppString     : [1]u32,
        pFqbn        : [1]u32,
        pOctetString : [1]u32,
    },
 };
 PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 :: ^struct {
    Name       : u32,
    ValueType  : u16,
    Reserved   : u16,
    Flags      : u32,
    ValueCount : u32,
    Values : struct #raw_union {
        pInt64       : [1]u32,
        pUint64      : [1]u32,
        ppString     : [1]u32,
        pFqbn        : [1]u32,
        pOctetString : [1]u32,
    },
 };

 CLAIM_SECURITY_ATTRIBUTES_INFORMATION :: struct {
    Version        : u16,
    Reserved       : u16,
    AttributeCount : u32,
    Attribute : struct #raw_union {
        pAttributeV1 : PCLAIM_SECURITY_ATTRIBUTE_V1,
    },
 };
 PCLAIM_SECURITY_ATTRIBUTES_INFORMATION :: ^struct {
    Version        : u16,
    Reserved       : u16,
    AttributeCount : u32,
    Attribute : struct #raw_union {
        pAttributeV1 : PCLAIM_SECURITY_ATTRIBUTE_V1,
    },
 };

 SECURITY_CONTEXT_TRACKING_MODE :: BOOLEAN;
 PSECURITY_CONTEXT_TRACKING_MODE :: ^BOOLEAN;

 SECURITY_QUALITY_OF_SERVICE :: struct {
    Length              : u32,
    ImpersonationLevel  : SECURITY_IMPERSONATION_LEVEL,
    ContextTrackingMode : SECURITY_CONTEXT_TRACKING_MODE,
    EffectiveOnly       : BOOLEAN,
 };
 PSECURITY_QUALITY_OF_SERVICE :: ^struct {
    Length              : u32,
    ImpersonationLevel  : SECURITY_IMPERSONATION_LEVEL,
    ContextTrackingMode : SECURITY_CONTEXT_TRACKING_MODE,
    EffectiveOnly       : BOOLEAN,
 };

 SE_IMPERSONATION_STATE :: struct {
    Token         : PACCESS_TOKEN,
    CopyOnOpen    : BOOLEAN,
    EffectiveOnly : BOOLEAN,
    Level         : SECURITY_IMPERSONATION_LEVEL,
 };
 PSE_IMPERSONATION_STATE :: ^struct {
    Token         : PACCESS_TOKEN,
    CopyOnOpen    : BOOLEAN,
    EffectiveOnly : BOOLEAN,
    Level         : SECURITY_IMPERSONATION_LEVEL,
 };

 SECURITY_INFORMATION :: u32;
 PSECURITY_INFORMATION :: ^u32;

 SE_SIGNING_LEVEL :: BYTE;
 PSE_SIGNING_LEVEL :: ^BYTE;

 SE_IMAGE_SIGNATURE_TYPE :: enum {
    SeImageSignatureNone = 0,
    SeImageSignatureEmbedded,
    SeImageSignatureCache,
    SeImageSignatureCatalogCached,
    SeImageSignatureCatalogNotCached,
    SeImageSignatureCatalogHint,
    SeImageSignaturePackageCatalog,
 };
 PSE_IMAGE_SIGNATURE_TYPE :: ^enum {
    SeImageSignatureNone = 0,
    SeImageSignatureEmbedded,
    SeImageSignatureCache,
    SeImageSignatureCatalogCached,
    SeImageSignatureCatalogNotCached,
    SeImageSignatureCatalogHint,
    SeImageSignaturePackageCatalog,
 };

 SE_LEARNING_MODE_DATA_TYPE :: enum {
    SeLearningModeInvalidType = 0,
    SeLearningModeSettings,
    SeLearningModeMax,
 };

 SECURITY_CAPABILITIES :: struct {
    AppContainerSid : PSID,
    Capabilities    : PSID_AND_ATTRIBUTES,
    CapabilityCount : u32,
    Reserved        : u32,
 };
 PSECURITY_CAPABILITIES :: ^struct {
    AppContainerSid : PSID,
    Capabilities    : PSID_AND_ATTRIBUTES,
    CapabilityCount : u32,
    Reserved        : u32,
 };
 LPSECURITY_CAPABILITIES :: ^struct {
    AppContainerSid : PSID,
    Capabilities    : PSID_AND_ATTRIBUTES,
    CapabilityCount : u32,
    Reserved        : u32,
 };

 JOB_SET_ARRAY :: struct {
    JobHandle   : HANDLE,
    MemberLevel : u32,
    Flags       : u32,
 };
 PJOB_SET_ARRAY :: ^struct {
    JobHandle   : HANDLE,
    MemberLevel : u32,
    Flags       : u32,
 };

 EXCEPTION_REGISTRATION_RECORD :: struct {
    Next    : ^EXCEPTION_REGISTRATION_RECORD,
    Handler : PEXCEPTION_ROUTINE,
 };

 PEXCEPTION_REGISTRATION_RECORD :: ^EXCEPTION_REGISTRATION_RECORD;

 NT_TIB :: struct {
    ExceptionList        : ^EXCEPTION_REGISTRATION_RECORD,
    StackBase            : PVOID,
    StackLimit           : PVOID,
    SubSystemTib         : PVOID,
    FiberData            : PVOID,
    ArbitraryUserPointer : PVOID,
    Self                 : ^NT_TIB,
 };

 PNT_TIB :: ^NT_TIB;

 NT_TIB32 :: struct {
    ExceptionList        : u32,
    StackBase            : u32,
    StackLimit           : u32,
    SubSystemTib         : u32,
    FiberData            : u32,
    ArbitraryUserPointer : u32,
    Self                 : u32,
 };
 PNT_TIB32 :: ^struct {
    ExceptionList        : u32,
    StackBase            : u32,
    StackLimit           : u32,
    SubSystemTib         : u32,
    FiberData            : u32,
    ArbitraryUserPointer : u32,
    Self                 : u32,
 };

 NT_TIB64 :: struct {
    ExceptionList        : DWORD64,
    StackBase            : DWORD64,
    StackLimit           : DWORD64,
    SubSystemTib         : DWORD64,
    FiberData            : DWORD64,
    ArbitraryUserPointer : DWORD64,
    Self                 : DWORD64,
 };
 PNT_TIB64 :: ^struct {
    ExceptionList        : DWORD64,
    StackBase            : DWORD64,
    StackLimit           : DWORD64,
    SubSystemTib         : DWORD64,
    FiberData            : DWORD64,
    ArbitraryUserPointer : DWORD64,
    Self                 : DWORD64,
 };

 UMS_CREATE_THREAD_ATTRIBUTES :: struct {
    UmsVersion        : u32,
    UmsContext        : PVOID,
    UmsCompletionList : PVOID,
 };
 PUMS_CREATE_THREAD_ATTRIBUTES :: ^struct {
    UmsVersion        : u32,
    UmsContext        : PVOID,
    UmsCompletionList : PVOID,
 };

 WOW64_ARCHITECTURE_INFORMATION :: struct {
    Machine       : ,
    KernelMode    : ,
    UserMode      : ,
    Native        : ,
    Process       : ,
    ReservedZero0 : ,
 };

 QUOTA_LIMITS :: struct {
    PagedPoolLimit        : SIZE_T,
    NonPagedPoolLimit     : SIZE_T,
    MinimumWorkingSetSize : SIZE_T,
    MaximumWorkingSetSize : SIZE_T,
    PagefileLimit         : SIZE_T,
    TimeLimit             : LARGE_INTEGER,
 };
 PQUOTA_LIMITS :: ^struct {
    PagedPoolLimit        : SIZE_T,
    NonPagedPoolLimit     : SIZE_T,
    MinimumWorkingSetSize : SIZE_T,
    MaximumWorkingSetSize : SIZE_T,
    PagefileLimit         : SIZE_T,
    TimeLimit             : LARGE_INTEGER,
 };

 RATE_QUOTA_LIMIT :: struct #raw_union {
    RateData : u32,
    s : struct {
        RatePercent : ,
        Reserved0   : ,
    },
 };
 PRATE_QUOTA_LIMIT :: ^struct #raw_union {
    RateData : u32,
    s : struct {
        RatePercent : ,
        Reserved0   : ,
    },
 };

 QUOTA_LIMITS_EX :: struct {
    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                 : u32,
    CpuRateLimit          : RATE_QUOTA_LIMIT,
 };
 PQUOTA_LIMITS_EX :: ^struct {
    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                 : u32,
    CpuRateLimit          : RATE_QUOTA_LIMIT,
 };

 IO_COUNTERS :: struct {
    ReadOperationCount  : ULONGLONG,
    WriteOperationCount : ULONGLONG,
    OtherOperationCount : ULONGLONG,
    ReadTransferCount   : ULONGLONG,
    WriteTransferCount  : ULONGLONG,
    OtherTransferCount  : ULONGLONG,
 };

 PIO_COUNTERS :: ^IO_COUNTERS;

 HARDWARE_COUNTER_TYPE :: enum {
    PMCCounter,
    MaxHardwareCounterType,
 };
 PHARDWARE_COUNTER_TYPE :: ^enum {
    PMCCounter,
    MaxHardwareCounterType,
 };

 PROCESS_MITIGATION_POLICY :: enum {
    ProcessDEPPolicy,
    ProcessASLRPolicy,
    ProcessDynamicCodePolicy,
    ProcessStrictHandleCheckPolicy,
    ProcessSystemCallDisablePolicy,
    ProcessMitigationOptionsMask,
    ProcessExtensionPointDisablePolicy,
    ProcessControlFlowGuardPolicy,
    ProcessSignaturePolicy,
    ProcessFontDisablePolicy,
    ProcessImageLoadPolicy,
    ProcessSystemCallFilterPolicy,
    ProcessPayloadRestrictionPolicy,
    ProcessChildProcessPolicy,
    ProcessSideChannelIsolationPolicy,
    MaxProcessMitigationPolicy,
 };
 PPROCESS_MITIGATION_POLICY :: ^enum {
    ProcessDEPPolicy,
    ProcessASLRPolicy,
    ProcessDynamicCodePolicy,
    ProcessStrictHandleCheckPolicy,
    ProcessSystemCallDisablePolicy,
    ProcessMitigationOptionsMask,
    ProcessExtensionPointDisablePolicy,
    ProcessControlFlowGuardPolicy,
    ProcessSignaturePolicy,
    ProcessFontDisablePolicy,
    ProcessImageLoadPolicy,
    ProcessSystemCallFilterPolicy,
    ProcessPayloadRestrictionPolicy,
    ProcessChildProcessPolicy,
    ProcessSideChannelIsolationPolicy,
    MaxProcessMitigationPolicy,
 };

 PROCESS_MITIGATION_ASLR_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            EnableBottomUpRandomization : ,
            EnableForceRelocateImages   : ,
            EnableHighEntropy           : ,
            DisallowStrippedImages      : ,
            ReservedFlags               : ,
        },
    },
 };
 PPROCESS_MITIGATION_ASLR_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            EnableBottomUpRandomization : ,
            EnableForceRelocateImages   : ,
            EnableHighEntropy           : ,
            DisallowStrippedImages      : ,
            ReservedFlags               : ,
        },
    },
 };

 PROCESS_MITIGATION_DEP_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            Enable                   : ,
            DisableAtlThunkEmulation : ,
            ReservedFlags            : ,
        },
    },
    Permanent : BOOLEAN,
 };
 PPROCESS_MITIGATION_DEP_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            Enable                   : ,
            DisableAtlThunkEmulation : ,
            ReservedFlags            : ,
        },
    },
    Permanent : BOOLEAN,
 };

 PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            RaiseExceptionOnInvalidHandleReference : ,
            HandleExceptionsPermanentlyEnabled     : ,
            ReservedFlags                          : ,
        },
    },
 };
 PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            RaiseExceptionOnInvalidHandleReference : ,
            HandleExceptionsPermanentlyEnabled     : ,
            ReservedFlags                          : ,
        },
    },
 };

 PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            DisallowWin32kSystemCalls      : ,
            AuditDisallowWin32kSystemCalls : ,
            ReservedFlags                  : ,
        },
    },
 };
 PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            DisallowWin32kSystemCalls      : ,
            AuditDisallowWin32kSystemCalls : ,
            ReservedFlags                  : ,
        },
    },
 };

 PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            DisableExtensionPoints : ,
            ReservedFlags          : ,
        },
    },
 };
 PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            DisableExtensionPoints : ,
            ReservedFlags          : ,
        },
    },
 };

 PROCESS_MITIGATION_DYNAMIC_CODE_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            ProhibitDynamicCode      : ,
            AllowThreadOptOut        : ,
            AllowRemoteDowngrade     : ,
            AuditProhibitDynamicCode : ,
            ReservedFlags            : ,
        },
    },
 };
 PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            ProhibitDynamicCode      : ,
            AllowThreadOptOut        : ,
            AllowRemoteDowngrade     : ,
            AuditProhibitDynamicCode : ,
            ReservedFlags            : ,
        },
    },
 };

 PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            EnableControlFlowGuard  : ,
            EnableExportSuppression : ,
            StrictMode              : ,
            ReservedFlags           : ,
        },
    },
 };
 PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            EnableControlFlowGuard  : ,
            EnableExportSuppression : ,
            StrictMode              : ,
            ReservedFlags           : ,
        },
    },
 };

 PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            MicrosoftSignedOnly      : ,
            StoreSignedOnly          : ,
            MitigationOptIn          : ,
            AuditMicrosoftSignedOnly : ,
            AuditStoreSignedOnly     : ,
            ReservedFlags            : ,
        },
    },
 };
 PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            MicrosoftSignedOnly      : ,
            StoreSignedOnly          : ,
            MitigationOptIn          : ,
            AuditMicrosoftSignedOnly : ,
            AuditStoreSignedOnly     : ,
            ReservedFlags            : ,
        },
    },
 };

 PROCESS_MITIGATION_FONT_DISABLE_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            DisableNonSystemFonts     : ,
            AuditNonSystemFontLoading : ,
            ReservedFlags             : ,
        },
    },
 };
 PPROCESS_MITIGATION_FONT_DISABLE_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            DisableNonSystemFonts     : ,
            AuditNonSystemFontLoading : ,
            ReservedFlags             : ,
        },
    },
 };

 PROCESS_MITIGATION_IMAGE_LOAD_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            NoRemoteImages                 : ,
            NoLowMandatoryLabelImages      : ,
            PreferSystem32Images           : ,
            AuditNoRemoteImages            : ,
            AuditNoLowMandatoryLabelImages : ,
            ReservedFlags                  : ,
        },
    },
 };
 PPROCESS_MITIGATION_IMAGE_LOAD_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            NoRemoteImages                 : ,
            NoLowMandatoryLabelImages      : ,
            PreferSystem32Images           : ,
            AuditNoRemoteImages            : ,
            AuditNoLowMandatoryLabelImages : ,
            ReservedFlags                  : ,
        },
    },
 };

 PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            FilterId      : ,
            ReservedFlags : ,
        },
    },
 };
 PPROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            FilterId      : ,
            ReservedFlags : ,
        },
    },
 };

 PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            EnableExportAddressFilter     : ,
            AuditExportAddressFilter      : ,
            EnableExportAddressFilterPlus : ,
            AuditExportAddressFilterPlus  : ,
            EnableImportAddressFilter     : ,
            AuditImportAddressFilter      : ,
            EnableRopStackPivot           : ,
            AuditRopStackPivot            : ,
            EnableRopCallerCheck          : ,
            AuditRopCallerCheck           : ,
            EnableRopSimExec              : ,
            AuditRopSimExec               : ,
            ReservedFlags                 : ,
        },
    },
 };
 PPROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            EnableExportAddressFilter     : ,
            AuditExportAddressFilter      : ,
            EnableExportAddressFilterPlus : ,
            AuditExportAddressFilterPlus  : ,
            EnableImportAddressFilter     : ,
            AuditImportAddressFilter      : ,
            EnableRopStackPivot           : ,
            AuditRopStackPivot            : ,
            EnableRopCallerCheck          : ,
            AuditRopCallerCheck           : ,
            EnableRopSimExec              : ,
            AuditRopSimExec               : ,
            ReservedFlags                 : ,
        },
    },
 };

 PROCESS_MITIGATION_CHILD_PROCESS_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            NoChildProcessCreation      : ,
            AuditNoChildProcessCreation : ,
            AllowSecureProcessCreation  : ,
            ReservedFlags               : ,
        },
    },
 };
 PPROCESS_MITIGATION_CHILD_PROCESS_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            NoChildProcessCreation      : ,
            AuditNoChildProcessCreation : ,
            AllowSecureProcessCreation  : ,
            ReservedFlags               : ,
        },
    },
 };

 PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY :: struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            SmtBranchTargetIsolation      : ,
            IsolateSecurityDomain         : ,
            DisablePageCombine            : ,
            SpeculativeStoreBypassDisable : ,
            ReservedFlags                 : ,
        },
    },
 };
 PPROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY :: ^struct {
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            SmtBranchTargetIsolation      : ,
            IsolateSecurityDomain         : ,
            DisablePageCombine            : ,
            SpeculativeStoreBypassDisable : ,
            ReservedFlags                 : ,
        },
    },
 };

 JOBOBJECT_BASIC_ACCOUNTING_INFORMATION :: struct {
    TotalUserTime             : LARGE_INTEGER,
    TotalKernelTime           : LARGE_INTEGER,
    ThisPeriodTotalUserTime   : LARGE_INTEGER,
    ThisPeriodTotalKernelTime : LARGE_INTEGER,
    TotalPageFaultCount       : u32,
    TotalProcesses            : u32,
    ActiveProcesses           : u32,
    TotalTerminatedProcesses  : u32,
 };
 PJOBOBJECT_BASIC_ACCOUNTING_INFORMATION :: ^struct {
    TotalUserTime             : LARGE_INTEGER,
    TotalKernelTime           : LARGE_INTEGER,
    ThisPeriodTotalUserTime   : LARGE_INTEGER,
    ThisPeriodTotalKernelTime : LARGE_INTEGER,
    TotalPageFaultCount       : u32,
    TotalProcesses            : u32,
    ActiveProcesses           : u32,
    TotalTerminatedProcesses  : u32,
 };

 JOBOBJECT_BASIC_LIMIT_INFORMATION :: struct {
    PerProcessUserTimeLimit : LARGE_INTEGER,
    PerJobUserTimeLimit     : LARGE_INTEGER,
    LimitFlags              : u32,
    MinimumWorkingSetSize   : SIZE_T,
    MaximumWorkingSetSize   : SIZE_T,
    ActiveProcessLimit      : u32,
    Affinity                : ULONG_PTR,
    PriorityClass           : u32,
    SchedulingClass         : u32,
 };
 PJOBOBJECT_BASIC_LIMIT_INFORMATION :: ^struct {
    PerProcessUserTimeLimit : LARGE_INTEGER,
    PerJobUserTimeLimit     : LARGE_INTEGER,
    LimitFlags              : u32,
    MinimumWorkingSetSize   : SIZE_T,
    MaximumWorkingSetSize   : SIZE_T,
    ActiveProcessLimit      : u32,
    Affinity                : ULONG_PTR,
    PriorityClass           : u32,
    SchedulingClass         : u32,
 };

 JOBOBJECT_EXTENDED_LIMIT_INFORMATION :: struct {
    BasicLimitInformation : JOBOBJECT_BASIC_LIMIT_INFORMATION,
    IoInfo                : IO_COUNTERS,
    ProcessMemoryLimit    : SIZE_T,
    JobMemoryLimit        : SIZE_T,
    PeakProcessMemoryUsed : SIZE_T,
    PeakJobMemoryUsed     : SIZE_T,
 };
 PJOBOBJECT_EXTENDED_LIMIT_INFORMATION :: ^struct {
    BasicLimitInformation : JOBOBJECT_BASIC_LIMIT_INFORMATION,
    IoInfo                : IO_COUNTERS,
    ProcessMemoryLimit    : SIZE_T,
    JobMemoryLimit        : SIZE_T,
    PeakProcessMemoryUsed : SIZE_T,
    PeakJobMemoryUsed     : SIZE_T,
 };

 JOBOBJECT_BASIC_PROCESS_ID_LIST :: struct {
    NumberOfAssignedProcesses : u32,
    NumberOfProcessIdsInList  : u32,
    ProcessIdList             : [1]ULONG_PTR,
 };
 PJOBOBJECT_BASIC_PROCESS_ID_LIST :: ^struct {
    NumberOfAssignedProcesses : u32,
    NumberOfProcessIdsInList  : u32,
    ProcessIdList             : [1]ULONG_PTR,
 };

 JOBOBJECT_BASIC_UI_RESTRICTIONS :: struct {
    UIRestrictionsClass : u32,
 };
 PJOBOBJECT_BASIC_UI_RESTRICTIONS :: ^struct {
    UIRestrictionsClass : u32,
 };

 JOBOBJECT_SECURITY_LIMIT_INFORMATION :: struct {
    SecurityLimitFlags : u32,
    JobToken           : HANDLE,
    SidsToDisable      : PTOKEN_GROUPS,
    PrivilegesToDelete : PTOKEN_PRIVILEGES,
    RestrictedSids     : PTOKEN_GROUPS,
 };
 PJOBOBJECT_SECURITY_LIMIT_INFORMATION :: ^struct {
    SecurityLimitFlags : u32,
    JobToken           : HANDLE,
    SidsToDisable      : PTOKEN_GROUPS,
    PrivilegesToDelete : PTOKEN_PRIVILEGES,
    RestrictedSids     : PTOKEN_GROUPS,
 };

 JOBOBJECT_END_OF_JOB_TIME_INFORMATION :: struct {
    EndOfJobTimeAction : u32,
 };
 PJOBOBJECT_END_OF_JOB_TIME_INFORMATION :: ^struct {
    EndOfJobTimeAction : u32,
 };

 JOBOBJECT_ASSOCIATE_COMPLETION_PORT :: struct {
    CompletionKey  : PVOID,
    CompletionPort : HANDLE,
 };
 PJOBOBJECT_ASSOCIATE_COMPLETION_PORT :: ^struct {
    CompletionKey  : PVOID,
    CompletionPort : HANDLE,
 };

 JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION :: struct {
    BasicInfo : JOBOBJECT_BASIC_ACCOUNTING_INFORMATION,
    IoInfo    : IO_COUNTERS,
 };
 PJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION :: ^struct {
    BasicInfo : JOBOBJECT_BASIC_ACCOUNTING_INFORMATION,
    IoInfo    : IO_COUNTERS,
 };

 JOBOBJECT_JOBSET_INFORMATION :: struct {
    MemberLevel : u32,
 };
 PJOBOBJECT_JOBSET_INFORMATION :: ^struct {
    MemberLevel : u32,
 };

 JOBOBJECT_RATE_CONTROL_TOLERANCE :: enum {
    ToleranceLow = 1,
    ToleranceMedium,
    ToleranceHigh,
 };
 PJOBOBJECT_RATE_CONTROL_TOLERANCE :: ^enum {
    ToleranceLow = 1,
    ToleranceMedium,
    ToleranceHigh,
 };

 JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: enum {
    ToleranceIntervalShort = 1,
    ToleranceIntervalMedium,
    ToleranceIntervalLong,
 };
 PJOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: ^enum {
    ToleranceIntervalShort = 1,
    ToleranceIntervalMedium,
    ToleranceIntervalLong,
 };

 JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION :: struct {
    IoReadBytesLimit             : DWORD64,
    IoWriteBytesLimit            : DWORD64,
    PerJobUserTimeLimit          : LARGE_INTEGER,
    JobMemoryLimit               : DWORD64,
    RateControlTolerance         : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    RateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
    LimitFlags                   : u32,
 };
 PJOBOBJECT_NOTIFICATION_LIMIT_INFORMATION :: ^struct {
    IoReadBytesLimit             : DWORD64,
    IoWriteBytesLimit            : DWORD64,
    PerJobUserTimeLimit          : LARGE_INTEGER,
    JobMemoryLimit               : DWORD64,
    RateControlTolerance         : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    RateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
    LimitFlags                   : u32,
 };

 JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2 :: struct {
    IoReadBytesLimit                : DWORD64,
    IoWriteBytesLimit               : DWORD64,
    PerJobUserTimeLimit             : LARGE_INTEGER,
    u : struct #raw_union {
        JobHighMemoryLimit : DWORD64,
        JobMemoryLimit     : DWORD64,
    },
    u2 : struct #raw_union {
        RateControlTolerance    : JOBOBJECT_RATE_CONTROL_TOLERANCE,
        CpuRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    },
    u3 : struct #raw_union {
        RateControlToleranceInterval    : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
        CpuRateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
    },
    LimitFlags                      : u32,
    IoRateControlTolerance          : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    JobLowMemoryLimit               : DWORD64,
    IoRateControlToleranceInterval  : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
    NetRateControlTolerance         : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    NetRateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL,
 };

 JOBOBJECT_LIMIT_VIOLATION_INFORMATION :: struct {
    LimitFlags                : u32,
    ViolationLimitFlags       : u32,
    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,
 };
 PJOBOBJECT_LIMIT_VIOLATION_INFORMATION :: ^struct {
    LimitFlags                : u32,
    ViolationLimitFlags       : u32,
    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,
 };

 JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2 :: struct {
    LimitFlags                   : u32,
    ViolationLimitFlags          : u32,
    IoReadBytes                  : DWORD64,
    IoReadBytesLimit             : DWORD64,
    IoWriteBytes                 : DWORD64,
    IoWriteBytesLimit            : DWORD64,
    PerJobUserTime               : LARGE_INTEGER,
    PerJobUserTimeLimit          : LARGE_INTEGER,
    JobMemory                    : DWORD64,
    u : struct #raw_union {
        JobHighMemoryLimit : DWORD64,
        JobMemoryLimit     : DWORD64,
    },
    u2 : struct #raw_union {
        RateControlTolerance    : JOBOBJECT_RATE_CONTROL_TOLERANCE,
        CpuRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    },
    u3 : struct #raw_union {
        RateControlToleranceLimit    : JOBOBJECT_RATE_CONTROL_TOLERANCE,
        CpuRateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    },
    JobLowMemoryLimit            : DWORD64,
    IoRateControlTolerance       : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    IoRateControlToleranceLimit  : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    NetRateControlTolerance      : JOBOBJECT_RATE_CONTROL_TOLERANCE,
    NetRateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE,
 };

 JOBOBJECT_CPU_RATE_CONTROL_INFORMATION :: struct {
    ControlFlags : u32,
    u : struct #raw_union {
        CpuRate : u32,
        Weight  : u32,
        s : struct {
            MinRate : u16,
            MaxRate : u16,
        },
    },
 };
 PJOBOBJECT_CPU_RATE_CONTROL_INFORMATION :: ^struct {
    ControlFlags : u32,
    u : struct #raw_union {
        CpuRate : u32,
        Weight  : u32,
        s : struct {
            MinRate : u16,
            MaxRate : u16,
        },
    },
 };

 JOB_OBJECT_NET_RATE_CONTROL_FLAGS :: enum {
    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,
 };

 __C_ASSERT__ :: [(JOB_OBJECT_NET_RATE_CONTROL_VALID_FLAGS == (JOB_OBJECT_NET_RATE_CONTROL_ENABLE + JOB_OBJECT_NET_RATE_CONTROL_MAX_BANDWIDTH + JOB_OBJECT_NET_RATE_CONTROL_DSCP_TAG)) ? 1 : -1]u8;

 JOBOBJECT_NET_RATE_CONTROL_INFORMATION :: struct {
    MaxBandwidth : DWORD64,
    ControlFlags : JOB_OBJECT_NET_RATE_CONTROL_FLAGS,
    DscpTag      : BYTE,
 };

 JOB_OBJECT_IO_RATE_CONTROL_FLAGS :: enum {
    JOB_OBJECT_IO_RATE_CONTROL_ENABLE = 0x1,
    JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME = 0x2,
    JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ALL = 0x4,
    JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ON_SOFT_CAP = 0x8,
    JOB_OBJECT_IO_RATE_CONTROL_VALID_FLAGS =     JOB_OBJECT_IO_RATE_CONTROL_ENABLE | JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME | JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ALL | JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ON_SOFT_CAP,
 };

 JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE :: struct {
    MaxIops          : LONG64,
    MaxBandwidth     : LONG64,
    ReservationIops  : LONG64,
    VolumeName       : PWSTR,
    BaseIoSize       : u32,
    ControlFlags     : JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
    VolumeNameLength : u16,
 };

 JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V1 :: JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE;

 JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V2 :: struct {
    MaxIops                        : LONG64,
    MaxBandwidth                   : LONG64,
    ReservationIops                : LONG64,
    VolumeName                     : PWSTR,
    BaseIoSize                     : u32,
    ControlFlags                   : JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
    VolumeNameLength               : u16,
    CriticalReservationIops        : LONG64,
    ReservationBandwidth           : LONG64,
    CriticalReservationBandwidth   : LONG64,
    MaxTimePercent                 : LONG64,
    ReservationTimePercent         : LONG64,
    CriticalReservationTimePercent : LONG64,
 };

 JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V3 :: struct {
    MaxIops                        : LONG64,
    MaxBandwidth                   : LONG64,
    ReservationIops                : LONG64,
    VolumeName                     : PWSTR,
    BaseIoSize                     : u32,
    ControlFlags                   : JOB_OBJECT_IO_RATE_CONTROL_FLAGS,
    VolumeNameLength               : u16,
    CriticalReservationIops        : LONG64,
    ReservationBandwidth           : LONG64,
    CriticalReservationBandwidth   : LONG64,
    MaxTimePercent                 : LONG64,
    ReservationTimePercent         : LONG64,
    CriticalReservationTimePercent : LONG64,
    SoftMaxIops                    : LONG64,
    SoftMaxBandwidth               : LONG64,
    SoftMaxTimePercent             : LONG64,
    LimitExcessNotifyIops          : LONG64,
    LimitExcessNotifyBandwidth     : LONG64,
    LimitExcessNotifyTimePercent   : LONG64,
 };

 JOBOBJECT_IO_ATTRIBUTION_CONTROL_FLAGS :: enum {
    JOBOBJECT_IO_ATTRIBUTION_CONTROL_ENABLE = 0x1,
    JOBOBJECT_IO_ATTRIBUTION_CONTROL_DISABLE = 0x2,
    JOBOBJECT_IO_ATTRIBUTION_CONTROL_VALID_FLAGS = 0x3,
 };

 JOBOBJECT_IO_ATTRIBUTION_STATS :: struct {
    IoCount                       : ULONG_PTR,
    TotalNonOverlappedQueueTime   : ULONGLONG,
    TotalNonOverlappedServiceTime : ULONGLONG,
    TotalSize                     : ULONGLONG,
 };
 PJOBOBJECT_IO_ATTRIBUTION_STATS :: ^struct {
    IoCount                       : ULONG_PTR,
    TotalNonOverlappedQueueTime   : ULONGLONG,
    TotalNonOverlappedServiceTime : ULONGLONG,
    TotalSize                     : ULONGLONG,
 };

 JOBOBJECT_IO_ATTRIBUTION_INFORMATION :: struct {
    ControlFlags : u32,
    ReadStats    : JOBOBJECT_IO_ATTRIBUTION_STATS,
    WriteStats   : JOBOBJECT_IO_ATTRIBUTION_STATS,
 };
 PJOBOBJECT_IO_ATTRIBUTION_INFORMATION :: ^struct {
    ControlFlags : u32,
    ReadStats    : JOBOBJECT_IO_ATTRIBUTION_STATS,
    WriteStats   : JOBOBJECT_IO_ATTRIBUTION_STATS,
 };

 JOBOBJECTINFOCLASS :: enum {
    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,
 };

 SILOOBJECT_BASIC_INFORMATION :: struct {
    SiloId            : u32,
    SiloParentId      : u32,
    NumberOfProcesses : u32,
    IsInServerSilo    : BOOLEAN,
    Reserved          : [3]BYTE,
 };
 PSILOOBJECT_BASIC_INFORMATION :: ^struct {
    SiloId            : u32,
    SiloParentId      : u32,
    NumberOfProcesses : u32,
    IsInServerSilo    : BOOLEAN,
    Reserved          : [3]BYTE,
 };

 SERVERSILO_STATE :: enum {
    SERVERSILO_INITING = 0,
    SERVERSILO_STARTED,
    SERVERSILO_SHUTTING_DOWN,
    SERVERSILO_TERMINATING,
    SERVERSILO_TERMINATED,
 };
 PSERVERSILO_STATE :: ^enum {
    SERVERSILO_INITING = 0,
    SERVERSILO_STARTED,
    SERVERSILO_SHUTTING_DOWN,
    SERVERSILO_TERMINATING,
    SERVERSILO_TERMINATED,
 };

 SERVERSILO_BASIC_INFORMATION :: struct {
    ServiceSessionId : u32,
    State            : SERVERSILO_STATE,
    ExitStatus       : u32,
 };
 PSERVERSILO_BASIC_INFORMATION :: ^struct {
    ServiceSessionId : u32,
    State            : SERVERSILO_STATE,
    ExitStatus       : u32,
 };

 FIRMWARE_TYPE :: enum {
    FirmwareTypeUnknown,
    FirmwareTypeBios,
    FirmwareTypeUefi,
    FirmwareTypeMax,
 };
 PFIRMWARE_TYPE :: ^enum {
    FirmwareTypeUnknown,
    FirmwareTypeBios,
    FirmwareTypeUefi,
    FirmwareTypeMax,
 };

 LOGICAL_PROCESSOR_RELATIONSHIP :: enum {
    RelationProcessorCore,
    RelationNumaNode,
    RelationCache,
    RelationProcessorPackage,
    RelationGroup,
    RelationAll = 0xffff,
 };

 PROCESSOR_CACHE_TYPE :: enum {
    CacheUnified,
    CacheInstruction,
    CacheData,
    CacheTrace,
 };

 CACHE_DESCRIPTOR :: struct {
    Level         : BYTE,
    Associativity : BYTE,
    LineSize      : u16,
    Size          : u32,
    Type          : PROCESSOR_CACHE_TYPE,
 };
 PCACHE_DESCRIPTOR :: ^struct {
    Level         : BYTE,
    Associativity : BYTE,
    LineSize      : u16,
    Size          : u32,
    Type          : PROCESSOR_CACHE_TYPE,
 };

 SYSTEM_LOGICAL_PROCESSOR_INFORMATION :: struct {
    ProcessorMask : ULONG_PTR,
    Relationship  : LOGICAL_PROCESSOR_RELATIONSHIP,
    u : struct #raw_union {
        ProcessorCore : struct {
            Flags : BYTE,
        },
        NumaNode : struct {
            NodeNumber : u32,
        },
        Cache         : CACHE_DESCRIPTOR,
        Reserved      : [2]ULONGLONG,
    },
 };
 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION :: ^struct {
    ProcessorMask : ULONG_PTR,
    Relationship  : LOGICAL_PROCESSOR_RELATIONSHIP,
    u : struct #raw_union {
        ProcessorCore : struct {
            Flags : BYTE,
        },
        NumaNode : struct {
            NodeNumber : u32,
        },
        Cache         : CACHE_DESCRIPTOR,
        Reserved      : [2]ULONGLONG,
    },
 };

 PROCESSOR_RELATIONSHIP :: struct {
    Flags           : BYTE,
    EfficiencyClass : BYTE,
    Reserved        : [20]BYTE,
    GroupCount      : u16,
    GroupMask       : [1]GROUP_AFFINITY,
 };
 PPROCESSOR_RELATIONSHIP :: ^struct {
    Flags           : BYTE,
    EfficiencyClass : BYTE,
    Reserved        : [20]BYTE,
    GroupCount      : u16,
    GroupMask       : [1]GROUP_AFFINITY,
 };

 NUMA_NODE_RELATIONSHIP :: struct {
    NodeNumber : u32,
    Reserved   : [20]BYTE,
    GroupMask  : GROUP_AFFINITY,
 };
 PNUMA_NODE_RELATIONSHIP :: ^struct {
    NodeNumber : u32,
    Reserved   : [20]BYTE,
    GroupMask  : GROUP_AFFINITY,
 };

 CACHE_RELATIONSHIP :: struct {
    Level         : BYTE,
    Associativity : BYTE,
    LineSize      : u16,
    CacheSize     : u32,
    Type          : PROCESSOR_CACHE_TYPE,
    Reserved      : [20]BYTE,
    GroupMask     : GROUP_AFFINITY,
 };
 PCACHE_RELATIONSHIP :: ^struct {
    Level         : BYTE,
    Associativity : BYTE,
    LineSize      : u16,
    CacheSize     : u32,
    Type          : PROCESSOR_CACHE_TYPE,
    Reserved      : [20]BYTE,
    GroupMask     : GROUP_AFFINITY,
 };

 PROCESSOR_GROUP_INFO :: struct {
    MaximumProcessorCount : BYTE,
    ActiveProcessorCount  : BYTE,
    Reserved              : [38]BYTE,
    ActiveProcessorMask   : KAFFINITY,
 };
 PPROCESSOR_GROUP_INFO :: ^struct {
    MaximumProcessorCount : BYTE,
    ActiveProcessorCount  : BYTE,
    Reserved              : [38]BYTE,
    ActiveProcessorMask   : KAFFINITY,
 };

 GROUP_RELATIONSHIP :: struct {
    MaximumGroupCount : u16,
    ActiveGroupCount  : u16,
    Reserved          : [20]BYTE,
    GroupInfo         : [1]PROCESSOR_GROUP_INFO,
 };
 PGROUP_RELATIONSHIP :: ^struct {
    MaximumGroupCount : u16,
    ActiveGroupCount  : u16,
    Reserved          : [20]BYTE,
    GroupInfo         : [1]PROCESSOR_GROUP_INFO,
 };

 SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX :: struct {
    Relationship : LOGICAL_PROCESSOR_RELATIONSHIP,
    Size         : u32,
    u : struct #raw_union {
        Processor : PROCESSOR_RELATIONSHIP,
        NumaNode  : NUMA_NODE_RELATIONSHIP,
        Cache     : CACHE_RELATIONSHIP,
        Group     : GROUP_RELATIONSHIP,
    },
 };

 SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX :: struct {};

 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX :: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;

 CPU_SET_INFORMATION_TYPE :: enum {
    CpuSetInformation,
 };
 PCPU_SET_INFORMATION_TYPE :: ^enum {
    CpuSetInformation,
 };

 SYSTEM_CPU_SET_INFORMATION :: struct {
    Size : u32,
    Type : CPU_SET_INFORMATION_TYPE,
    u : struct #raw_union {
        CpuSet : struct {
            Id                    : u32,
            Group                 : u16,
            LogicalProcessorIndex : BYTE,
            CoreIndex             : BYTE,
            LastLevelCacheIndex   : BYTE,
            NumaNodeIndex         : BYTE,
            EfficiencyClass       : BYTE,
            u2 : struct #raw_union {
                AllFlags : BYTE,
                s : struct {
                    Parked                   : ,
                    Allocated                : ,
                    AllocatedToTargetProcess : ,
                    RealTime                 : ,
                    ReservedFlags            : ,
                },
            },
            using _ : struct #raw_union {
                Reserved        : u32,
                SchedulingClass : BYTE,
            },
            AllocationTag         : DWORD64,
        },
    },
 };

 SYSTEM_CPU_SET_INFORMATION :: struct {};

 PSYSTEM_CPU_SET_INFORMATION :: ^SYSTEM_CPU_SET_INFORMATION;

 SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION :: struct {
    CycleTime : DWORD64,
 };
 PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION :: ^struct {
    CycleTime : DWORD64,
 };

 XSTATE_FEATURE :: struct {
    Offset : u32,
    Size   : u32,
 };
 PXSTATE_FEATURE :: ^struct {
    Offset : u32,
    Size   : u32,
 };

 XSTATE_CONFIGURATION :: struct {
    EnabledFeatures                      : DWORD64,
    EnabledVolatileFeatures              : DWORD64,
    Size                                 : u32,
    using _ : struct #raw_union {
        ControlFlags : u32,
        using _ : struct {
            OptimizedSave     : ,
            CompactionEnabled : ,
        },
    },
    Features                             : [(64)]XSTATE_FEATURE,
    EnabledSupervisorFeatures            : DWORD64,
    AlignedFeatures                      : DWORD64,
    AllFeatureSize                       : u32,
    AllFeatures                          : [(64)]u32,
    EnabledUserVisibleSupervisorFeatures : DWORD64,
 };
 PXSTATE_CONFIGURATION :: ^struct {
    EnabledFeatures                      : DWORD64,
    EnabledVolatileFeatures              : DWORD64,
    Size                                 : u32,
    using _ : struct #raw_union {
        ControlFlags : u32,
        using _ : struct {
            OptimizedSave     : ,
            CompactionEnabled : ,
        },
    },
    Features                             : [(64)]XSTATE_FEATURE,
    EnabledSupervisorFeatures            : DWORD64,
    AlignedFeatures                      : DWORD64,
    AllFeatureSize                       : u32,
    AllFeatures                          : [(64)]u32,
    EnabledUserVisibleSupervisorFeatures : DWORD64,
 };

 MEMORY_BASIC_INFORMATION :: struct {
    BaseAddress       : PVOID,
    AllocationBase    : PVOID,
    AllocationProtect : u32,
    RegionSize        : SIZE_T,
    State             : u32,
    Protect           : u32,
    Type              : u32,
 };
 PMEMORY_BASIC_INFORMATION :: ^struct {
    BaseAddress       : PVOID,
    AllocationBase    : PVOID,
    AllocationProtect : u32,
    RegionSize        : SIZE_T,
    State             : u32,
    Protect           : u32,
    Type              : u32,
 };

 MEMORY_BASIC_INFORMATION32 :: struct {
    BaseAddress       : u32,
    AllocationBase    : u32,
    AllocationProtect : u32,
    RegionSize        : u32,
    State             : u32,
    Protect           : u32,
    Type              : u32,
 };
 PMEMORY_BASIC_INFORMATION32 :: ^struct {
    BaseAddress       : u32,
    AllocationBase    : u32,
    AllocationProtect : u32,
    RegionSize        : u32,
    State             : u32,
    Protect           : u32,
    Type              : u32,
 };

 MEMORY_BASIC_INFORMATION64 :: struct {
    BaseAddress       : ULONGLONG,
    AllocationBase    : ULONGLONG,
    AllocationProtect : u32,
    __alignment1      : u32,
    RegionSize        : ULONGLONG,
    State             : u32,
    Protect           : u32,
    Type              : u32,
    __alignment2      : u32,
 };
 PMEMORY_BASIC_INFORMATION64 :: ^struct {
    BaseAddress       : ULONGLONG,
    AllocationBase    : ULONGLONG,
    AllocationProtect : u32,
    __alignment1      : u32,
    RegionSize        : ULONGLONG,
    State             : u32,
    Protect           : u32,
    Type              : u32,
    __alignment2      : u32,
 };

 CFG_CALL_TARGET_INFO :: struct {
    Offset : ULONG_PTR,
    Flags  : ULONG_PTR,
 };
 PCFG_CALL_TARGET_INFO :: ^struct {
    Offset : ULONG_PTR,
    Flags  : ULONG_PTR,
 };

 MEM_ADDRESS_REQUIREMENTS :: struct {
    LowestStartingAddress : PVOID,
    HighestEndingAddress  : PVOID,
    Alignment             : SIZE_T,
 };
 PMEM_ADDRESS_REQUIREMENTS :: ^struct {
    LowestStartingAddress : PVOID,
    HighestEndingAddress  : PVOID,
    Alignment             : SIZE_T,
 };

 MEM_EXTENDED_PARAMETER_TYPE :: enum {
    MemExtendedParameterInvalidType = 0,
    MemExtendedParameterAddressRequirements,
    MemExtendedParameterNumaNode,
    MemExtendedParameterPartitionHandle,
    MemExtendedParameterUserPhysicalHandle,
    MemExtendedParameterAttributeFlags,
    MemExtendedParameterMax,
 };
 PMEM_EXTENDED_PARAMETER_TYPE :: ^enum {
    MemExtendedParameterInvalidType = 0,
    MemExtendedParameterAddressRequirements,
    MemExtendedParameterNumaNode,
    MemExtendedParameterPartitionHandle,
    MemExtendedParameterUserPhysicalHandle,
    MemExtendedParameterAttributeFlags,
    MemExtendedParameterMax,
 };

 MEM_EXTENDED_PARAMETER :: struct {
    s : struct {
        Type     : ,
        Reserved : ,
    },
    u : struct #raw_union {
        ULong64 : DWORD64,
        Pointer : PVOID,
        Size    : SIZE_T,
        Handle  : HANDLE,
        ULong   : u32,
    },
 };
 PMEM_EXTENDED_PARAMETER :: ^struct {
    s : struct {
        Type     : ,
        Reserved : ,
    },
    u : struct #raw_union {
        ULong64 : DWORD64,
        Pointer : PVOID,
        Size    : SIZE_T,
        Handle  : HANDLE,
        ULong   : u32,
    },
 };

 MEM_SECTION_EXTENDED_PARAMETER_TYPE :: enum {
    MemSectionExtendedParameterInvalidType = 0,
    MemSectionExtendedParameterUserPhysicalFlags,
    MemSectionExtendedParameterNumaNode,
    MemSectionExtendedParameterMax,
 };
 PMEM_SECTION_EXTENDED_PARAMETER_TYPE :: ^enum {
    MemSectionExtendedParameterInvalidType = 0,
    MemSectionExtendedParameterUserPhysicalFlags,
    MemSectionExtendedParameterNumaNode,
    MemSectionExtendedParameterMax,
 };

 ENCLAVE_CREATE_INFO_SGX :: struct {
    Secs : [4096]BYTE,
 };
 PENCLAVE_CREATE_INFO_SGX :: ^struct {
    Secs : [4096]BYTE,
 };

 ENCLAVE_INIT_INFO_SGX :: struct {
    SigStruct  : [1808]BYTE,
    Reserved1  : [240]BYTE,
    EInitToken : [304]BYTE,
    Reserved2  : [1744]BYTE,
 };
 PENCLAVE_INIT_INFO_SGX :: ^struct {
    SigStruct  : [1808]BYTE,
    Reserved1  : [240]BYTE,
    EInitToken : [304]BYTE,
    Reserved2  : [1744]BYTE,
 };

 ENCLAVE_CREATE_INFO_VBS :: struct {
    Flags   : u32,
    OwnerID : [32]BYTE,
 };
 PENCLAVE_CREATE_INFO_VBS :: ^struct {
    Flags   : u32,
    OwnerID : [32]BYTE,
 };

 ENCLAVE_CREATE_INFO_VBS_BASIC :: struct {
    Flags   : u32,
    OwnerID : [32]BYTE,
 };
 PENCLAVE_CREATE_INFO_VBS_BASIC :: ^struct {
    Flags   : u32,
    OwnerID : [32]BYTE,
 };

 ENCLAVE_LOAD_DATA_VBS_BASIC :: struct {
    PageType : u32,
 };
 PENCLAVE_LOAD_DATA_VBS_BASIC :: ^struct {
    PageType : u32,
 };

 ENCLAVE_INIT_INFO_VBS_BASIC :: struct {
    FamilyId    : [16]BYTE,
    ImageId     : [16]BYTE,
    EnclaveSize : ULONGLONG,
    EnclaveSvn  : u32,
    Reserved    : u32,
    u : struct #raw_union {
        SignatureInfoHandle : HANDLE,
        Unused              : ULONGLONG,
    },
 };
 PENCLAVE_INIT_INFO_VBS_BASIC :: ^struct {
    FamilyId    : [16]BYTE,
    ImageId     : [16]BYTE,
    EnclaveSize : ULONGLONG,
    EnclaveSvn  : u32,
    Reserved    : u32,
    u : struct #raw_union {
        SignatureInfoHandle : HANDLE,
        Unused              : ULONGLONG,
    },
 };

 ENCLAVE_INIT_INFO_VBS :: struct {
    Length      : u32,
    ThreadCount : u32,
 };
 PENCLAVE_INIT_INFO_VBS :: ^struct {
    Length      : u32,
    ThreadCount : u32,
 };

 ENCLAVE_TARGET_FUNCTION :: #type (proc(PVOID) -> PVOID);

 PENCLAVE_TARGET_FUNCTION :: ^ENCLAVE_TARGET_FUNCTION;

 LPENCLAVE_TARGET_FUNCTION :: PENCLAVE_TARGET_FUNCTION;

 FILE_ID_128 :: struct {
    Identifier : [16]BYTE,
 };
 PFILE_ID_128 :: ^struct {
    Identifier : [16]BYTE,
 };

 FILE_NOTIFY_INFORMATION :: struct {
    NextEntryOffset : u32,
    Action          : u32,
    FileNameLength  : u32,
    FileName        : [1]WCHAR,
 };
 PFILE_NOTIFY_INFORMATION :: ^struct {
    NextEntryOffset : u32,
    Action          : u32,
    FileNameLength  : u32,
    FileName        : [1]WCHAR,
 };

 FILE_NOTIFY_EXTENDED_INFORMATION :: struct {
    NextEntryOffset      : u32,
    Action               : u32,
    CreationTime         : LARGE_INTEGER,
    LastModificationTime : LARGE_INTEGER,
    LastChangeTime       : LARGE_INTEGER,
    LastAccessTime       : LARGE_INTEGER,
    AllocatedLength      : LARGE_INTEGER,
    FileSize             : LARGE_INTEGER,
    FileAttributes       : u32,
    ReparsePointTag      : u32,
    FileId               : LARGE_INTEGER,
    ParentFileId         : LARGE_INTEGER,
    FileNameLength       : u32,
    FileName             : [1]WCHAR,
 };
 PFILE_NOTIFY_EXTENDED_INFORMATION :: ^struct {
    NextEntryOffset      : u32,
    Action               : u32,
    CreationTime         : LARGE_INTEGER,
    LastModificationTime : LARGE_INTEGER,
    LastChangeTime       : LARGE_INTEGER,
    LastAccessTime       : LARGE_INTEGER,
    AllocatedLength      : LARGE_INTEGER,
    FileSize             : LARGE_INTEGER,
    FileAttributes       : u32,
    ReparsePointTag      : u32,
    FileId               : LARGE_INTEGER,
    ParentFileId         : LARGE_INTEGER,
    FileNameLength       : u32,
    FileName             : [1]WCHAR,
 };

 FILE_SEGMENT_ELEMENT :: struct #raw_union {
    Buffer    : PVOID64,
    Alignment : ULONGLONG,
 };
 PFILE_SEGMENT_ELEMENT :: ^struct #raw_union {
    Buffer    : PVOID64,
    Alignment : ULONGLONG,
 };

 REPARSE_GUID_DATA_BUFFER :: struct {
    ReparseTag           : u32,
    ReparseDataLength    : u16,
    Reserved             : u16,
    ReparseGuid          : GUID,
    GenericReparseBuffer : struct {
        DataBuffer : [1]BYTE,
    },
 };
 PREPARSE_GUID_DATA_BUFFER :: ^struct {
    ReparseTag           : u32,
    ReparseDataLength    : u16,
    Reserved             : u16,
    ReparseGuid          : GUID,
    GenericReparseBuffer : struct {
        DataBuffer : [1]BYTE,
    },
 };

 SCRUB_DATA_INPUT :: struct {
    Size          : u32,
    Flags         : u32,
    MaximumIos    : u32,
    ObjectId      : [4]u32,
    Reserved      : [25]u32,
    ResumeContext : [816]BYTE,
 };
 PSCRUB_DATA_INPUT :: ^struct {
    Size          : u32,
    Flags         : u32,
    MaximumIos    : u32,
    ObjectId      : [4]u32,
    Reserved      : [25]u32,
    ResumeContext : [816]BYTE,
 };

 SCRUB_PARITY_EXTENT :: struct {
    Offset : LONGLONG,
    Length : ULONGLONG,
 };
 PSCRUB_PARITY_EXTENT :: ^struct {
    Offset : LONGLONG,
    Length : ULONGLONG,
 };

 SCRUB_PARITY_EXTENT_DATA :: struct {
    Size                         : u16,
    Flags                        : u16,
    NumberOfParityExtents        : u16,
    MaximumNumberOfParityExtents : u16,
    ParityExtents                : [1]SCRUB_PARITY_EXTENT,
 };
 PSCRUB_PARITY_EXTENT_DATA :: ^struct {
    Size                         : u16,
    Flags                        : u16,
    NumberOfParityExtents        : u16,
    MaximumNumberOfParityExtents : u16,
    ParityExtents                : [1]SCRUB_PARITY_EXTENT,
 };

 SCRUB_DATA_OUTPUT :: struct {
    Size                            : u32,
    Flags                           : u32,
    Status                          : u32,
    ErrorFileOffset                 : ULONGLONG,
    ErrorLength                     : ULONGLONG,
    NumberOfBytesRepaired           : ULONGLONG,
    NumberOfBytesFailed             : ULONGLONG,
    InternalFileReference           : ULONGLONG,
    ResumeContextLength             : u16,
    ParityExtentDataOffset          : u16,
    Reserved                        : [9]u32,
    NumberOfMetadataBytesProcessed  : ULONGLONG,
    NumberOfDataBytesProcessed      : ULONGLONG,
    TotalNumberOfMetadataBytesInUse : ULONGLONG,
    TotalNumberOfDataBytesInUse     : ULONGLONG,
    ResumeContext                   : [816]BYTE,
 };
 PSCRUB_DATA_OUTPUT :: ^struct {
    Size                            : u32,
    Flags                           : u32,
    Status                          : u32,
    ErrorFileOffset                 : ULONGLONG,
    ErrorLength                     : ULONGLONG,
    NumberOfBytesRepaired           : ULONGLONG,
    NumberOfBytesFailed             : ULONGLONG,
    InternalFileReference           : ULONGLONG,
    ResumeContextLength             : u16,
    ParityExtentDataOffset          : u16,
    Reserved                        : [9]u32,
    NumberOfMetadataBytesProcessed  : ULONGLONG,
    NumberOfDataBytesProcessed      : ULONGLONG,
    TotalNumberOfMetadataBytesInUse : ULONGLONG,
    TotalNumberOfDataBytesInUse     : ULONGLONG,
    ResumeContext                   : [816]BYTE,
 };

 SharedVirtualDiskSupportType :: enum {
    SharedVirtualDisksUnsupported = 0,
    SharedVirtualDisksSupported = 1,
    SharedVirtualDiskSnapshotsSupported = 3,
    SharedVirtualDiskCDPSnapshotsSupported = 7,
 };

 SharedVirtualDiskHandleState :: enum {
    SharedVirtualDiskHandleStateNone = 0,
    SharedVirtualDiskHandleStateFileShared = 1,
    SharedVirtualDiskHandleStateHandleShared = 3,
 };

 SHARED_VIRTUAL_DISK_SUPPORT :: struct {
    SharedVirtualDiskSupport : SharedVirtualDiskSupportType,
    HandleState              : SharedVirtualDiskHandleState,
 };
 PSHARED_VIRTUAL_DISK_SUPPORT :: ^struct {
    SharedVirtualDiskSupport : SharedVirtualDiskSupportType,
    HandleState              : SharedVirtualDiskHandleState,
 };

 REARRANGE_FILE_DATA :: struct {
    SourceStartingOffset : ULONGLONG,
    TargetOffset         : ULONGLONG,
    SourceFileHandle     : HANDLE,
    Length               : u32,
    Flags                : u32,
 };
 PREARRANGE_FILE_DATA :: ^struct {
    SourceStartingOffset : ULONGLONG,
    TargetOffset         : ULONGLONG,
    SourceFileHandle     : HANDLE,
    Length               : u32,
    Flags                : u32,
 };

 SHUFFLE_FILE_DATA :: struct {
    StartingOffset : LONGLONG,
    Length         : LONGLONG,
    Flags          : u32,
 };
 PSHUFFLE_FILE_DATA :: ^struct {
    StartingOffset : LONGLONG,
    Length         : LONGLONG,
    Flags          : u32,
 };

 NETWORK_APP_INSTANCE_EA :: struct {
    AppInstanceID : GUID,
    CsvFlags      : u32,
 };
 PNETWORK_APP_INSTANCE_EA :: ^struct {
    AppInstanceID : GUID,
    CsvFlags      : u32,
 };

 SYSTEM_POWER_STATE :: enum {
    PowerSystemUnspecified = 0,
    PowerSystemWorking = 1,
    PowerSystemSleeping1 = 2,
    PowerSystemSleeping2 = 3,
    PowerSystemSleeping3 = 4,
    PowerSystemHibernate = 5,
    PowerSystemShutdown = 6,
    PowerSystemMaximum = 7,
 };
 PSYSTEM_POWER_STATE :: ^enum {
    PowerSystemUnspecified = 0,
    PowerSystemWorking = 1,
    PowerSystemSleeping1 = 2,
    PowerSystemSleeping2 = 3,
    PowerSystemSleeping3 = 4,
    PowerSystemHibernate = 5,
    PowerSystemShutdown = 6,
    PowerSystemMaximum = 7,
 };

 POWER_ACTION :: enum {
    PowerActionNone = 0,
    PowerActionReserved,
    PowerActionSleep,
    PowerActionHibernate,
    PowerActionShutdown,
    PowerActionShutdownReset,
    PowerActionShutdownOff,
    PowerActionWarmEject,
    PowerActionDisplayOff,
 };
 PPOWER_ACTION :: ^enum {
    PowerActionNone = 0,
    PowerActionReserved,
    PowerActionSleep,
    PowerActionHibernate,
    PowerActionShutdown,
    PowerActionShutdownReset,
    PowerActionShutdownOff,
    PowerActionWarmEject,
    PowerActionDisplayOff,
 };

 DEVICE_POWER_STATE :: enum {
    PowerDeviceUnspecified = 0,
    PowerDeviceD0,
    PowerDeviceD1,
    PowerDeviceD2,
    PowerDeviceD3,
    PowerDeviceMaximum,
 };
 PDEVICE_POWER_STATE :: ^enum {
    PowerDeviceUnspecified = 0,
    PowerDeviceD0,
    PowerDeviceD1,
    PowerDeviceD2,
    PowerDeviceD3,
    PowerDeviceMaximum,
 };

 MONITOR_DISPLAY_STATE :: enum {
    PowerMonitorOff = 0,
    PowerMonitorOn,
    PowerMonitorDim,
 };
 PMONITOR_DISPLAY_STATE :: ^enum {
    PowerMonitorOff = 0,
    PowerMonitorOn,
    PowerMonitorDim,
 };

 USER_ACTIVITY_PRESENCE :: enum {
    PowerUserPresent = 0,
    PowerUserNotPresent,
    PowerUserInactive,
    PowerUserMaximum,
    PowerUserInvalid =     PowerUserMaximum,
 };
 PUSER_ACTIVITY_PRESENCE :: ^enum {
    PowerUserPresent = 0,
    PowerUserNotPresent,
    PowerUserInactive,
    PowerUserMaximum,
    PowerUserInvalid =     PowerUserMaximum,
 };

 EXECUTION_STATE :: u32;
 PEXECUTION_STATE :: ^u32;

 LATENCY_TIME :: enum {
    LT_DONT_CARE,
    LT_LOWEST_LATENCY,
 };

 POWER_REQUEST_TYPE :: enum {
    PowerRequestDisplayRequired,
    PowerRequestSystemRequired,
    PowerRequestAwayModeRequired,
    PowerRequestExecutionRequired,
 };
 PPOWER_REQUEST_TYPE :: ^enum {
    PowerRequestDisplayRequired,
    PowerRequestSystemRequired,
    PowerRequestAwayModeRequired,
    PowerRequestExecutionRequired,
 };

 CM_POWER_DATA :: struct {
    PD_Size                 : u32,
    PD_MostRecentPowerState : DEVICE_POWER_STATE,
    PD_Capabilities         : u32,
    PD_D1Latency            : u32,
    PD_D2Latency            : u32,
    PD_D3Latency            : u32,
    PD_PowerStateMapping    : [7]DEVICE_POWER_STATE,
    PD_DeepestSystemWake    : SYSTEM_POWER_STATE,
 };
 PCM_POWER_DATA :: ^struct {
    PD_Size                 : u32,
    PD_MostRecentPowerState : DEVICE_POWER_STATE,
    PD_Capabilities         : u32,
    PD_D1Latency            : u32,
    PD_D2Latency            : u32,
    PD_D3Latency            : u32,
    PD_PowerStateMapping    : [7]DEVICE_POWER_STATE,
    PD_DeepestSystemWake    : SYSTEM_POWER_STATE,
 };

 POWER_INFORMATION_LEVEL :: enum {
    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,
 };

 POWER_USER_PRESENCE_TYPE :: enum {
    UserNotPresent = 0,
    UserPresent = 1,
    UserUnknown = 0xff,
 };
 PPOWER_USER_PRESENCE_TYPE :: ^enum {
    UserNotPresent = 0,
    UserPresent = 1,
    UserUnknown = 0xff,
 };

 POWER_USER_PRESENCE :: struct {
    UserPresence : POWER_USER_PRESENCE_TYPE,
 };
 PPOWER_USER_PRESENCE :: ^struct {
    UserPresence : POWER_USER_PRESENCE_TYPE,
 };

 POWER_SESSION_CONNECT :: struct {
    Connected : BOOLEAN,
    Console   : BOOLEAN,
 };
 PPOWER_SESSION_CONNECT :: ^struct {
    Connected : BOOLEAN,
    Console   : BOOLEAN,
 };

 POWER_SESSION_TIMEOUTS :: struct {
    InputTimeout   : u32,
    DisplayTimeout : u32,
 };
 PPOWER_SESSION_TIMEOUTS :: ^struct {
    InputTimeout   : u32,
    DisplayTimeout : u32,
 };

 POWER_SESSION_RIT_STATE :: struct {
    Active        : BOOLEAN,
    LastInputTime : u32,
 };
 PPOWER_SESSION_RIT_STATE :: ^struct {
    Active        : BOOLEAN,
    LastInputTime : u32,
 };

 POWER_SESSION_WINLOGON :: struct {
    SessionId : u32,
    Console   : BOOLEAN,
    Locked    : BOOLEAN,
 };
 PPOWER_SESSION_WINLOGON :: ^struct {
    SessionId : u32,
    Console   : BOOLEAN,
    Locked    : BOOLEAN,
 };

 POWER_IDLE_RESILIENCY :: struct {
    CoalescingTimeout    : u32,
    IdleResiliencyPeriod : u32,
 };
 PPOWER_IDLE_RESILIENCY :: ^struct {
    CoalescingTimeout    : u32,
    IdleResiliencyPeriod : u32,
 };

 POWER_MONITOR_REQUEST_REASON :: enum {
    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,
    MonitorRequestReasonUserInputKeyboard,
    MonitorRequestReasonUserInputMouse,
    MonitorRequestReasonUserInputTouch,
    MonitorRequestReasonUserInputPen,
    MonitorRequestReasonUserInputAccelerometer,
    MonitorRequestReasonUserInputHid,
    MonitorRequestReasonUserInputPoUserPresent,
    MonitorRequestReasonUserInputSessionSwitch,
    MonitorRequestReasonUserInputInitialization,
    MonitorRequestReasonPdcSignalWindowsMobilePwrNotif,
    MonitorRequestReasonPdcSignalWindowsMobileShell,
    MonitorRequestReasonPdcSignalHeyCortana,
    MonitorRequestReasonPdcSignalHolographicShell,
    MonitorRequestReasonPdcSignalFingerprint,
    MonitorRequestReasonDirectedDrips,
    MonitorRequestReasonMax,
 };

 POWER_MONITOR_REQUEST_TYPE :: enum {
    MonitorRequestTypeOff,
    MonitorRequestTypeOnAndPresent,
    MonitorRequestTypeToggleOn,
 };

 POWER_MONITOR_INVOCATION :: struct {
    Console       : BOOLEAN,
    RequestReason : POWER_MONITOR_REQUEST_REASON,
 };
 PPOWER_MONITOR_INVOCATION :: ^struct {
    Console       : BOOLEAN,
    RequestReason : POWER_MONITOR_REQUEST_REASON,
 };

 RESUME_PERFORMANCE :: struct {
    PostTimeMs              : u32,
    TotalResumeTimeMs       : ULONGLONG,
    ResumeCompleteTimestamp : ULONGLONG,
 };
 PRESUME_PERFORMANCE :: ^struct {
    PostTimeMs              : u32,
    TotalResumeTimeMs       : ULONGLONG,
    ResumeCompleteTimestamp : ULONGLONG,
 };

 SYSTEM_POWER_CONDITION :: enum {
    PoAc,
    PoDc,
    PoHot,
    PoConditionMaximum,
 };

 SET_POWER_SETTING_VALUE :: struct {
    Version        : u32,
    Guid           : GUID,
    PowerCondition : SYSTEM_POWER_CONDITION,
    DataLength     : u32,
    Data           : [1]BYTE,
 };
 PSET_POWER_SETTING_VALUE :: ^struct {
    Version        : u32,
    Guid           : GUID,
    PowerCondition : SYSTEM_POWER_CONDITION,
    DataLength     : u32,
    Data           : [1]BYTE,
 };

 NOTIFY_USER_POWER_SETTING :: struct {
    Guid : GUID,
 };
 PNOTIFY_USER_POWER_SETTING :: ^struct {
    Guid : GUID,
 };

 APPLICATIONLAUNCH_SETTING_VALUE :: struct {
    ActivationTime   : LARGE_INTEGER,
    Flags            : u32,
    ButtonInstanceID : u32,
 };
 PAPPLICATIONLAUNCH_SETTING_VALUE :: ^struct {
    ActivationTime   : LARGE_INTEGER,
    Flags            : u32,
    ButtonInstanceID : u32,
 };

 POWER_PLATFORM_ROLE :: enum {
    PlatformRoleUnspecified = 0,
    PlatformRoleDesktop,
    PlatformRoleMobile,
    PlatformRoleWorkstation,
    PlatformRoleEnterpriseServer,
    PlatformRoleSOHOServer,
    PlatformRoleAppliancePC,
    PlatformRolePerformanceServer,
    PlatformRoleSlate,
    PlatformRoleMaximum,
 };
 PPOWER_PLATFORM_ROLE :: ^enum {
    PlatformRoleUnspecified = 0,
    PlatformRoleDesktop,
    PlatformRoleMobile,
    PlatformRoleWorkstation,
    PlatformRoleEnterpriseServer,
    PlatformRoleSOHOServer,
    PlatformRoleAppliancePC,
    PlatformRolePerformanceServer,
    PlatformRoleSlate,
    PlatformRoleMaximum,
 };

 POWER_PLATFORM_INFORMATION :: struct {
    AoAc : BOOLEAN,
 };
 PPOWER_PLATFORM_INFORMATION :: ^struct {
    AoAc : BOOLEAN,
 };

 BATTERY_REPORTING_SCALE :: struct {
    Granularity : u32,
    Capacity    : u32,
 };
 PBATTERY_REPORTING_SCALE :: ^struct {
    Granularity : u32,
    Capacity    : u32,
 };

 PPM_WMI_LEGACY_PERFSTATE :: struct {
    Frequency        : u32,
    Flags            : u32,
    PercentFrequency : u32,
 };
 PPPM_WMI_LEGACY_PERFSTATE :: ^struct {
    Frequency        : u32,
    Flags            : u32,
    PercentFrequency : u32,
 };

 PPM_WMI_IDLE_STATE :: struct {
    Latency        : u32,
    Power          : u32,
    TimeCheck      : u32,
    PromotePercent : BYTE,
    DemotePercent  : BYTE,
    StateType      : BYTE,
    Reserved       : BYTE,
    StateFlags     : u32,
    Context        : u32,
    IdleHandler    : u32,
    Reserved1      : u32,
 };
 PPPM_WMI_IDLE_STATE :: ^struct {
    Latency        : u32,
    Power          : u32,
    TimeCheck      : u32,
    PromotePercent : BYTE,
    DemotePercent  : BYTE,
    StateType      : BYTE,
    Reserved       : BYTE,
    StateFlags     : u32,
    Context        : u32,
    IdleHandler    : u32,
    Reserved1      : u32,
 };

 PPM_WMI_IDLE_STATES :: struct {
    Type             : u32,
    Count            : u32,
    TargetState      : u32,
    OldState         : u32,
    TargetProcessors : DWORD64,
    State            : [1]PPM_WMI_IDLE_STATE,
 };
 PPPM_WMI_IDLE_STATES :: ^struct {
    Type             : u32,
    Count            : u32,
    TargetState      : u32,
    OldState         : u32,
    TargetProcessors : DWORD64,
    State            : [1]PPM_WMI_IDLE_STATE,
 };

 PPM_WMI_IDLE_STATES_EX :: struct {
    Type             : u32,
    Count            : u32,
    TargetState      : u32,
    OldState         : u32,
    TargetProcessors : PVOID,
    State            : [1]PPM_WMI_IDLE_STATE,
 };
 PPPM_WMI_IDLE_STATES_EX :: ^struct {
    Type             : u32,
    Count            : u32,
    TargetState      : u32,
    OldState         : u32,
    TargetProcessors : PVOID,
    State            : [1]PPM_WMI_IDLE_STATE,
 };

 PPM_WMI_PERF_STATE :: struct {
    Frequency        : u32,
    Power            : u32,
    PercentFrequency : BYTE,
    IncreaseLevel    : BYTE,
    DecreaseLevel    : BYTE,
    Type             : BYTE,
    IncreaseTime     : u32,
    DecreaseTime     : u32,
    Control          : DWORD64,
    Status           : DWORD64,
    HitCount         : u32,
    Reserved1        : u32,
    Reserved2        : DWORD64,
    Reserved3        : DWORD64,
 };
 PPPM_WMI_PERF_STATE :: ^struct {
    Frequency        : u32,
    Power            : u32,
    PercentFrequency : BYTE,
    IncreaseLevel    : BYTE,
    DecreaseLevel    : BYTE,
    Type             : BYTE,
    IncreaseTime     : u32,
    DecreaseTime     : u32,
    Control          : DWORD64,
    Status           : DWORD64,
    HitCount         : u32,
    Reserved1        : u32,
    Reserved2        : DWORD64,
    Reserved3        : DWORD64,
 };

 PPM_WMI_PERF_STATES :: struct {
    Count             : u32,
    MaxFrequency      : u32,
    CurrentState      : u32,
    MaxPerfState      : u32,
    MinPerfState      : u32,
    LowestPerfState   : u32,
    ThermalConstraint : u32,
    BusyAdjThreshold  : BYTE,
    PolicyType        : BYTE,
    Type              : BYTE,
    Reserved          : BYTE,
    TimerInterval     : u32,
    TargetProcessors  : DWORD64,
    PStateHandler     : u32,
    PStateContext     : u32,
    TStateHandler     : u32,
    TStateContext     : u32,
    FeedbackHandler   : u32,
    Reserved1         : u32,
    Reserved2         : DWORD64,
    State             : [1]PPM_WMI_PERF_STATE,
 };
 PPPM_WMI_PERF_STATES :: ^struct {
    Count             : u32,
    MaxFrequency      : u32,
    CurrentState      : u32,
    MaxPerfState      : u32,
    MinPerfState      : u32,
    LowestPerfState   : u32,
    ThermalConstraint : u32,
    BusyAdjThreshold  : BYTE,
    PolicyType        : BYTE,
    Type              : BYTE,
    Reserved          : BYTE,
    TimerInterval     : u32,
    TargetProcessors  : DWORD64,
    PStateHandler     : u32,
    PStateContext     : u32,
    TStateHandler     : u32,
    TStateContext     : u32,
    FeedbackHandler   : u32,
    Reserved1         : u32,
    Reserved2         : DWORD64,
    State             : [1]PPM_WMI_PERF_STATE,
 };

 PPM_WMI_PERF_STATES_EX :: struct {
    Count             : u32,
    MaxFrequency      : u32,
    CurrentState      : u32,
    MaxPerfState      : u32,
    MinPerfState      : u32,
    LowestPerfState   : u32,
    ThermalConstraint : u32,
    BusyAdjThreshold  : BYTE,
    PolicyType        : BYTE,
    Type              : BYTE,
    Reserved          : BYTE,
    TimerInterval     : u32,
    TargetProcessors  : PVOID,
    PStateHandler     : u32,
    PStateContext     : u32,
    TStateHandler     : u32,
    TStateContext     : u32,
    FeedbackHandler   : u32,
    Reserved1         : u32,
    Reserved2         : DWORD64,
    State             : [1]PPM_WMI_PERF_STATE,
 };
 PPPM_WMI_PERF_STATES_EX :: ^struct {
    Count             : u32,
    MaxFrequency      : u32,
    CurrentState      : u32,
    MaxPerfState      : u32,
    MinPerfState      : u32,
    LowestPerfState   : u32,
    ThermalConstraint : u32,
    BusyAdjThreshold  : BYTE,
    PolicyType        : BYTE,
    Type              : BYTE,
    Reserved          : BYTE,
    TimerInterval     : u32,
    TargetProcessors  : PVOID,
    PStateHandler     : u32,
    PStateContext     : u32,
    TStateHandler     : u32,
    TStateContext     : u32,
    FeedbackHandler   : u32,
    Reserved1         : u32,
    Reserved2         : DWORD64,
    State             : [1]PPM_WMI_PERF_STATE,
 };

 PPM_IDLE_STATE_ACCOUNTING :: struct {
    IdleTransitions    : u32,
    FailedTransitions  : u32,
    InvalidBucketIndex : u32,
    TotalTime          : DWORD64,
    IdleTimeBuckets    : [6]u32,
 };
 PPPM_IDLE_STATE_ACCOUNTING :: ^struct {
    IdleTransitions    : u32,
    FailedTransitions  : u32,
    InvalidBucketIndex : u32,
    TotalTime          : DWORD64,
    IdleTimeBuckets    : [6]u32,
 };

 PPM_IDLE_ACCOUNTING :: struct {
    StateCount       : u32,
    TotalTransitions : u32,
    ResetCount       : u32,
    StartTime        : DWORD64,
    State            : [1]PPM_IDLE_STATE_ACCOUNTING,
 };
 PPPM_IDLE_ACCOUNTING :: ^struct {
    StateCount       : u32,
    TotalTransitions : u32,
    ResetCount       : u32,
    StartTime        : DWORD64,
    State            : [1]PPM_IDLE_STATE_ACCOUNTING,
 };

 PPM_IDLE_STATE_BUCKET_EX :: struct {
    TotalTimeUs : DWORD64,
    MinTimeUs   : u32,
    MaxTimeUs   : u32,
    Count       : u32,
 };
 PPPM_IDLE_STATE_BUCKET_EX :: ^struct {
    TotalTimeUs : DWORD64,
    MinTimeUs   : u32,
    MaxTimeUs   : u32,
    Count       : u32,
 };

 PPM_IDLE_STATE_ACCOUNTING_EX :: struct {
    TotalTime            : DWORD64,
    IdleTransitions      : u32,
    FailedTransitions    : u32,
    InvalidBucketIndex   : u32,
    MinTimeUs            : u32,
    MaxTimeUs            : u32,
    CancelledTransitions : u32,
    IdleTimeBuckets      : [16]PPM_IDLE_STATE_BUCKET_EX,
 };
 PPPM_IDLE_STATE_ACCOUNTING_EX :: ^struct {
    TotalTime            : DWORD64,
    IdleTransitions      : u32,
    FailedTransitions    : u32,
    InvalidBucketIndex   : u32,
    MinTimeUs            : u32,
    MaxTimeUs            : u32,
    CancelledTransitions : u32,
    IdleTimeBuckets      : [16]PPM_IDLE_STATE_BUCKET_EX,
 };

 PPM_IDLE_ACCOUNTING_EX :: struct {
    StateCount       : u32,
    TotalTransitions : u32,
    ResetCount       : u32,
    AbortCount       : u32,
    StartTime        : DWORD64,
    State            : [1]PPM_IDLE_STATE_ACCOUNTING_EX,
 };
 PPPM_IDLE_ACCOUNTING_EX :: ^struct {
    StateCount       : u32,
    TotalTransitions : u32,
    ResetCount       : u32,
    AbortCount       : u32,
    StartTime        : DWORD64,
    State            : [1]PPM_IDLE_STATE_ACCOUNTING_EX,
 };

 PPM_PERFSTATE_EVENT :: struct {
    State     : u32,
    Status    : u32,
    Latency   : u32,
    Speed     : u32,
    Processor : u32,
 };
 PPPM_PERFSTATE_EVENT :: ^struct {
    State     : u32,
    Status    : u32,
    Latency   : u32,
    Speed     : u32,
    Processor : u32,
 };

 PPM_PERFSTATE_DOMAIN_EVENT :: struct {
    State      : u32,
    Latency    : u32,
    Speed      : u32,
    Processors : DWORD64,
 };
 PPPM_PERFSTATE_DOMAIN_EVENT :: ^struct {
    State      : u32,
    Latency    : u32,
    Speed      : u32,
    Processors : DWORD64,
 };

 PPM_IDLESTATE_EVENT :: struct {
    NewState   : u32,
    OldState   : u32,
    Processors : DWORD64,
 };
 PPPM_IDLESTATE_EVENT :: ^struct {
    NewState   : u32,
    OldState   : u32,
    Processors : DWORD64,
 };

 PPM_THERMALCHANGE_EVENT :: struct {
    ThermalConstraint : u32,
    Processors        : DWORD64,
 };
 PPPM_THERMALCHANGE_EVENT :: ^struct {
    ThermalConstraint : u32,
    Processors        : DWORD64,
 };

 PPM_THERMAL_POLICY_EVENT :: struct {
    Mode       : BYTE,
    Processors : DWORD64,
 };
 PPPM_THERMAL_POLICY_EVENT :: ^struct {
    Mode       : BYTE,
    Processors : DWORD64,
 };

 POWER_ACTION_POLICY :: struct {
    Action    : POWER_ACTION,
    Flags     : u32,
    EventCode : u32,
 };
 PPOWER_ACTION_POLICY :: ^struct {
    Action    : POWER_ACTION,
    Flags     : u32,
    EventCode : u32,
 };

 SYSTEM_POWER_LEVEL :: struct {
    Enable         : BOOLEAN,
    Spare          : [3]BYTE,
    BatteryLevel   : u32,
    PowerPolicy    : POWER_ACTION_POLICY,
    MinSystemState : SYSTEM_POWER_STATE,
 };
 PSYSTEM_POWER_LEVEL :: ^struct {
    Enable         : BOOLEAN,
    Spare          : [3]BYTE,
    BatteryLevel   : u32,
    PowerPolicy    : POWER_ACTION_POLICY,
    MinSystemState : SYSTEM_POWER_STATE,
 };

 SYSTEM_POWER_POLICY :: struct {
    Revision                    : u32,
    PowerButton                 : POWER_ACTION_POLICY,
    SleepButton                 : POWER_ACTION_POLICY,
    LidClose                    : POWER_ACTION_POLICY,
    LidOpenWake                 : SYSTEM_POWER_STATE,
    Reserved                    : u32,
    Idle                        : POWER_ACTION_POLICY,
    IdleTimeout                 : u32,
    IdleSensitivity             : BYTE,
    DynamicThrottle             : BYTE,
    Spare2                      : [2]BYTE,
    MinSleep                    : SYSTEM_POWER_STATE,
    MaxSleep                    : SYSTEM_POWER_STATE,
    ReducedLatencySleep         : SYSTEM_POWER_STATE,
    WinLogonFlags               : u32,
    Spare3                      : u32,
    DozeS4Timeout               : u32,
    BroadcastCapacityResolution : u32,
    DischargePolicy             : [4]SYSTEM_POWER_LEVEL,
    VideoTimeout                : u32,
    VideoDimDisplay             : BOOLEAN,
    VideoReserved               : [3]u32,
    SpindownTimeout             : u32,
    OptimizeForPower            : BOOLEAN,
    FanThrottleTolerance        : BYTE,
    ForcedThrottle              : BYTE,
    MinThrottle                 : BYTE,
    OverThrottled               : POWER_ACTION_POLICY,
 };
 PSYSTEM_POWER_POLICY :: ^struct {
    Revision                    : u32,
    PowerButton                 : POWER_ACTION_POLICY,
    SleepButton                 : POWER_ACTION_POLICY,
    LidClose                    : POWER_ACTION_POLICY,
    LidOpenWake                 : SYSTEM_POWER_STATE,
    Reserved                    : u32,
    Idle                        : POWER_ACTION_POLICY,
    IdleTimeout                 : u32,
    IdleSensitivity             : BYTE,
    DynamicThrottle             : BYTE,
    Spare2                      : [2]BYTE,
    MinSleep                    : SYSTEM_POWER_STATE,
    MaxSleep                    : SYSTEM_POWER_STATE,
    ReducedLatencySleep         : SYSTEM_POWER_STATE,
    WinLogonFlags               : u32,
    Spare3                      : u32,
    DozeS4Timeout               : u32,
    BroadcastCapacityResolution : u32,
    DischargePolicy             : [4]SYSTEM_POWER_LEVEL,
    VideoTimeout                : u32,
    VideoDimDisplay             : BOOLEAN,
    VideoReserved               : [3]u32,
    SpindownTimeout             : u32,
    OptimizeForPower            : BOOLEAN,
    FanThrottleTolerance        : BYTE,
    ForcedThrottle              : BYTE,
    MinThrottle                 : BYTE,
    OverThrottled               : POWER_ACTION_POLICY,
 };

 PROCESSOR_IDLESTATE_INFO :: struct {
    TimeCheck      : u32,
    DemotePercent  : BYTE,
    PromotePercent : BYTE,
    Spare          : [2]BYTE,
 };
 PPROCESSOR_IDLESTATE_INFO :: ^struct {
    TimeCheck      : u32,
    DemotePercent  : BYTE,
    PromotePercent : BYTE,
    Spare          : [2]BYTE,
 };

 PROCESSOR_IDLESTATE_POLICY :: struct {
    Revision    : u16,
    Flags : struct #raw_union {
        AsWORD : u16,
        s : struct {
            AllowScaling : ,
            Disabled     : ,
            Reserved     : ,
        },
    },
    PolicyCount : u32,
    Policy      : [0x3]PROCESSOR_IDLESTATE_INFO,
 };
 PPROCESSOR_IDLESTATE_POLICY :: ^struct {
    Revision    : u16,
    Flags : struct #raw_union {
        AsWORD : u16,
        s : struct {
            AllowScaling : ,
            Disabled     : ,
            Reserved     : ,
        },
    },
    PolicyCount : u32,
    Policy      : [0x3]PROCESSOR_IDLESTATE_INFO,
 };

 PROCESSOR_POWER_POLICY_INFO :: struct {
    TimeCheck      : u32,
    DemoteLimit    : u32,
    PromoteLimit   : u32,
    DemotePercent  : BYTE,
    PromotePercent : BYTE,
    Spare          : [2]BYTE,
    AllowDemotion  : ,
    AllowPromotion : ,
    Reserved       : ,
 };
 PPROCESSOR_POWER_POLICY_INFO :: ^struct {
    TimeCheck      : u32,
    DemoteLimit    : u32,
    PromoteLimit   : u32,
    DemotePercent  : BYTE,
    PromotePercent : BYTE,
    Spare          : [2]BYTE,
    AllowDemotion  : ,
    AllowPromotion : ,
    Reserved       : ,
 };

 PROCESSOR_POWER_POLICY :: struct {
    Revision        : u32,
    DynamicThrottle : BYTE,
    Spare           : [3]BYTE,
    DisableCStates  : ,
    Reserved        : ,
    PolicyCount     : u32,
    Policy          : [3]PROCESSOR_POWER_POLICY_INFO,
 };
 PPROCESSOR_POWER_POLICY :: ^struct {
    Revision        : u32,
    DynamicThrottle : BYTE,
    Spare           : [3]BYTE,
    DisableCStates  : ,
    Reserved        : ,
    PolicyCount     : u32,
    Policy          : [3]PROCESSOR_POWER_POLICY_INFO,
 };

 PROCESSOR_PERFSTATE_POLICY :: struct {
    Revision         : u32,
    MaxThrottle      : BYTE,
    MinThrottle      : BYTE,
    BusyAdjThreshold : BYTE,
    u : struct #raw_union {
        Spare : BYTE,
        Flags : struct #raw_union {
            AsBYTE : BYTE,
            s : struct {
                NoDomainAccounting : ,
                IncreasePolicy     : ,
                DecreasePolicy     : ,
                Reserved           : ,
            },
        },
    },
    TimeCheck        : u32,
    IncreaseTime     : u32,
    DecreaseTime     : u32,
    IncreasePercent  : u32,
    DecreasePercent  : u32,
 };
 PPROCESSOR_PERFSTATE_POLICY :: ^struct {
    Revision         : u32,
    MaxThrottle      : BYTE,
    MinThrottle      : BYTE,
    BusyAdjThreshold : BYTE,
    u : struct #raw_union {
        Spare : BYTE,
        Flags : struct #raw_union {
            AsBYTE : BYTE,
            s : struct {
                NoDomainAccounting : ,
                IncreasePolicy     : ,
                DecreasePolicy     : ,
                Reserved           : ,
            },
        },
    },
    TimeCheck        : u32,
    IncreaseTime     : u32,
    DecreaseTime     : u32,
    IncreasePercent  : u32,
    DecreasePercent  : u32,
 };

 ADMINISTRATOR_POWER_POLICY :: struct {
    MinSleep           : SYSTEM_POWER_STATE,
    MaxSleep           : SYSTEM_POWER_STATE,
    MinVideoTimeout    : u32,
    MaxVideoTimeout    : u32,
    MinSpindownTimeout : u32,
    MaxSpindownTimeout : u32,
 };
 PADMINISTRATOR_POWER_POLICY :: ^struct {
    MinSleep           : SYSTEM_POWER_STATE,
    MaxSleep           : SYSTEM_POWER_STATE,
    MinVideoTimeout    : u32,
    MaxVideoTimeout    : u32,
    MinSpindownTimeout : u32,
    MaxSpindownTimeout : u32,
 };

 HIBERFILE_BUCKET_SIZE :: enum {
    HiberFileBucket1GB = 0,
    HiberFileBucket2GB,
    HiberFileBucket4GB,
    HiberFileBucket8GB,
    HiberFileBucket16GB,
    HiberFileBucket32GB,
    HiberFileBucketUnlimited,
    HiberFileBucketMax,
 };
 PHIBERFILE_BUCKET_SIZE :: ^enum {
    HiberFileBucket1GB = 0,
    HiberFileBucket2GB,
    HiberFileBucket4GB,
    HiberFileBucket8GB,
    HiberFileBucket16GB,
    HiberFileBucket32GB,
    HiberFileBucketUnlimited,
    HiberFileBucketMax,
 };

 HIBERFILE_BUCKET :: struct {
    MaxPhysicalMemory     : DWORD64,
    PhysicalMemoryPercent : [0x03]u32,
 };
 PHIBERFILE_BUCKET :: ^struct {
    MaxPhysicalMemory     : DWORD64,
    PhysicalMemoryPercent : [0x03]u32,
 };

 SYSTEM_POWER_CAPABILITIES :: struct {
    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                    : [6]BYTE,
    SystemBatteriesPresent    : BOOLEAN,
    BatteriesAreShortTerm     : BOOLEAN,
    BatteryScale              : [3]BATTERY_REPORTING_SCALE,
    AcOnLineWake              : SYSTEM_POWER_STATE,
    SoftLidWake               : SYSTEM_POWER_STATE,
    RtcWake                   : SYSTEM_POWER_STATE,
    MinDeviceWakeState        : SYSTEM_POWER_STATE,
    DefaultLowLatencyWake     : SYSTEM_POWER_STATE,
 };
 PSYSTEM_POWER_CAPABILITIES :: ^struct {
    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                    : [6]BYTE,
    SystemBatteriesPresent    : BOOLEAN,
    BatteriesAreShortTerm     : BOOLEAN,
    BatteryScale              : [3]BATTERY_REPORTING_SCALE,
    AcOnLineWake              : SYSTEM_POWER_STATE,
    SoftLidWake               : SYSTEM_POWER_STATE,
    RtcWake                   : SYSTEM_POWER_STATE,
    MinDeviceWakeState        : SYSTEM_POWER_STATE,
    DefaultLowLatencyWake     : SYSTEM_POWER_STATE,
 };

 SYSTEM_BATTERY_STATE :: struct {
    AcOnLine          : BOOLEAN,
    BatteryPresent    : BOOLEAN,
    Charging          : BOOLEAN,
    Discharging       : BOOLEAN,
    Spare1            : [3]BOOLEAN,
    Tag               : BYTE,
    MaxCapacity       : u32,
    RemainingCapacity : u32,
    Rate              : u32,
    EstimatedTime     : u32,
    DefaultAlert1     : u32,
    DefaultAlert2     : u32,
 };
 PSYSTEM_BATTERY_STATE :: ^struct {
    AcOnLine          : BOOLEAN,
    BatteryPresent    : BOOLEAN,
    Charging          : BOOLEAN,
    Discharging       : BOOLEAN,
    Spare1            : [3]BOOLEAN,
    Tag               : BYTE,
    MaxCapacity       : u32,
    RemainingCapacity : u32,
    Rate              : u32,
    EstimatedTime     : u32,
    DefaultAlert1     : u32,
    DefaultAlert2     : u32,
 };

 IMAGE_DOS_HEADER :: struct {
    e_magic    : u16,
    e_cblp     : u16,
    e_cp       : u16,
    e_crlc     : u16,
    e_cparhdr  : u16,
    e_minalloc : u16,
    e_maxalloc : u16,
    e_ss       : u16,
    e_sp       : u16,
    e_csum     : u16,
    e_ip       : u16,
    e_cs       : u16,
    e_lfarlc   : u16,
    e_ovno     : u16,
    e_res      : [4]u16,
    e_oemid    : u16,
    e_oeminfo  : u16,
    e_res2     : [10]u16,
    e_lfanew   : LONG,
 };
 PIMAGE_DOS_HEADER :: ^struct {
    e_magic    : u16,
    e_cblp     : u16,
    e_cp       : u16,
    e_crlc     : u16,
    e_cparhdr  : u16,
    e_minalloc : u16,
    e_maxalloc : u16,
    e_ss       : u16,
    e_sp       : u16,
    e_csum     : u16,
    e_ip       : u16,
    e_cs       : u16,
    e_lfarlc   : u16,
    e_ovno     : u16,
    e_res      : [4]u16,
    e_oemid    : u16,
    e_oeminfo  : u16,
    e_res2     : [10]u16,
    e_lfanew   : LONG,
 };

 IMAGE_OS2_HEADER :: struct {
    ne_magic        : u16,
    ne_ver          : CHAR,
    ne_rev          : CHAR,
    ne_enttab       : u16,
    ne_cbenttab     : u16,
    ne_crc          : LONG,
    ne_flags        : u16,
    ne_autodata     : u16,
    ne_heap         : u16,
    ne_stack        : u16,
    ne_csip         : LONG,
    ne_sssp         : LONG,
    ne_cseg         : u16,
    ne_cmod         : u16,
    ne_cbnrestab    : u16,
    ne_segtab       : u16,
    ne_rsrctab      : u16,
    ne_restab       : u16,
    ne_modtab       : u16,
    ne_imptab       : u16,
    ne_nrestab      : LONG,
    ne_cmovent      : u16,
    ne_align        : u16,
    ne_cres         : u16,
    ne_exetyp       : BYTE,
    ne_flagsothers  : BYTE,
    ne_pretthunks   : u16,
    ne_psegrefbytes : u16,
    ne_swaparea     : u16,
    ne_expver       : u16,
 };
 PIMAGE_OS2_HEADER :: ^struct {
    ne_magic        : u16,
    ne_ver          : CHAR,
    ne_rev          : CHAR,
    ne_enttab       : u16,
    ne_cbenttab     : u16,
    ne_crc          : LONG,
    ne_flags        : u16,
    ne_autodata     : u16,
    ne_heap         : u16,
    ne_stack        : u16,
    ne_csip         : LONG,
    ne_sssp         : LONG,
    ne_cseg         : u16,
    ne_cmod         : u16,
    ne_cbnrestab    : u16,
    ne_segtab       : u16,
    ne_rsrctab      : u16,
    ne_restab       : u16,
    ne_modtab       : u16,
    ne_imptab       : u16,
    ne_nrestab      : LONG,
    ne_cmovent      : u16,
    ne_align        : u16,
    ne_cres         : u16,
    ne_exetyp       : BYTE,
    ne_flagsothers  : BYTE,
    ne_pretthunks   : u16,
    ne_psegrefbytes : u16,
    ne_swaparea     : u16,
    ne_expver       : u16,
 };

 IMAGE_VXD_HEADER :: struct {
    e32_magic        : u16,
    e32_border       : BYTE,
    e32_worder       : BYTE,
    e32_level        : u32,
    e32_cpu          : u16,
    e32_os           : u16,
    e32_ver          : u32,
    e32_mflags       : u32,
    e32_mpages       : u32,
    e32_startobj     : u32,
    e32_eip          : u32,
    e32_stackobj     : u32,
    e32_esp          : u32,
    e32_pagesize     : u32,
    e32_lastpagesize : u32,
    e32_fixupsize    : u32,
    e32_fixupsum     : u32,
    e32_ldrsize      : u32,
    e32_ldrsum       : u32,
    e32_objtab       : u32,
    e32_objcnt       : u32,
    e32_objmap       : u32,
    e32_itermap      : u32,
    e32_rsrctab      : u32,
    e32_rsrccnt      : u32,
    e32_restab       : u32,
    e32_enttab       : u32,
    e32_dirtab       : u32,
    e32_dircnt       : u32,
    e32_fpagetab     : u32,
    e32_frectab      : u32,
    e32_impmod       : u32,
    e32_impmodcnt    : u32,
    e32_impproc      : u32,
    e32_pagesum      : u32,
    e32_datapage     : u32,
    e32_preload      : u32,
    e32_nrestab      : u32,
    e32_cbnrestab    : u32,
    e32_nressum      : u32,
    e32_autodata     : u32,
    e32_debuginfo    : u32,
    e32_debuglen     : u32,
    e32_instpreload  : u32,
    e32_instdemand   : u32,
    e32_heapsize     : u32,
    e32_res3         : [12]BYTE,
    e32_winresoff    : u32,
    e32_winreslen    : u32,
    e32_devid        : u16,
    e32_ddkver       : u16,
 };
 PIMAGE_VXD_HEADER :: ^struct {
    e32_magic        : u16,
    e32_border       : BYTE,
    e32_worder       : BYTE,
    e32_level        : u32,
    e32_cpu          : u16,
    e32_os           : u16,
    e32_ver          : u32,
    e32_mflags       : u32,
    e32_mpages       : u32,
    e32_startobj     : u32,
    e32_eip          : u32,
    e32_stackobj     : u32,
    e32_esp          : u32,
    e32_pagesize     : u32,
    e32_lastpagesize : u32,
    e32_fixupsize    : u32,
    e32_fixupsum     : u32,
    e32_ldrsize      : u32,
    e32_ldrsum       : u32,
    e32_objtab       : u32,
    e32_objcnt       : u32,
    e32_objmap       : u32,
    e32_itermap      : u32,
    e32_rsrctab      : u32,
    e32_rsrccnt      : u32,
    e32_restab       : u32,
    e32_enttab       : u32,
    e32_dirtab       : u32,
    e32_dircnt       : u32,
    e32_fpagetab     : u32,
    e32_frectab      : u32,
    e32_impmod       : u32,
    e32_impmodcnt    : u32,
    e32_impproc      : u32,
    e32_pagesum      : u32,
    e32_datapage     : u32,
    e32_preload      : u32,
    e32_nrestab      : u32,
    e32_cbnrestab    : u32,
    e32_nressum      : u32,
    e32_autodata     : u32,
    e32_debuginfo    : u32,
    e32_debuglen     : u32,
    e32_instpreload  : u32,
    e32_instdemand   : u32,
    e32_heapsize     : u32,
    e32_res3         : [12]BYTE,
    e32_winresoff    : u32,
    e32_winreslen    : u32,
    e32_devid        : u16,
    e32_ddkver       : u16,
 };

 IMAGE_FILE_HEADER :: struct {
    Machine              : u16,
    NumberOfSections     : u16,
    TimeDateStamp        : u32,
    PointerToSymbolTable : u32,
    NumberOfSymbols      : u32,
    SizeOfOptionalHeader : u16,
    Characteristics      : u16,
 };
 PIMAGE_FILE_HEADER :: ^struct {
    Machine              : u16,
    NumberOfSections     : u16,
    TimeDateStamp        : u32,
    PointerToSymbolTable : u32,
    NumberOfSymbols      : u32,
    SizeOfOptionalHeader : u16,
    Characteristics      : u16,
 };

 IMAGE_DATA_DIRECTORY :: struct {
    VirtualAddress : u32,
    Size           : u32,
 };
 PIMAGE_DATA_DIRECTORY :: ^struct {
    VirtualAddress : u32,
    Size           : u32,
 };

 IMAGE_OPTIONAL_HEADER32 :: struct {
    Magic                       : u16,
    MajorLinkerVersion          : BYTE,
    MinorLinkerVersion          : BYTE,
    SizeOfCode                  : u32,
    SizeOfInitializedData       : u32,
    SizeOfUninitializedData     : u32,
    AddressOfEntryPoint         : u32,
    BaseOfCode                  : u32,
    BaseOfData                  : u32,
    ImageBase                   : u32,
    SectionAlignment            : u32,
    FileAlignment               : u32,
    MajorOperatingSystemVersion : u16,
    MinorOperatingSystemVersion : u16,
    MajorImageVersion           : u16,
    MinorImageVersion           : u16,
    MajorSubsystemVersion       : u16,
    MinorSubsystemVersion       : u16,
    Win32VersionValue           : u32,
    SizeOfImage                 : u32,
    SizeOfHeaders               : u32,
    CheckSum                    : u32,
    Subsystem                   : u16,
    DllCharacteristics          : u16,
    SizeOfStackReserve          : u32,
    SizeOfStackCommit           : u32,
    SizeOfHeapReserve           : u32,
    SizeOfHeapCommit            : u32,
    LoaderFlags                 : u32,
    NumberOfRvaAndSizes         : u32,
    DataDirectory               : [16]IMAGE_DATA_DIRECTORY,
 };
 PIMAGE_OPTIONAL_HEADER32 :: ^struct {
    Magic                       : u16,
    MajorLinkerVersion          : BYTE,
    MinorLinkerVersion          : BYTE,
    SizeOfCode                  : u32,
    SizeOfInitializedData       : u32,
    SizeOfUninitializedData     : u32,
    AddressOfEntryPoint         : u32,
    BaseOfCode                  : u32,
    BaseOfData                  : u32,
    ImageBase                   : u32,
    SectionAlignment            : u32,
    FileAlignment               : u32,
    MajorOperatingSystemVersion : u16,
    MinorOperatingSystemVersion : u16,
    MajorImageVersion           : u16,
    MinorImageVersion           : u16,
    MajorSubsystemVersion       : u16,
    MinorSubsystemVersion       : u16,
    Win32VersionValue           : u32,
    SizeOfImage                 : u32,
    SizeOfHeaders               : u32,
    CheckSum                    : u32,
    Subsystem                   : u16,
    DllCharacteristics          : u16,
    SizeOfStackReserve          : u32,
    SizeOfStackCommit           : u32,
    SizeOfHeapReserve           : u32,
    SizeOfHeapCommit            : u32,
    LoaderFlags                 : u32,
    NumberOfRvaAndSizes         : u32,
    DataDirectory               : [16]IMAGE_DATA_DIRECTORY,
 };

 IMAGE_ROM_OPTIONAL_HEADER :: struct {
    Magic                   : u16,
    MajorLinkerVersion      : BYTE,
    MinorLinkerVersion      : BYTE,
    SizeOfCode              : u32,
    SizeOfInitializedData   : u32,
    SizeOfUninitializedData : u32,
    AddressOfEntryPoint     : u32,
    BaseOfCode              : u32,
    BaseOfData              : u32,
    BaseOfBss               : u32,
    GprMask                 : u32,
    CprMask                 : [4]u32,
    GpValue                 : u32,
 };
 PIMAGE_ROM_OPTIONAL_HEADER :: ^struct {
    Magic                   : u16,
    MajorLinkerVersion      : BYTE,
    MinorLinkerVersion      : BYTE,
    SizeOfCode              : u32,
    SizeOfInitializedData   : u32,
    SizeOfUninitializedData : u32,
    AddressOfEntryPoint     : u32,
    BaseOfCode              : u32,
    BaseOfData              : u32,
    BaseOfBss               : u32,
    GprMask                 : u32,
    CprMask                 : [4]u32,
    GpValue                 : u32,
 };

 IMAGE_OPTIONAL_HEADER64 :: struct {
    Magic                       : u16,
    MajorLinkerVersion          : BYTE,
    MinorLinkerVersion          : BYTE,
    SizeOfCode                  : u32,
    SizeOfInitializedData       : u32,
    SizeOfUninitializedData     : u32,
    AddressOfEntryPoint         : u32,
    BaseOfCode                  : u32,
    ImageBase                   : ULONGLONG,
    SectionAlignment            : u32,
    FileAlignment               : u32,
    MajorOperatingSystemVersion : u16,
    MinorOperatingSystemVersion : u16,
    MajorImageVersion           : u16,
    MinorImageVersion           : u16,
    MajorSubsystemVersion       : u16,
    MinorSubsystemVersion       : u16,
    Win32VersionValue           : u32,
    SizeOfImage                 : u32,
    SizeOfHeaders               : u32,
    CheckSum                    : u32,
    Subsystem                   : u16,
    DllCharacteristics          : u16,
    SizeOfStackReserve          : ULONGLONG,
    SizeOfStackCommit           : ULONGLONG,
    SizeOfHeapReserve           : ULONGLONG,
    SizeOfHeapCommit            : ULONGLONG,
    LoaderFlags                 : u32,
    NumberOfRvaAndSizes         : u32,
    DataDirectory               : [16]IMAGE_DATA_DIRECTORY,
 };
 PIMAGE_OPTIONAL_HEADER64 :: ^struct {
    Magic                       : u16,
    MajorLinkerVersion          : BYTE,
    MinorLinkerVersion          : BYTE,
    SizeOfCode                  : u32,
    SizeOfInitializedData       : u32,
    SizeOfUninitializedData     : u32,
    AddressOfEntryPoint         : u32,
    BaseOfCode                  : u32,
    ImageBase                   : ULONGLONG,
    SectionAlignment            : u32,
    FileAlignment               : u32,
    MajorOperatingSystemVersion : u16,
    MinorOperatingSystemVersion : u16,
    MajorImageVersion           : u16,
    MinorImageVersion           : u16,
    MajorSubsystemVersion       : u16,
    MinorSubsystemVersion       : u16,
    Win32VersionValue           : u32,
    SizeOfImage                 : u32,
    SizeOfHeaders               : u32,
    CheckSum                    : u32,
    Subsystem                   : u16,
    DllCharacteristics          : u16,
    SizeOfStackReserve          : ULONGLONG,
    SizeOfStackCommit           : ULONGLONG,
    SizeOfHeapReserve           : ULONGLONG,
    SizeOfHeapCommit            : ULONGLONG,
    LoaderFlags                 : u32,
    NumberOfRvaAndSizes         : u32,
    DataDirectory               : [16]IMAGE_DATA_DIRECTORY,
 };

 IMAGE_OPTIONAL_HEADER :: IMAGE_OPTIONAL_HEADER32;

 PIMAGE_OPTIONAL_HEADER :: PIMAGE_OPTIONAL_HEADER32;

 IMAGE_NT_HEADERS64 :: struct {
    Signature      : u32,
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_OPTIONAL_HEADER64,
 };
 PIMAGE_NT_HEADERS64 :: ^struct {
    Signature      : u32,
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_OPTIONAL_HEADER64,
 };

 IMAGE_NT_HEADERS32 :: struct {
    Signature      : u32,
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_OPTIONAL_HEADER32,
 };
 PIMAGE_NT_HEADERS32 :: ^struct {
    Signature      : u32,
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_OPTIONAL_HEADER32,
 };

 IMAGE_ROM_HEADERS :: struct {
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_ROM_OPTIONAL_HEADER,
 };
 PIMAGE_ROM_HEADERS :: ^struct {
    FileHeader     : IMAGE_FILE_HEADER,
    OptionalHeader : IMAGE_ROM_OPTIONAL_HEADER,
 };

 IMAGE_NT_HEADERS :: IMAGE_NT_HEADERS32;

 PIMAGE_NT_HEADERS :: PIMAGE_NT_HEADERS32;

 ANON_OBJECT_HEADER :: struct {
    Sig1          : u16,
    Sig2          : u16,
    Version       : u16,
    Machine       : u16,
    TimeDateStamp : u32,
    ClassID       : CLSID,
    SizeOfData    : u32,
 };

 ANON_OBJECT_HEADER_V2 :: struct {
    Sig1           : u16,
    Sig2           : u16,
    Version        : u16,
    Machine        : u16,
    TimeDateStamp  : u32,
    ClassID        : CLSID,
    SizeOfData     : u32,
    Flags          : u32,
    MetaDataSize   : u32,
    MetaDataOffset : u32,
 };

 ANON_OBJECT_HEADER_BIGOBJ :: struct {
    Sig1                 : u16,
    Sig2                 : u16,
    Version              : u16,
    Machine              : u16,
    TimeDateStamp        : u32,
    ClassID              : CLSID,
    SizeOfData           : u32,
    Flags                : u32,
    MetaDataSize         : u32,
    MetaDataOffset       : u32,
    NumberOfSections     : u32,
    PointerToSymbolTable : u32,
    NumberOfSymbols      : u32,
 };

 IMAGE_SECTION_HEADER :: struct {
    Name                 : [8]BYTE,
    Misc : struct #raw_union {
        PhysicalAddress : u32,
        VirtualSize     : u32,
    },
    VirtualAddress       : u32,
    SizeOfRawData        : u32,
    PointerToRawData     : u32,
    PointerToRelocations : u32,
    PointerToLinenumbers : u32,
    NumberOfRelocations  : u16,
    NumberOfLinenumbers  : u16,
    Characteristics      : u32,
 };
 PIMAGE_SECTION_HEADER :: ^struct {
    Name                 : [8]BYTE,
    Misc : struct #raw_union {
        PhysicalAddress : u32,
        VirtualSize     : u32,
    },
    VirtualAddress       : u32,
    SizeOfRawData        : u32,
    PointerToRawData     : u32,
    PointerToRelocations : u32,
    PointerToLinenumbers : u32,
    NumberOfRelocations  : u16,
    NumberOfLinenumbers  : u16,
    Characteristics      : u32,
 };

 IMAGE_SYMBOL :: struct {
    N : struct #raw_union {
        ShortName : [8]BYTE,
        Name : struct {
            Short : u32,
            Long  : u32,
        },
        LongName  : [2]u32,
    },
    Value              : u32,
    SectionNumber      : SHORT,
    Type               : u16,
    StorageClass       : BYTE,
    NumberOfAuxSymbols : BYTE,
 };

 PIMAGE_SYMBOL :: ^IMAGE_SYMBOL;

 IMAGE_SYMBOL_EX :: struct {
    N : struct #raw_union {
        ShortName : [8]BYTE,
        Name : struct {
            Short : u32,
            Long  : u32,
        },
        LongName  : [2]u32,
    },
    Value              : u32,
    SectionNumber      : LONG,
    Type               : u16,
    StorageClass       : BYTE,
    NumberOfAuxSymbols : BYTE,
 };

 PIMAGE_SYMBOL_EX :: ^IMAGE_SYMBOL_EX;

 IMAGE_AUX_SYMBOL_TOKEN_DEF :: struct {
    bAuxType         : BYTE,
    bReserved        : BYTE,
    SymbolTableIndex : u32,
    rgbReserved      : [12]BYTE,
 };

 PIMAGE_AUX_SYMBOL_TOKEN_DEF :: ^IMAGE_AUX_SYMBOL_TOKEN_DEF;

 IMAGE_AUX_SYMBOL :: struct #raw_union {
    Sym : struct {
        TagIndex : u32,
        Misc : struct #raw_union {
            LnSz : struct {
                Linenumber : u16,
                Size       : u16,
            },
            TotalSize : u32,
        },
        FcnAry : struct #raw_union {
            Function : struct {
                PointerToLinenumber   : u32,
                PointerToNextFunction : u32,
            },
            Array : struct {
                Dimension : [4]u16,
            },
        },
        TvIndex  : u16,
    },
    File : struct {
        Name : [18]BYTE,
    },
    Section : struct {
        Length              : u32,
        NumberOfRelocations : u16,
        NumberOfLinenumbers : u16,
        CheckSum            : u32,
        Number              : SHORT,
        Selection           : BYTE,
        bReserved           : BYTE,
        HighNumber          : SHORT,
    },
    TokenDef : IMAGE_AUX_SYMBOL_TOKEN_DEF,
    CRC : struct {
        crc         : u32,
        rgbReserved : [14]BYTE,
    },
 };

 PIMAGE_AUX_SYMBOL :: ^IMAGE_AUX_SYMBOL;

 IMAGE_AUX_SYMBOL_EX :: struct #raw_union {
    Sym : struct {
        WeakDefaultSymIndex : u32,
        WeakSearchType      : u32,
        rgbReserved         : [12]BYTE,
    },
    File : struct {
        Name : [size_of(IMAGE_SYMBOL_EX)]BYTE,
    },
    Section : struct {
        Length              : u32,
        NumberOfRelocations : u16,
        NumberOfLinenumbers : u16,
        CheckSum            : u32,
        Number              : SHORT,
        Selection           : BYTE,
        bReserved           : BYTE,
        HighNumber          : SHORT,
        rgbReserved         : [2]BYTE,
    },
    s : struct {
        TokenDef    : IMAGE_AUX_SYMBOL_TOKEN_DEF,
        rgbReserved : [2]BYTE,
    },
    CRC : struct {
        crc         : u32,
        rgbReserved : [16]BYTE,
    },
 };

 PIMAGE_AUX_SYMBOL_EX :: ^IMAGE_AUX_SYMBOL_EX;

 IMAGE_AUX_SYMBOL_TYPE :: enum {
    IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF = 1,
 };

 IMAGE_RELOCATION :: struct {
    u : struct #raw_union {
        VirtualAddress : u32,
        RelocCount     : u32,
    },
    SymbolTableIndex : u32,
    Type             : u16,
 };

 PIMAGE_RELOCATION :: ^IMAGE_RELOCATION;

 IMAGE_LINENUMBER :: struct {
    Type : struct #raw_union {
        SymbolTableIndex : u32,
        VirtualAddress   : u32,
    },
    Linenumber : u16,
 };

 PIMAGE_LINENUMBER :: ^IMAGE_LINENUMBER;

 IMAGE_BASE_RELOCATION :: struct {
    VirtualAddress : u32,
    SizeOfBlock    : u32,
 };

 PIMAGE_BASE_RELOCATION :: ^IMAGE_BASE_RELOCATION;

 IMAGE_ARCHIVE_MEMBER_HEADER :: struct {
    Name      : [16]BYTE,
    Date      : [12]BYTE,
    UserID    : [6]BYTE,
    GroupID   : [6]BYTE,
    Mode      : [8]BYTE,
    Size      : [10]BYTE,
    EndHeader : [2]BYTE,
 };
 PIMAGE_ARCHIVE_MEMBER_HEADER :: ^struct {
    Name      : [16]BYTE,
    Date      : [12]BYTE,
    UserID    : [6]BYTE,
    GroupID   : [6]BYTE,
    Mode      : [8]BYTE,
    Size      : [10]BYTE,
    EndHeader : [2]BYTE,
 };

 IMAGE_EXPORT_DIRECTORY :: struct {
    Characteristics       : u32,
    TimeDateStamp         : u32,
    MajorVersion          : u16,
    MinorVersion          : u16,
    Name                  : u32,
    Base                  : u32,
    NumberOfFunctions     : u32,
    NumberOfNames         : u32,
    AddressOfFunctions    : u32,
    AddressOfNames        : u32,
    AddressOfNameOrdinals : u32,
 };
 PIMAGE_EXPORT_DIRECTORY :: ^struct {
    Characteristics       : u32,
    TimeDateStamp         : u32,
    MajorVersion          : u16,
    MinorVersion          : u16,
    Name                  : u32,
    Base                  : u32,
    NumberOfFunctions     : u32,
    NumberOfNames         : u32,
    AddressOfFunctions    : u32,
    AddressOfNames        : u32,
    AddressOfNameOrdinals : u32,
 };

 IMAGE_IMPORT_BY_NAME :: struct {
    Hint : u16,
    Name : [1]CHAR,
 };
 PIMAGE_IMPORT_BY_NAME :: ^struct {
    Hint : u16,
    Name : [1]CHAR,
 };

 IMAGE_THUNK_DATA64 :: struct {
    u1 : struct #raw_union {
        ForwarderString : ULONGLONG,
        Function        : ULONGLONG,
        Ordinal         : ULONGLONG,
        AddressOfData   : ULONGLONG,
    },
 };

 PIMAGE_THUNK_DATA64 :: ^IMAGE_THUNK_DATA64;

 IMAGE_THUNK_DATA32 :: struct {
    u1 : struct #raw_union {
        ForwarderString : u32,
        Function        : u32,
        Ordinal         : u32,
        AddressOfData   : u32,
    },
 };

 PIMAGE_THUNK_DATA32 :: ^IMAGE_THUNK_DATA32;

 PIMAGE_TLS_CALLBACK :: proc(DllHandle : PVOID, Reason : u32, Reserved : PVOID);

 IMAGE_TLS_DIRECTORY64 :: struct {
    StartAddressOfRawData : ULONGLONG,
    EndAddressOfRawData   : ULONGLONG,
    AddressOfIndex        : ULONGLONG,
    AddressOfCallBacks    : ULONGLONG,
    SizeOfZeroFill        : u32,
    u : struct #raw_union {
        Characteristics : u32,
        s : struct {
            Reserved0 : ,
            Alignment : ,
            Reserved1 : ,
        },
    },
 };

 PIMAGE_TLS_DIRECTORY64 :: ^IMAGE_TLS_DIRECTORY64;

 IMAGE_TLS_DIRECTORY32 :: struct {
    StartAddressOfRawData : u32,
    EndAddressOfRawData   : u32,
    AddressOfIndex        : u32,
    AddressOfCallBacks    : u32,
    SizeOfZeroFill        : u32,
    u : struct #raw_union {
        Characteristics : u32,
        s : struct {
            Reserved0 : ,
            Alignment : ,
            Reserved1 : ,
        },
    },
 };

 PIMAGE_TLS_DIRECTORY32 :: ^IMAGE_TLS_DIRECTORY32;

 IMAGE_THUNK_DATA :: IMAGE_THUNK_DATA32;

 PIMAGE_THUNK_DATA :: PIMAGE_THUNK_DATA32;

 IMAGE_TLS_DIRECTORY :: IMAGE_TLS_DIRECTORY32;

 PIMAGE_TLS_DIRECTORY :: PIMAGE_TLS_DIRECTORY32;

 IMAGE_IMPORT_DESCRIPTOR :: struct {
    u : struct #raw_union {
        Characteristics    : u32,
        OriginalFirstThunk : u32,
    },
    TimeDateStamp  : u32,
    ForwarderChain : u32,
    Name           : u32,
    FirstThunk     : u32,
 };

 PIMAGE_IMPORT_DESCRIPTOR :: ^IMAGE_IMPORT_DESCRIPTOR;

 IMAGE_BOUND_IMPORT_DESCRIPTOR :: struct {
    TimeDateStamp               : u32,
    OffsetModuleName            : u16,
    NumberOfModuleForwarderRefs : u16,
 };
 PIMAGE_BOUND_IMPORT_DESCRIPTOR :: ^struct {
    TimeDateStamp               : u32,
    OffsetModuleName            : u16,
    NumberOfModuleForwarderRefs : u16,
 };

 IMAGE_BOUND_FORWARDER_REF :: struct {
    TimeDateStamp    : u32,
    OffsetModuleName : u16,
    Reserved         : u16,
 };
 PIMAGE_BOUND_FORWARDER_REF :: ^struct {
    TimeDateStamp    : u32,
    OffsetModuleName : u16,
    Reserved         : u16,
 };

 IMAGE_DELAYLOAD_DESCRIPTOR :: struct {
    Attributes : struct #raw_union {
        AllAttributes : u32,
        s : struct {
            RvaBased           : ,
            ReservedAttributes : ,
        },
    },
    DllNameRVA                 : u32,
    ModuleHandleRVA            : u32,
    ImportAddressTableRVA      : u32,
    ImportNameTableRVA         : u32,
    BoundImportAddressTableRVA : u32,
    UnloadInformationTableRVA  : u32,
    TimeDateStamp              : u32,
 };
 PIMAGE_DELAYLOAD_DESCRIPTOR :: ^struct {
    Attributes : struct #raw_union {
        AllAttributes : u32,
        s : struct {
            RvaBased           : ,
            ReservedAttributes : ,
        },
    },
    DllNameRVA                 : u32,
    ModuleHandleRVA            : u32,
    ImportAddressTableRVA      : u32,
    ImportNameTableRVA         : u32,
    BoundImportAddressTableRVA : u32,
    UnloadInformationTableRVA  : u32,
    TimeDateStamp              : u32,
 };

 PCIMAGE_DELAYLOAD_DESCRIPTOR :: ^IMAGE_DELAYLOAD_DESCRIPTOR;

 IMAGE_RESOURCE_DIRECTORY :: struct {
    Characteristics      : u32,
    TimeDateStamp        : u32,
    MajorVersion         : u16,
    MinorVersion         : u16,
    NumberOfNamedEntries : u16,
    NumberOfIdEntries    : u16,
 };
 PIMAGE_RESOURCE_DIRECTORY :: ^struct {
    Characteristics      : u32,
    TimeDateStamp        : u32,
    MajorVersion         : u16,
    MinorVersion         : u16,
    NumberOfNamedEntries : u16,
    NumberOfIdEntries    : u16,
 };

 IMAGE_RESOURCE_DIRECTORY_ENTRY :: struct {
    u : struct #raw_union {
        s : struct {
            NameOffset   : ,
            NameIsString : ,
        },
        Name : u32,
        Id   : u16,
    },
    u2 : struct #raw_union {
        OffsetToData : u32,
        s2 : struct {
            OffsetToDirectory : ,
            DataIsDirectory   : ,
        },
    },
 };
 PIMAGE_RESOURCE_DIRECTORY_ENTRY :: ^struct {
    u : struct #raw_union {
        s : struct {
            NameOffset   : ,
            NameIsString : ,
        },
        Name : u32,
        Id   : u16,
    },
    u2 : struct #raw_union {
        OffsetToData : u32,
        s2 : struct {
            OffsetToDirectory : ,
            DataIsDirectory   : ,
        },
    },
 };

 IMAGE_RESOURCE_DIRECTORY_STRING :: struct {
    Length     : u16,
    NameString : [1]CHAR,
 };
 PIMAGE_RESOURCE_DIRECTORY_STRING :: ^struct {
    Length     : u16,
    NameString : [1]CHAR,
 };

 IMAGE_RESOURCE_DIR_STRING_U :: struct {
    Length     : u16,
    NameString : [1]WCHAR,
 };
 PIMAGE_RESOURCE_DIR_STRING_U :: ^struct {
    Length     : u16,
    NameString : [1]WCHAR,
 };

 IMAGE_RESOURCE_DATA_ENTRY :: struct {
    OffsetToData : u32,
    Size         : u32,
    CodePage     : u32,
    Reserved     : u32,
 };
 PIMAGE_RESOURCE_DATA_ENTRY :: ^struct {
    OffsetToData : u32,
    Size         : u32,
    CodePage     : u32,
    Reserved     : u32,
 };

 IMAGE_LOAD_CONFIG_CODE_INTEGRITY :: struct {
    Flags         : u16,
    Catalog       : u16,
    CatalogOffset : u32,
    Reserved      : u32,
 };
 PIMAGE_LOAD_CONFIG_CODE_INTEGRITY :: ^struct {
    Flags         : u16,
    Catalog       : u16,
    CatalogOffset : u32,
    Reserved      : u32,
 };

 IMAGE_DYNAMIC_RELOCATION_TABLE :: struct {
    Version : u32,
    Size    : u32,
 };
 PIMAGE_DYNAMIC_RELOCATION_TABLE :: ^struct {
    Version : u32,
    Size    : u32,
 };

 IMAGE_DYNAMIC_RELOCATION32 :: struct {
    Symbol        : u32,
    BaseRelocSize : u32,
 };
 PIMAGE_DYNAMIC_RELOCATION32 :: ^struct {
    Symbol        : u32,
    BaseRelocSize : u32,
 };

 IMAGE_DYNAMIC_RELOCATION64 :: struct {
    Symbol        : ULONGLONG,
    BaseRelocSize : u32,
 };
 PIMAGE_DYNAMIC_RELOCATION64 :: ^struct {
    Symbol        : ULONGLONG,
    BaseRelocSize : u32,
 };

 IMAGE_DYNAMIC_RELOCATION32_V2 :: struct {
    HeaderSize    : u32,
    FixupInfoSize : u32,
    Symbol        : u32,
    SymbolGroup   : u32,
    Flags         : u32,
 };
 PIMAGE_DYNAMIC_RELOCATION32_V2 :: ^struct {
    HeaderSize    : u32,
    FixupInfoSize : u32,
    Symbol        : u32,
    SymbolGroup   : u32,
    Flags         : u32,
 };

 IMAGE_DYNAMIC_RELOCATION64_V2 :: struct {
    HeaderSize    : u32,
    FixupInfoSize : u32,
    Symbol        : ULONGLONG,
    SymbolGroup   : u32,
    Flags         : u32,
 };
 PIMAGE_DYNAMIC_RELOCATION64_V2 :: ^struct {
    HeaderSize    : u32,
    FixupInfoSize : u32,
    Symbol        : ULONGLONG,
    SymbolGroup   : u32,
    Flags         : u32,
 };

 IMAGE_DYNAMIC_RELOCATION :: IMAGE_DYNAMIC_RELOCATION32;

 PIMAGE_DYNAMIC_RELOCATION :: PIMAGE_DYNAMIC_RELOCATION32;

 IMAGE_DYNAMIC_RELOCATION_V2 :: IMAGE_DYNAMIC_RELOCATION32_V2;

 PIMAGE_DYNAMIC_RELOCATION_V2 :: PIMAGE_DYNAMIC_RELOCATION32_V2;

 IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER :: struct {
    PrologueByteCount : BYTE,
 };

 PIMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER :: ^IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER;

 IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER :: struct {
    EpilogueCount               : u32,
    EpilogueByteCount           : BYTE,
    BranchDescriptorElementSize : BYTE,
    BranchDescriptorCount       : u16,
 };

 PIMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER :: ^IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER;

 IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: struct {
    PageRelativeOffset : ,
    IndirectCall       : ,
    IATIndex           : ,
 };

 PIMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: ^IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION;

 IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: struct {
    PageRelativeOffset : ,
    IndirectCall       : ,
    RexWPrefix         : ,
    CfgCheck           : ,
    Reserved           : ,
 };

 PIMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: ^IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION;

 IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION :: struct {
    PageRelativeOffset : ,
    RegisterNumber     : ,
 };

 PIMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION :: ^IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION;

 IMAGE_LOAD_CONFIG_DIRECTORY32 :: struct {
    Size                                     : u32,
    TimeDateStamp                            : u32,
    MajorVersion                             : u16,
    MinorVersion                             : u16,
    GlobalFlagsClear                         : u32,
    GlobalFlagsSet                           : u32,
    CriticalSectionDefaultTimeout            : u32,
    DeCommitFreeBlockThreshold               : u32,
    DeCommitTotalFreeThreshold               : u32,
    LockPrefixTable                          : u32,
    MaximumAllocationSize                    : u32,
    VirtualMemoryThreshold                   : u32,
    ProcessHeapFlags                         : u32,
    ProcessAffinityMask                      : u32,
    CSDVersion                               : u16,
    DependentLoadFlags                       : u16,
    EditList                                 : u32,
    SecurityCookie                           : u32,
    SEHandlerTable                           : u32,
    SEHandlerCount                           : u32,
    GuardCFCheckFunctionPointer              : u32,
    GuardCFDispatchFunctionPointer           : u32,
    GuardCFFunctionTable                     : u32,
    GuardCFFunctionCount                     : u32,
    GuardFlags                               : u32,
    CodeIntegrity                            : IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
    GuardAddressTakenIatEntryTable           : u32,
    GuardAddressTakenIatEntryCount           : u32,
    GuardLongJumpTargetTable                 : u32,
    GuardLongJumpTargetCount                 : u32,
    DynamicValueRelocTable                   : u32,
    CHPEMetadataPointer                      : u32,
    GuardRFFailureRoutine                    : u32,
    GuardRFFailureRoutineFunctionPointer     : u32,
    DynamicValueRelocTableOffset             : u32,
    DynamicValueRelocTableSection            : u16,
    Reserved2                                : u16,
    GuardRFVerifyStackPointerFunctionPointer : u32,
    HotPatchTableOffset                      : u32,
    Reserved3                                : u32,
    EnclaveConfigurationPointer              : u32,
    VolatileMetadataPointer                  : u32,
 };
 PIMAGE_LOAD_CONFIG_DIRECTORY32 :: ^struct {
    Size                                     : u32,
    TimeDateStamp                            : u32,
    MajorVersion                             : u16,
    MinorVersion                             : u16,
    GlobalFlagsClear                         : u32,
    GlobalFlagsSet                           : u32,
    CriticalSectionDefaultTimeout            : u32,
    DeCommitFreeBlockThreshold               : u32,
    DeCommitTotalFreeThreshold               : u32,
    LockPrefixTable                          : u32,
    MaximumAllocationSize                    : u32,
    VirtualMemoryThreshold                   : u32,
    ProcessHeapFlags                         : u32,
    ProcessAffinityMask                      : u32,
    CSDVersion                               : u16,
    DependentLoadFlags                       : u16,
    EditList                                 : u32,
    SecurityCookie                           : u32,
    SEHandlerTable                           : u32,
    SEHandlerCount                           : u32,
    GuardCFCheckFunctionPointer              : u32,
    GuardCFDispatchFunctionPointer           : u32,
    GuardCFFunctionTable                     : u32,
    GuardCFFunctionCount                     : u32,
    GuardFlags                               : u32,
    CodeIntegrity                            : IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
    GuardAddressTakenIatEntryTable           : u32,
    GuardAddressTakenIatEntryCount           : u32,
    GuardLongJumpTargetTable                 : u32,
    GuardLongJumpTargetCount                 : u32,
    DynamicValueRelocTable                   : u32,
    CHPEMetadataPointer                      : u32,
    GuardRFFailureRoutine                    : u32,
    GuardRFFailureRoutineFunctionPointer     : u32,
    DynamicValueRelocTableOffset             : u32,
    DynamicValueRelocTableSection            : u16,
    Reserved2                                : u16,
    GuardRFVerifyStackPointerFunctionPointer : u32,
    HotPatchTableOffset                      : u32,
    Reserved3                                : u32,
    EnclaveConfigurationPointer              : u32,
    VolatileMetadataPointer                  : u32,
 };

 IMAGE_LOAD_CONFIG_DIRECTORY64 :: struct {
    Size                                     : u32,
    TimeDateStamp                            : u32,
    MajorVersion                             : u16,
    MinorVersion                             : u16,
    GlobalFlagsClear                         : u32,
    GlobalFlagsSet                           : u32,
    CriticalSectionDefaultTimeout            : u32,
    DeCommitFreeBlockThreshold               : ULONGLONG,
    DeCommitTotalFreeThreshold               : ULONGLONG,
    LockPrefixTable                          : ULONGLONG,
    MaximumAllocationSize                    : ULONGLONG,
    VirtualMemoryThreshold                   : ULONGLONG,
    ProcessAffinityMask                      : ULONGLONG,
    ProcessHeapFlags                         : u32,
    CSDVersion                               : u16,
    DependentLoadFlags                       : u16,
    EditList                                 : ULONGLONG,
    SecurityCookie                           : ULONGLONG,
    SEHandlerTable                           : ULONGLONG,
    SEHandlerCount                           : ULONGLONG,
    GuardCFCheckFunctionPointer              : ULONGLONG,
    GuardCFDispatchFunctionPointer           : ULONGLONG,
    GuardCFFunctionTable                     : ULONGLONG,
    GuardCFFunctionCount                     : ULONGLONG,
    GuardFlags                               : u32,
    CodeIntegrity                            : IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
    GuardAddressTakenIatEntryTable           : ULONGLONG,
    GuardAddressTakenIatEntryCount           : ULONGLONG,
    GuardLongJumpTargetTable                 : ULONGLONG,
    GuardLongJumpTargetCount                 : ULONGLONG,
    DynamicValueRelocTable                   : ULONGLONG,
    CHPEMetadataPointer                      : ULONGLONG,
    GuardRFFailureRoutine                    : ULONGLONG,
    GuardRFFailureRoutineFunctionPointer     : ULONGLONG,
    DynamicValueRelocTableOffset             : u32,
    DynamicValueRelocTableSection            : u16,
    Reserved2                                : u16,
    GuardRFVerifyStackPointerFunctionPointer : ULONGLONG,
    HotPatchTableOffset                      : u32,
    Reserved3                                : u32,
    EnclaveConfigurationPointer              : ULONGLONG,
    VolatileMetadataPointer                  : ULONGLONG,
 };
 PIMAGE_LOAD_CONFIG_DIRECTORY64 :: ^struct {
    Size                                     : u32,
    TimeDateStamp                            : u32,
    MajorVersion                             : u16,
    MinorVersion                             : u16,
    GlobalFlagsClear                         : u32,
    GlobalFlagsSet                           : u32,
    CriticalSectionDefaultTimeout            : u32,
    DeCommitFreeBlockThreshold               : ULONGLONG,
    DeCommitTotalFreeThreshold               : ULONGLONG,
    LockPrefixTable                          : ULONGLONG,
    MaximumAllocationSize                    : ULONGLONG,
    VirtualMemoryThreshold                   : ULONGLONG,
    ProcessAffinityMask                      : ULONGLONG,
    ProcessHeapFlags                         : u32,
    CSDVersion                               : u16,
    DependentLoadFlags                       : u16,
    EditList                                 : ULONGLONG,
    SecurityCookie                           : ULONGLONG,
    SEHandlerTable                           : ULONGLONG,
    SEHandlerCount                           : ULONGLONG,
    GuardCFCheckFunctionPointer              : ULONGLONG,
    GuardCFDispatchFunctionPointer           : ULONGLONG,
    GuardCFFunctionTable                     : ULONGLONG,
    GuardCFFunctionCount                     : ULONGLONG,
    GuardFlags                               : u32,
    CodeIntegrity                            : IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
    GuardAddressTakenIatEntryTable           : ULONGLONG,
    GuardAddressTakenIatEntryCount           : ULONGLONG,
    GuardLongJumpTargetTable                 : ULONGLONG,
    GuardLongJumpTargetCount                 : ULONGLONG,
    DynamicValueRelocTable                   : ULONGLONG,
    CHPEMetadataPointer                      : ULONGLONG,
    GuardRFFailureRoutine                    : ULONGLONG,
    GuardRFFailureRoutineFunctionPointer     : ULONGLONG,
    DynamicValueRelocTableOffset             : u32,
    DynamicValueRelocTableSection            : u16,
    Reserved2                                : u16,
    GuardRFVerifyStackPointerFunctionPointer : ULONGLONG,
    HotPatchTableOffset                      : u32,
    Reserved3                                : u32,
    EnclaveConfigurationPointer              : ULONGLONG,
    VolatileMetadataPointer                  : ULONGLONG,
 };

 IMAGE_LOAD_CONFIG_DIRECTORY :: IMAGE_LOAD_CONFIG_DIRECTORY32;

 PIMAGE_LOAD_CONFIG_DIRECTORY :: PIMAGE_LOAD_CONFIG_DIRECTORY32;

 IMAGE_HOT_PATCH_INFO :: struct {
    Version        : u32,
    Size           : u32,
    SequenceNumber : u32,
    BaseImageList  : u32,
    BaseImageCount : u32,
    BufferOffset   : u32,
    ExtraPatchSize : u32,
 };
 PIMAGE_HOT_PATCH_INFO :: ^struct {
    Version        : u32,
    Size           : u32,
    SequenceNumber : u32,
    BaseImageList  : u32,
    BaseImageCount : u32,
    BufferOffset   : u32,
    ExtraPatchSize : u32,
 };

 IMAGE_HOT_PATCH_BASE :: struct {
    SequenceNumber        : u32,
    Flags                 : u32,
    OriginalTimeDateStamp : u32,
    OriginalCheckSum      : u32,
    CodeIntegrityInfo     : u32,
    CodeIntegritySize     : u32,
    PatchTable            : u32,
    BufferOffset          : u32,
 };
 PIMAGE_HOT_PATCH_BASE :: ^struct {
    SequenceNumber        : u32,
    Flags                 : u32,
    OriginalTimeDateStamp : u32,
    OriginalCheckSum      : u32,
    CodeIntegrityInfo     : u32,
    CodeIntegritySize     : u32,
    PatchTable            : u32,
    BufferOffset          : u32,
 };

 IMAGE_HOT_PATCH_HASHES :: struct {
    SHA256 : [32]BYTE,
    SHA1   : [20]BYTE,
 };
 PIMAGE_HOT_PATCH_HASHES :: ^struct {
    SHA256 : [32]BYTE,
    SHA1   : [20]BYTE,
 };

 IMAGE_CE_RUNTIME_FUNCTION_ENTRY :: struct {
    FuncStart     : u32,
    PrologLen     : ,
    FuncLen       : ,
    ThirtyTwoBit  : ,
    ExceptionFlag : ,
 };
 PIMAGE_CE_RUNTIME_FUNCTION_ENTRY :: ^struct {
    FuncStart     : u32,
    PrologLen     : ,
    FuncLen       : ,
    ThirtyTwoBit  : ,
    ExceptionFlag : ,
 };

 IMAGE_ARM_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress : u32,
    u : struct #raw_union {
        UnwindData : u32,
        s : struct {
            Flag           : ,
            FunctionLength : ,
            Ret            : ,
            H              : ,
            Reg            : ,
            R              : ,
            L              : ,
            C              : ,
            StackAdjust    : ,
        },
    },
 };
 PIMAGE_ARM_RUNTIME_FUNCTION_ENTRY :: ^struct {
    BeginAddress : u32,
    u : struct #raw_union {
        UnwindData : u32,
        s : struct {
            Flag           : ,
            FunctionLength : ,
            Ret            : ,
            H              : ,
            Reg            : ,
            R              : ,
            L              : ,
            C              : ,
            StackAdjust    : ,
        },
    },
 };

 IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress : u32,
    u : struct #raw_union {
        UnwindData : u32,
        s : struct {
            Flag           : ,
            FunctionLength : ,
            RegF           : ,
            RegI           : ,
            H              : ,
            CR             : ,
            FrameSize      : ,
        },
    },
 };
 PIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY :: ^struct {
    BeginAddress : u32,
    u : struct #raw_union {
        UnwindData : u32,
        s : struct {
            Flag           : ,
            FunctionLength : ,
            RegF           : ,
            RegI           : ,
            H              : ,
            CR             : ,
            FrameSize      : ,
        },
    },
 };

 IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress     : ULONGLONG,
    EndAddress       : ULONGLONG,
    ExceptionHandler : ULONGLONG,
    HandlerData      : ULONGLONG,
    PrologEndAddress : ULONGLONG,
 };
 PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY :: ^struct {
    BeginAddress     : ULONGLONG,
    EndAddress       : ULONGLONG,
    ExceptionHandler : ULONGLONG,
    HandlerData      : ULONGLONG,
    PrologEndAddress : ULONGLONG,
 };

 IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress     : u32,
    EndAddress       : u32,
    ExceptionHandler : u32,
    HandlerData      : u32,
    PrologEndAddress : u32,
 };
 PIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY :: ^struct {
    BeginAddress     : u32,
    EndAddress       : u32,
    ExceptionHandler : u32,
    HandlerData      : u32,
    PrologEndAddress : u32,
 };

 _IMAGE_RUNTIME_FUNCTION_ENTRY :: struct {
    BeginAddress : u32,
    EndAddress   : u32,
    u : struct #raw_union {
        UnwindInfoAddress : u32,
        UnwindData        : u32,
    },
 };
 _PIMAGE_RUNTIME_FUNCTION_ENTRY :: ^struct {
    BeginAddress : u32,
    EndAddress   : u32,
    u : struct #raw_union {
        UnwindInfoAddress : u32,
        UnwindData        : u32,
    },
 };

 IMAGE_IA64_RUNTIME_FUNCTION_ENTRY :: _IMAGE_RUNTIME_FUNCTION_ENTRY;

 PIMAGE_IA64_RUNTIME_FUNCTION_ENTRY :: _PIMAGE_RUNTIME_FUNCTION_ENTRY;

 IMAGE_RUNTIME_FUNCTION_ENTRY :: _IMAGE_RUNTIME_FUNCTION_ENTRY;

 PIMAGE_RUNTIME_FUNCTION_ENTRY :: _PIMAGE_RUNTIME_FUNCTION_ENTRY;

 IMAGE_ENCLAVE_CONFIG32 :: struct {
    Size                      : u32,
    MinimumRequiredConfigSize : u32,
    PolicyFlags               : u32,
    NumberOfImports           : u32,
    ImportList                : u32,
    ImportEntrySize           : u32,
    FamilyID                  : [16]BYTE,
    ImageID                   : [16]BYTE,
    ImageVersion              : u32,
    SecurityVersion           : u32,
    EnclaveSize               : u32,
    NumberOfThreads           : u32,
    EnclaveFlags              : u32,
 };
 PIMAGE_ENCLAVE_CONFIG32 :: ^struct {
    Size                      : u32,
    MinimumRequiredConfigSize : u32,
    PolicyFlags               : u32,
    NumberOfImports           : u32,
    ImportList                : u32,
    ImportEntrySize           : u32,
    FamilyID                  : [16]BYTE,
    ImageID                   : [16]BYTE,
    ImageVersion              : u32,
    SecurityVersion           : u32,
    EnclaveSize               : u32,
    NumberOfThreads           : u32,
    EnclaveFlags              : u32,
 };

 IMAGE_ENCLAVE_CONFIG64 :: struct {
    Size                      : u32,
    MinimumRequiredConfigSize : u32,
    PolicyFlags               : u32,
    NumberOfImports           : u32,
    ImportList                : u32,
    ImportEntrySize           : u32,
    FamilyID                  : [16]BYTE,
    ImageID                   : [16]BYTE,
    ImageVersion              : u32,
    SecurityVersion           : u32,
    EnclaveSize               : ULONGLONG,
    NumberOfThreads           : u32,
    EnclaveFlags              : u32,
 };
 PIMAGE_ENCLAVE_CONFIG64 :: ^struct {
    Size                      : u32,
    MinimumRequiredConfigSize : u32,
    PolicyFlags               : u32,
    NumberOfImports           : u32,
    ImportList                : u32,
    ImportEntrySize           : u32,
    FamilyID                  : [16]BYTE,
    ImageID                   : [16]BYTE,
    ImageVersion              : u32,
    SecurityVersion           : u32,
    EnclaveSize               : ULONGLONG,
    NumberOfThreads           : u32,
    EnclaveFlags              : u32,
 };

 IMAGE_ENCLAVE_CONFIG :: IMAGE_ENCLAVE_CONFIG32;

 PIMAGE_ENCLAVE_CONFIG :: PIMAGE_ENCLAVE_CONFIG32;

 IMAGE_ENCLAVE_IMPORT :: struct {
    MatchType              : u32,
    MinimumSecurityVersion : u32,
    UniqueOrAuthorID       : [32]BYTE,
    FamilyID               : [16]BYTE,
    ImageID                : [16]BYTE,
    ImportName             : u32,
    Reserved               : u32,
 };
 PIMAGE_ENCLAVE_IMPORT :: ^struct {
    MatchType              : u32,
    MinimumSecurityVersion : u32,
    UniqueOrAuthorID       : [32]BYTE,
    FamilyID               : [16]BYTE,
    ImageID                : [16]BYTE,
    ImportName             : u32,
    Reserved               : u32,
 };

 IMAGE_DEBUG_DIRECTORY :: struct {
    Characteristics  : u32,
    TimeDateStamp    : u32,
    MajorVersion     : u16,
    MinorVersion     : u16,
    Type             : u32,
    SizeOfData       : u32,
    AddressOfRawData : u32,
    PointerToRawData : u32,
 };
 PIMAGE_DEBUG_DIRECTORY :: ^struct {
    Characteristics  : u32,
    TimeDateStamp    : u32,
    MajorVersion     : u16,
    MinorVersion     : u16,
    Type             : u32,
    SizeOfData       : u32,
    AddressOfRawData : u32,
    PointerToRawData : u32,
 };

 IMAGE_COFF_SYMBOLS_HEADER :: struct {
    NumberOfSymbols      : u32,
    LvaToFirstSymbol     : u32,
    NumberOfLinenumbers  : u32,
    LvaToFirstLinenumber : u32,
    RvaToFirstByteOfCode : u32,
    RvaToLastByteOfCode  : u32,
    RvaToFirstByteOfData : u32,
    RvaToLastByteOfData  : u32,
 };
 PIMAGE_COFF_SYMBOLS_HEADER :: ^struct {
    NumberOfSymbols      : u32,
    LvaToFirstSymbol     : u32,
    NumberOfLinenumbers  : u32,
    LvaToFirstLinenumber : u32,
    RvaToFirstByteOfCode : u32,
    RvaToLastByteOfCode  : u32,
    RvaToFirstByteOfData : u32,
    RvaToLastByteOfData  : u32,
 };

 FPO_DATA :: struct {
    ulOffStart : u32,
    cbProcSize : u32,
    cdwLocals  : u32,
    cdwParams  : u16,
    cbProlog   : ,
    cbRegs     : ,
    fHasSEH    : ,
    fUseBP     : ,
    reserved   : ,
    cbFrame    : ,
 };
 PFPO_DATA :: ^struct {
    ulOffStart : u32,
    cbProcSize : u32,
    cdwLocals  : u32,
    cdwParams  : u16,
    cbProlog   : ,
    cbRegs     : ,
    fHasSEH    : ,
    fUseBP     : ,
    reserved   : ,
    cbFrame    : ,
 };

 IMAGE_DEBUG_MISC :: struct {
    DataType : u32,
    Length   : u32,
    Unicode  : BOOLEAN,
    Reserved : [3]BYTE,
    Data     : [1]BYTE,
 };
 PIMAGE_DEBUG_MISC :: ^struct {
    DataType : u32,
    Length   : u32,
    Unicode  : BOOLEAN,
    Reserved : [3]BYTE,
    Data     : [1]BYTE,
 };

 IMAGE_FUNCTION_ENTRY :: struct {
    StartingAddress : u32,
    EndingAddress   : u32,
    EndOfPrologue   : u32,
 };
 PIMAGE_FUNCTION_ENTRY :: ^struct {
    StartingAddress : u32,
    EndingAddress   : u32,
    EndOfPrologue   : u32,
 };

 IMAGE_FUNCTION_ENTRY64 :: struct {
    StartingAddress : ULONGLONG,
    EndingAddress   : ULONGLONG,
    u : struct #raw_union {
        EndOfPrologue     : ULONGLONG,
        UnwindInfoAddress : ULONGLONG,
    },
 };
 PIMAGE_FUNCTION_ENTRY64 :: ^struct {
    StartingAddress : ULONGLONG,
    EndingAddress   : ULONGLONG,
    u : struct #raw_union {
        EndOfPrologue     : ULONGLONG,
        UnwindInfoAddress : ULONGLONG,
    },
 };

 IMAGE_SEPARATE_DEBUG_HEADER :: struct {
    Signature          : u16,
    Flags              : u16,
    Machine            : u16,
    Characteristics    : u16,
    TimeDateStamp      : u32,
    CheckSum           : u32,
    ImageBase          : u32,
    SizeOfImage        : u32,
    NumberOfSections   : u32,
    ExportedNamesSize  : u32,
    DebugDirectorySize : u32,
    SectionAlignment   : u32,
    Reserved           : [2]u32,
 };
 PIMAGE_SEPARATE_DEBUG_HEADER :: ^struct {
    Signature          : u16,
    Flags              : u16,
    Machine            : u16,
    Characteristics    : u16,
    TimeDateStamp      : u32,
    CheckSum           : u32,
    ImageBase          : u32,
    SizeOfImage        : u32,
    NumberOfSections   : u32,
    ExportedNamesSize  : u32,
    DebugDirectorySize : u32,
    SectionAlignment   : u32,
    Reserved           : [2]u32,
 };

 NON_PAGED_DEBUG_INFO :: struct {
    Signature       : u16,
    Flags           : u16,
    Size            : u32,
    Machine         : u16,
    Characteristics : u16,
    TimeDateStamp   : u32,
    CheckSum        : u32,
    SizeOfImage     : u32,
    ImageBase       : ULONGLONG,
 };
 PNON_PAGED_DEBUG_INFO :: ^struct {
    Signature       : u16,
    Flags           : u16,
    Size            : u32,
    Machine         : u16,
    Characteristics : u16,
    TimeDateStamp   : u32,
    CheckSum        : u32,
    SizeOfImage     : u32,
    ImageBase       : ULONGLONG,
 };

 IMAGE_ARCHITECTURE_HEADER :: struct {
    AmaskValue    : ,
    ,
    AmaskShift    : ,
    ,
    FirstEntryRVA : u32,
 };
 PIMAGE_ARCHITECTURE_HEADER :: ^struct {
    AmaskValue    : ,
    ,
    AmaskShift    : ,
    ,
    FirstEntryRVA : u32,
 };

 IMAGE_ARCHITECTURE_ENTRY :: struct {
    FixupInstRVA : u32,
    NewInst      : u32,
 };
 PIMAGE_ARCHITECTURE_ENTRY :: ^struct {
    FixupInstRVA : u32,
    NewInst      : u32,
 };

 IMPORT_OBJECT_HEADER :: struct {
    Sig1          : u16,
    Sig2          : u16,
    Version       : u16,
    Machine       : u16,
    TimeDateStamp : u32,
    SizeOfData    : u32,
    u : struct #raw_union {
        Ordinal : u16,
        Hint    : u16,
    },
    Type          : ,
    NameType      : ,
    Reserved      : ,
 };

 IMPORT_OBJECT_TYPE :: enum {
    IMPORT_OBJECT_CODE = 0,
    IMPORT_OBJECT_DATA = 1,
    IMPORT_OBJECT_CONST = 2,
 };

 IMPORT_OBJECT_NAME_TYPE :: enum {
    IMPORT_OBJECT_ORDINAL = 0,
    IMPORT_OBJECT_NAME = 1,
    IMPORT_OBJECT_NAME_NO_PREFIX = 2,
    IMPORT_OBJECT_NAME_UNDECORATE = 3,
    IMPORT_OBJECT_NAME_EXPORTAS = 4,
 };

 ReplacesCorHdrNumericDefines :: enum {
    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,
 };

 IMAGE_COR20_HEADER :: struct {
    cb                      : u32,
    MajorRuntimeVersion     : u16,
    MinorRuntimeVersion     : u16,
    MetaData                : IMAGE_DATA_DIRECTORY,
    Flags                   : u32,
    u : struct #raw_union {
        EntryPointToken : u32,
        EntryPointRVA   : u32,
    },
    Resources               : IMAGE_DATA_DIRECTORY,
    StrongNameSignature     : IMAGE_DATA_DIRECTORY,
    CodeManagerTable        : IMAGE_DATA_DIRECTORY,
    VTableFixups            : IMAGE_DATA_DIRECTORY,
    ExportAddressTableJumps : IMAGE_DATA_DIRECTORY,
    ManagedNativeHeader     : IMAGE_DATA_DIRECTORY,
 };
 PIMAGE_COR20_HEADER :: ^struct {
    cb                      : u32,
    MajorRuntimeVersion     : u16,
    MinorRuntimeVersion     : u16,
    MetaData                : IMAGE_DATA_DIRECTORY,
    Flags                   : u32,
    u : struct #raw_union {
        EntryPointToken : u32,
        EntryPointRVA   : u32,
    },
    Resources               : IMAGE_DATA_DIRECTORY,
    StrongNameSignature     : IMAGE_DATA_DIRECTORY,
    CodeManagerTable        : IMAGE_DATA_DIRECTORY,
    VTableFixups            : IMAGE_DATA_DIRECTORY,
    ExportAddressTableJumps : IMAGE_DATA_DIRECTORY,
    ManagedNativeHeader     : IMAGE_DATA_DIRECTORY,
 };

 SLIST_ENTRY :: struct {};

 PSLIST_ENTRY :: ^SLIST_ENTRY;

 SLIST_HEADER :: struct #raw_union {
    Alignment : ULONGLONG,
    s : struct {
        Next  : SLIST_ENTRY,
        Depth : u16,
        CpuId : u16,
    },
 };
 PSLIST_HEADER :: ^struct #raw_union {
    Alignment : ULONGLONG,
    s : struct {
        Next  : SLIST_ENTRY,
        Depth : u16,
        CpuId : u16,
    },
 };

 RTL_RUN_ONCE :: struct #raw_union {
    Ptr : PVOID,
 };
 PRTL_RUN_ONCE :: ^struct #raw_union {
    Ptr : PVOID,
 };

 RTL_BARRIER :: struct {
    Reserved1 : u32,
    Reserved2 : u32,
    Reserved3 : [2]ULONG_PTR,
    Reserved4 : u32,
    Reserved5 : u32,
 };
 PRTL_BARRIER :: ^struct {
    Reserved1 : u32,
    Reserved2 : u32,
    Reserved3 : [2]ULONG_PTR,
    Reserved4 : u32,
    Reserved5 : u32,
 };

 MESSAGE_RESOURCE_ENTRY :: struct {
    Length : u16,
    Flags  : u16,
    Text   : [1]BYTE,
 };
 PMESSAGE_RESOURCE_ENTRY :: ^struct {
    Length : u16,
    Flags  : u16,
    Text   : [1]BYTE,
 };

 MESSAGE_RESOURCE_BLOCK :: struct {
    LowId           : u32,
    HighId          : u32,
    OffsetToEntries : u32,
 };
 PMESSAGE_RESOURCE_BLOCK :: ^struct {
    LowId           : u32,
    HighId          : u32,
    OffsetToEntries : u32,
 };

 MESSAGE_RESOURCE_DATA :: struct {
    NumberOfBlocks : u32,
    Blocks         : [1]MESSAGE_RESOURCE_BLOCK,
 };
 PMESSAGE_RESOURCE_DATA :: ^struct {
    NumberOfBlocks : u32,
    Blocks         : [1]MESSAGE_RESOURCE_BLOCK,
 };

 OSVERSIONINFOA :: struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]CHAR,
 };
 POSVERSIONINFOA :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]CHAR,
 };
 LPOSVERSIONINFOA :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]CHAR,
 };

 OSVERSIONINFOW :: struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
 };
 POSVERSIONINFOW :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
 };
 LPOSVERSIONINFOW :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
 };
 RTL_OSVERSIONINFOW :: struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
 };
 PRTL_OSVERSIONINFOW :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
 };

 OSVERSIONINFO :: OSVERSIONINFOA;

 POSVERSIONINFO :: POSVERSIONINFOA;

 LPOSVERSIONINFO :: LPOSVERSIONINFOA;

 OSVERSIONINFOEXA :: struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]CHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };
 POSVERSIONINFOEXA :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]CHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };
 LPOSVERSIONINFOEXA :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]CHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };

 OSVERSIONINFOEXW :: struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };
 POSVERSIONINFOEXW :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };
 LPOSVERSIONINFOEXW :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };
 RTL_OSVERSIONINFOEXW :: struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };
 PRTL_OSVERSIONINFOEXW :: ^struct {
    dwOSVersionInfoSize : u32,
    dwMajorVersion      : u32,
    dwMinorVersion      : u32,
    dwBuildNumber       : u32,
    dwPlatformId        : u32,
    szCSDVersion        : [128]WCHAR,
    wServicePackMajor   : u16,
    wServicePackMinor   : u16,
    wSuiteMask          : u16,
    wProductType        : BYTE,
    wReserved           : BYTE,
 };

 OSVERSIONINFOEX :: OSVERSIONINFOEXA;

 POSVERSIONINFOEX :: POSVERSIONINFOEXA;

 LPOSVERSIONINFOEX :: LPOSVERSIONINFOEXA;

 RTL_UMS_THREAD_INFO_CLASS :: enum {
    UmsThreadInvalidInfoClass = 0,
    UmsThreadUserContext,
    UmsThreadPriority,
    UmsThreadAffinity,
    UmsThreadTeb,
    UmsThreadIsSuspended,
    UmsThreadIsTerminated,
    UmsThreadMaxInfoClass,
 };
 PRTL_UMS_THREAD_INFO_CLASS :: ^enum {
    UmsThreadInvalidInfoClass = 0,
    UmsThreadUserContext,
    UmsThreadPriority,
    UmsThreadAffinity,
    UmsThreadTeb,
    UmsThreadIsSuspended,
    UmsThreadIsTerminated,
    UmsThreadMaxInfoClass,
 };

 RTL_UMS_SCHEDULER_REASON :: enum {
    UmsSchedulerStartup = 0,
    UmsSchedulerThreadBlocked,
    UmsSchedulerThreadYield,
 };
 PRTL_UMS_SCHEDULER_REASON :: ^enum {
    UmsSchedulerStartup = 0,
    UmsSchedulerThreadBlocked,
    UmsSchedulerThreadYield,
 };

 RTL_UMS_SCHEDULER_ENTRY_POINT :: #type proc(Reason : RTL_UMS_SCHEDULER_REASON, ActivationPayload : ULONG_PTR, SchedulerParam : PVOID);

 PRTL_UMS_SCHEDULER_ENTRY_POINT :: ^RTL_UMS_SCHEDULER_ENTRY_POINT;

 OS_DEPLOYEMENT_STATE_VALUES :: enum {
    OS_DEPLOYMENT_STANDARD = 1,
    OS_DEPLOYMENT_COMPACT,
 };

 NV_MEMORY_RANGE :: struct {
    BaseAddress : rawptr,
    Length      : SIZE_T,
 };
 PNV_MEMORY_RANGE :: ^struct {
    BaseAddress : rawptr,
    Length      : SIZE_T,
 };

 CORRELATION_VECTOR :: struct {
    Version : CHAR,
    Vector  : [129]CHAR,
 };

 PCORRELATION_VECTOR :: ^CORRELATION_VECTOR;

 CUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG :: struct {
    Size      : u32,
    TriggerId : PCWSTR,
 };
 PCUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG :: ^struct {
    Size      : u32,
    TriggerId : PCWSTR,
 };

 IMAGE_POLICY_ENTRY_TYPE :: enum {
    ImagePolicyEntryTypeNone = 0,
    ImagePolicyEntryTypeBool,
    ImagePolicyEntryTypeInt8,
    ImagePolicyEntryTypeUInt8,
    ImagePolicyEntryTypeInt16,
    ImagePolicyEntryTypeUInt16,
    ImagePolicyEntryTypeInt32,
    ImagePolicyEntryTypeUInt32,
    ImagePolicyEntryTypeInt64,
    ImagePolicyEntryTypeUInt64,
    ImagePolicyEntryTypeAnsiString,
    ImagePolicyEntryTypeUnicodeString,
    ImagePolicyEntryTypeOverride,
    ImagePolicyEntryTypeMaximum,
 };

 IMAGE_POLICY_ID :: enum {
    ImagePolicyIdNone = 0,
    ImagePolicyIdEtw,
    ImagePolicyIdDebug,
    ImagePolicyIdCrashDump,
    ImagePolicyIdCrashDumpKey,
    ImagePolicyIdCrashDumpKeyGuid,
    ImagePolicyIdParentSd,
    ImagePolicyIdParentSdRev,
    ImagePolicyIdSvn,
    ImagePolicyIdDeviceId,
    ImagePolicyIdCapability,
    ImagePolicyIdScenarioId,
    ImagePolicyIdMaximum,
 };

 IMAGE_POLICY_ENTRY :: struct {
    Type     : IMAGE_POLICY_ENTRY_TYPE,
    PolicyId : IMAGE_POLICY_ID,
    u : struct #raw_union {
        None               : rawptr,
        BoolValue          : BOOLEAN,
        Int8Value          : INT8,
        UInt8Value         : UINT8,
        Int16Value         : INT16,
        UInt16Value        : UINT16,
        Int32Value         : INT32,
        UInt32Value        : UINT32,
        Int64Value         : INT64,
        UInt64Value        : UINT64,
        AnsiStringValue    : PCSTR,
        UnicodeStringValue : PCWSTR,
    },
 };

 PCIMAGE_POLICY_ENTRY :: ^IMAGE_POLICY_ENTRY;

 IMAGE_POLICY_METADATA :: struct {
    Version       : BYTE,
    Reserved0     : [7]BYTE,
    ApplicationId : ULONGLONG,
    Policies      : []IMAGE_POLICY_ENTRY,
 };

 PCIMAGE_POLICY_METADATA :: ^IMAGE_POLICY_METADATA;

 RTL_CRITICAL_SECTION_DEBUG :: struct {
    Type                      : u16,
    CreatorBackTraceIndex     : u16,
    CriticalSection           : ^RTL_CRITICAL_SECTION,
    ProcessLocksList          : LIST_ENTRY,
    EntryCount                : u32,
    ContentionCount           : u32,
    Flags                     : u32,
    CreatorBackTraceIndexHigh : u16,
    SpareWORD                 : u16,
 };
 PRTL_CRITICAL_SECTION_DEBUG :: ^struct {
    Type                      : u16,
    CreatorBackTraceIndex     : u16,
    CriticalSection           : ^RTL_CRITICAL_SECTION,
    ProcessLocksList          : LIST_ENTRY,
    EntryCount                : u32,
    ContentionCount           : u32,
    Flags                     : u32,
    CreatorBackTraceIndexHigh : u16,
    SpareWORD                 : u16,
 };
 RTL_RESOURCE_DEBUG :: struct {
    Type                      : u16,
    CreatorBackTraceIndex     : u16,
    CriticalSection           : ^RTL_CRITICAL_SECTION,
    ProcessLocksList          : LIST_ENTRY,
    EntryCount                : u32,
    ContentionCount           : u32,
    Flags                     : u32,
    CreatorBackTraceIndexHigh : u16,
    SpareWORD                 : u16,
 };
 PRTL_RESOURCE_DEBUG :: ^struct {
    Type                      : u16,
    CreatorBackTraceIndex     : u16,
    CriticalSection           : ^RTL_CRITICAL_SECTION,
    ProcessLocksList          : LIST_ENTRY,
    EntryCount                : u32,
    ContentionCount           : u32,
    Flags                     : u32,
    CreatorBackTraceIndexHigh : u16,
    SpareWORD                 : u16,
 };

 RTL_CRITICAL_SECTION :: struct {
    DebugInfo      : PRTL_CRITICAL_SECTION_DEBUG,
    LockCount      : LONG,
    RecursionCount : LONG,
    OwningThread   : HANDLE,
    LockSemaphore  : HANDLE,
    SpinCount      : ULONG_PTR,
 };
 PRTL_CRITICAL_SECTION :: ^struct {
    DebugInfo      : PRTL_CRITICAL_SECTION_DEBUG,
    LockCount      : LONG,
    RecursionCount : LONG,
    OwningThread   : HANDLE,
    LockSemaphore  : HANDLE,
    SpinCount      : ULONG_PTR,
 };

 RTL_SRWLOCK :: struct {
    Ptr : PVOID,
 };
 PRTL_SRWLOCK :: ^struct {
    Ptr : PVOID,
 };

 RTL_CONDITION_VARIABLE :: struct {
    Ptr : PVOID,
 };
 PRTL_CONDITION_VARIABLE :: ^struct {
    Ptr : PVOID,
 };

 PAPCFUNC :: proc(Parameter : ULONG_PTR);

 PVECTORED_EXCEPTION_HANDLER :: (proc(ExceptionInfo : ^EXCEPTION_POINTERS) -> LONG);

 HEAP_INFORMATION_CLASS :: enum {
    HeapCompatibilityInformation = 0,
    HeapEnableTerminationOnCorruption = 1,
    HeapOptimizeResources = 3,
 };

 HEAP_OPTIMIZE_RESOURCES_INFORMATION :: struct {
    Version : u32,
    Flags   : u32,
 };
 PHEAP_OPTIMIZE_RESOURCES_INFORMATION :: ^struct {
    Version : u32,
    Flags   : u32,
 };

 WAITORTIMERCALLBACKFUNC :: proc(PVOID, BOOLEAN);

 WORKERCALLBACKFUNC :: proc(PVOID);

 APC_CALLBACK_FUNCTION :: proc(u32, PVOID, PVOID);

 WAITORTIMERCALLBACK :: WAITORTIMERCALLBACKFUNC;

 PFLS_CALLBACK_FUNCTION :: proc(lpFlsData : PVOID);

 PSECURE_MEMORY_CACHE_CALLBACK :: (proc(Addr : PVOID, Range : SIZE_T) -> BOOLEAN);

 ACTIVATION_CONTEXT_INFO_CLASS :: enum {
    ActivationContextBasicInformation = 1,
    ActivationContextDetailedInformation = 2,
    AssemblyDetailedInformationInActivationContext = 3,
    FileInformationInAssemblyOfAssemblyInActivationContext = 4,
    RunlevelInformationInActivationContext = 5,
    CompatibilityInformationInActivationContext = 6,
    ActivationContextManifestResourceName = 7,
    MaxActivationContextInfoClass,
    AssemblyDetailedInformationInActivationContxt = 3,
    FileInformationInAssemblyOfAssemblyInActivationContxt = 4,
 };

 ACTIVATION_CONTEXT_QUERY_INDEX :: struct {
    ulAssemblyIndex       : u32,
    ulFileIndexInAssembly : u32,
 };
 PACTIVATION_CONTEXT_QUERY_INDEX :: ^struct {
    ulAssemblyIndex       : u32,
    ulFileIndexInAssembly : u32,
 };

 PCACTIVATION_CONTEXT_QUERY_INDEX :: ^ACTIVATION_CONTEXT_QUERY_INDEX;

 ASSEMBLY_FILE_DETAILED_INFORMATION :: struct {
    ulFlags          : u32,
    ulFilenameLength : u32,
    ulPathLength     : u32,
    lpFileName       : PCWSTR,
    lpFilePath       : PCWSTR,
 };
 PASSEMBLY_FILE_DETAILED_INFORMATION :: ^struct {
    ulFlags          : u32,
    ulFilenameLength : u32,
    ulPathLength     : u32,
    lpFileName       : PCWSTR,
    lpFilePath       : PCWSTR,
 };

 PCASSEMBLY_FILE_DETAILED_INFORMATION :: ^ASSEMBLY_FILE_DETAILED_INFORMATION;

 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: struct {
    ulFlags                           : u32,
    ulEncodedAssemblyIdentityLength   : u32,
    ulManifestPathType                : u32,
    ulManifestPathLength              : u32,
    liManifestLastWriteTime           : LARGE_INTEGER,
    ulPolicyPathType                  : u32,
    ulPolicyPathLength                : u32,
    liPolicyLastWriteTime             : LARGE_INTEGER,
    ulMetadataSatelliteRosterIndex    : u32,
    ulManifestVersionMajor            : u32,
    ulManifestVersionMinor            : u32,
    ulPolicyVersionMajor              : u32,
    ulPolicyVersionMinor              : u32,
    ulAssemblyDirectoryNameLength     : u32,
    lpAssemblyEncodedAssemblyIdentity : PCWSTR,
    lpAssemblyManifestPath            : PCWSTR,
    lpAssemblyPolicyPath              : PCWSTR,
    lpAssemblyDirectoryName           : PCWSTR,
    ulFileCount                       : u32,
 };
 PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: ^struct {
    ulFlags                           : u32,
    ulEncodedAssemblyIdentityLength   : u32,
    ulManifestPathType                : u32,
    ulManifestPathLength              : u32,
    liManifestLastWriteTime           : LARGE_INTEGER,
    ulPolicyPathType                  : u32,
    ulPolicyPathLength                : u32,
    liPolicyLastWriteTime             : LARGE_INTEGER,
    ulMetadataSatelliteRosterIndex    : u32,
    ulManifestVersionMajor            : u32,
    ulManifestVersionMinor            : u32,
    ulPolicyVersionMajor              : u32,
    ulPolicyVersionMinor              : u32,
    ulAssemblyDirectoryNameLength     : u32,
    lpAssemblyEncodedAssemblyIdentity : PCWSTR,
    lpAssemblyManifestPath            : PCWSTR,
    lpAssemblyPolicyPath              : PCWSTR,
    lpAssemblyDirectoryName           : PCWSTR,
    ulFileCount                       : u32,
 };

 PCACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION;

 ACTCTX_REQUESTED_RUN_LEVEL :: enum {
    ACTCTX_RUN_LEVEL_UNSPECIFIED = 0,
    ACTCTX_RUN_LEVEL_AS_INVOKER,
    ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE,
    ACTCTX_RUN_LEVEL_REQUIRE_ADMIN,
    ACTCTX_RUN_LEVEL_NUMBERS,
 };

 ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: struct {
    ulFlags  : u32,
    RunLevel : ACTCTX_REQUESTED_RUN_LEVEL,
    UiAccess : u32,
 };
 PACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: ^struct {
    ulFlags  : u32,
    RunLevel : ACTCTX_REQUESTED_RUN_LEVEL,
    UiAccess : u32,
 };

 PCACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: ^ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION;

 ACTCTX_COMPATIBILITY_ELEMENT_TYPE :: enum {
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN = 0,
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS,
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION,
    ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MAXVERSIONTESTED,
 };

 COMPATIBILITY_CONTEXT_ELEMENT :: struct {
    Id               : GUID,
    Type             : ACTCTX_COMPATIBILITY_ELEMENT_TYPE,
    MaxVersionTested : ULONGLONG,
 };
 PCOMPATIBILITY_CONTEXT_ELEMENT :: ^struct {
    Id               : GUID,
    Type             : ACTCTX_COMPATIBILITY_ELEMENT_TYPE,
    MaxVersionTested : ULONGLONG,
 };

 PCCOMPATIBILITY_CONTEXT_ELEMENT :: ^COMPATIBILITY_CONTEXT_ELEMENT;

 SUPPORTED_OS_INFO :: struct {
    MajorVersion : u16,
    MinorVersion : u16,
 };
 PSUPPORTED_OS_INFO :: ^struct {
    MajorVersion : u16,
    MinorVersion : u16,
 };

 MAXVERSIONTESTED_INFO :: struct {
    MaxVersionTested : ULONGLONG,
 };
 PMAXVERSIONTESTED_INFO :: ^struct {
    MaxVersionTested : ULONGLONG,
 };

 ACTIVATION_CONTEXT_DETAILED_INFORMATION :: struct {
    dwFlags                      : u32,
    ulFormatVersion              : u32,
    ulAssemblyCount              : u32,
    ulRootManifestPathType       : u32,
    ulRootManifestPathChars      : u32,
    ulRootConfigurationPathType  : u32,
    ulRootConfigurationPathChars : u32,
    ulAppDirPathType             : u32,
    ulAppDirPathChars            : u32,
    lpRootManifestPath           : PCWSTR,
    lpRootConfigurationPath      : PCWSTR,
    lpAppDirPath                 : PCWSTR,
 };
 PACTIVATION_CONTEXT_DETAILED_INFORMATION :: ^struct {
    dwFlags                      : u32,
    ulFormatVersion              : u32,
    ulAssemblyCount              : u32,
    ulRootManifestPathType       : u32,
    ulRootManifestPathChars      : u32,
    ulRootConfigurationPathType  : u32,
    ulRootConfigurationPathChars : u32,
    ulAppDirPathType             : u32,
    ulAppDirPathChars            : u32,
    lpRootManifestPath           : PCWSTR,
    lpRootConfigurationPath      : PCWSTR,
    lpAppDirPath                 : PCWSTR,
 };

 PCACTIVATION_CONTEXT_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_DETAILED_INFORMATION;

 HARDWARE_COUNTER_DATA :: struct {
    Type     : HARDWARE_COUNTER_TYPE,
    Reserved : u32,
    Value    : DWORD64,
 };
 PHARDWARE_COUNTER_DATA :: ^struct {
    Type     : HARDWARE_COUNTER_TYPE,
    Reserved : u32,
    Value    : DWORD64,
 };

 PERFORMANCE_DATA :: struct {
    Size               : u16,
    Version            : BYTE,
    HwCountersCount    : BYTE,
    ContextSwitchCount : u32,
    WaitReasonBitMap   : DWORD64,
    CycleTime          : DWORD64,
    RetryCount         : u32,
    Reserved           : u32,
    HwCounters         : [16]HARDWARE_COUNTER_DATA,
 };
 PPERFORMANCE_DATA :: ^struct {
    Size               : u16,
    Version            : BYTE,
    HwCountersCount    : BYTE,
    ContextSwitchCount : u32,
    WaitReasonBitMap   : DWORD64,
    CycleTime          : DWORD64,
    RetryCount         : u32,
    Reserved           : u32,
    HwCounters         : [16]HARDWARE_COUNTER_DATA,
 };

 EVENTLOGRECORD :: struct {
    Length              : u32,
    Reserved            : u32,
    RecordNumber        : u32,
    TimeGenerated       : u32,
    TimeWritten         : u32,
    EventID             : u32,
    EventType           : u16,
    NumStrings          : u16,
    EventCategory       : u16,
    ReservedFlags       : u16,
    ClosingRecordNumber : u32,
    StringOffset        : u32,
    UserSidLength       : u32,
    UserSidOffset       : u32,
    DataLength          : u32,
    DataOffset          : u32,
 };
 PEVENTLOGRECORD :: ^struct {
    Length              : u32,
    Reserved            : u32,
    RecordNumber        : u32,
    TimeGenerated       : u32,
    TimeWritten         : u32,
    EventID             : u32,
    EventType           : u16,
    NumStrings          : u16,
    EventCategory       : u16,
    ReservedFlags       : u16,
    ClosingRecordNumber : u32,
    StringOffset        : u32,
    UserSidLength       : u32,
    UserSidOffset       : u32,
    DataLength          : u32,
    DataOffset          : u32,
 };

 EVENTSFORLOGFILE :: struct {};

 PEVENTSFORLOGFILE :: ^EVENTSFORLOGFILE;

 PACKEDEVENTINFO :: struct {};

 PPACKEDEVENTINFO :: ^PACKEDEVENTINFO;

 SERVICE_NODE_TYPE :: enum {
    DriverType = 0x00000001,
    FileSystemType = 0x00000002,
    Win32ServiceOwnProcess = 0x00000010,
    Win32ServiceShareProcess = 0x00000020,
    AdapterType = 0x00000004,
    RecognizerType = 0x00000008,
 };

 SERVICE_LOAD_TYPE :: enum {
    BootLoad = 0x00000000,
    SystemLoad = 0x00000001,
    AutoLoad = 0x00000002,
    DemandLoad = 0x00000003,
    DisableLoad = 0x00000004,
 };

 SERVICE_ERROR_TYPE :: enum {
    IgnoreError = 0x00000000,
    NormalError = 0x00000001,
    SevereError = 0x00000002,
    CriticalError = 0x00000003,
 };

 TAPE_ERASE :: struct {
    Type      : u32,
    Immediate : BOOLEAN,
 };
 PTAPE_ERASE :: ^struct {
    Type      : u32,
    Immediate : BOOLEAN,
 };

 TAPE_PREPARE :: struct {
    Operation : u32,
    Immediate : BOOLEAN,
 };
 PTAPE_PREPARE :: ^struct {
    Operation : u32,
    Immediate : BOOLEAN,
 };

 TAPE_WRITE_MARKS :: struct {
    Type      : u32,
    Count     : u32,
    Immediate : BOOLEAN,
 };
 PTAPE_WRITE_MARKS :: ^struct {
    Type      : u32,
    Count     : u32,
    Immediate : BOOLEAN,
 };

 TAPE_GET_POSITION :: struct {
    Type      : u32,
    Partition : u32,
    Offset    : LARGE_INTEGER,
 };
 PTAPE_GET_POSITION :: ^struct {
    Type      : u32,
    Partition : u32,
    Offset    : LARGE_INTEGER,
 };

 TAPE_SET_POSITION :: struct {
    Method    : u32,
    Partition : u32,
    Offset    : LARGE_INTEGER,
    Immediate : BOOLEAN,
 };
 PTAPE_SET_POSITION :: ^struct {
    Method    : u32,
    Partition : u32,
    Offset    : LARGE_INTEGER,
    Immediate : BOOLEAN,
 };

 TAPE_GET_DRIVE_PARAMETERS :: struct {
    ECC                   : BOOLEAN,
    Compression           : BOOLEAN,
    DataPadding           : BOOLEAN,
    ReportSetmarks        : BOOLEAN,
    DefaultBlockSize      : u32,
    MaximumBlockSize      : u32,
    MinimumBlockSize      : u32,
    MaximumPartitionCount : u32,
    FeaturesLow           : u32,
    FeaturesHigh          : u32,
    EOTWarningZoneSize    : u32,
 };
 PTAPE_GET_DRIVE_PARAMETERS :: ^struct {
    ECC                   : BOOLEAN,
    Compression           : BOOLEAN,
    DataPadding           : BOOLEAN,
    ReportSetmarks        : BOOLEAN,
    DefaultBlockSize      : u32,
    MaximumBlockSize      : u32,
    MinimumBlockSize      : u32,
    MaximumPartitionCount : u32,
    FeaturesLow           : u32,
    FeaturesHigh          : u32,
    EOTWarningZoneSize    : u32,
 };

 TAPE_SET_DRIVE_PARAMETERS :: struct {
    ECC                : BOOLEAN,
    Compression        : BOOLEAN,
    DataPadding        : BOOLEAN,
    ReportSetmarks     : BOOLEAN,
    EOTWarningZoneSize : u32,
 };
 PTAPE_SET_DRIVE_PARAMETERS :: ^struct {
    ECC                : BOOLEAN,
    Compression        : BOOLEAN,
    DataPadding        : BOOLEAN,
    ReportSetmarks     : BOOLEAN,
    EOTWarningZoneSize : u32,
 };

 TAPE_GET_MEDIA_PARAMETERS :: struct {
    Capacity       : LARGE_INTEGER,
    Remaining      : LARGE_INTEGER,
    BlockSize      : u32,
    PartitionCount : u32,
    WriteProtected : BOOLEAN,
 };
 PTAPE_GET_MEDIA_PARAMETERS :: ^struct {
    Capacity       : LARGE_INTEGER,
    Remaining      : LARGE_INTEGER,
    BlockSize      : u32,
    PartitionCount : u32,
    WriteProtected : BOOLEAN,
 };

 TAPE_SET_MEDIA_PARAMETERS :: struct {
    BlockSize : u32,
 };
 PTAPE_SET_MEDIA_PARAMETERS :: ^struct {
    BlockSize : u32,
 };

 TAPE_CREATE_PARTITION :: struct {
    Method : u32,
    Count  : u32,
    Size   : u32,
 };
 PTAPE_CREATE_PARTITION :: ^struct {
    Method : u32,
    Count  : u32,
    Size   : u32,
 };

 TAPE_WMI_OPERATIONS :: struct {
    Method         : u32,
    DataBufferSize : u32,
    DataBuffer     : PVOID,
 };
 PTAPE_WMI_OPERATIONS :: ^struct {
    Method         : u32,
    DataBufferSize : u32,
    DataBuffer     : PVOID,
 };

 TAPE_DRIVE_PROBLEM_TYPE :: enum {
    TapeDriveProblemNone,
    TapeDriveReadWriteWarning,
    TapeDriveReadWriteError,
    TapeDriveReadWarning,
    TapeDriveWriteWarning,
    TapeDriveReadError,
    TapeDriveWriteError,
    TapeDriveHardwareError,
    TapeDriveUnsupportedMedia,
    TapeDriveScsiConnectionError,
    TapeDriveTimetoClean,
    TapeDriveCleanDriveNow,
    TapeDriveMediaLifeExpired,
    TapeDriveSnappedTape,
 };

 UOW :: GUID;
 PUOW :: ^GUID;

 CRM_PROTOCOL_ID :: GUID;
 PCRM_PROTOCOL_ID :: ^GUID;

 NOTIFICATION_MASK :: ULONG;

 TRANSACTION_NOTIFICATION :: struct {
    TransactionKey          : PVOID,
    TransactionNotification : ULONG,
    TmVirtualClock          : LARGE_INTEGER,
    ArgumentLength          : ULONG,
 };
 PTRANSACTION_NOTIFICATION :: ^struct {
    TransactionKey          : PVOID,
    TransactionNotification : ULONG,
    TmVirtualClock          : LARGE_INTEGER,
    ArgumentLength          : ULONG,
 };

 TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT :: struct {
    EnlistmentId : GUID,
    UOW          : UOW,
 };
 PTRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT :: ^struct {
    EnlistmentId : GUID,
    UOW          : UOW,
 };

 TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT :: struct {
    TmIdentity : GUID,
    Flags      : ULONG,
 };
 PTRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT :: ^struct {
    TmIdentity : GUID,
    Flags      : ULONG,
 };

 SAVEPOINT_ID :: ULONG;
 PSAVEPOINT_ID :: ^ULONG;

 TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT :: struct {
    SavepointId : SAVEPOINT_ID,
 };
 PTRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT :: ^struct {
    SavepointId : SAVEPOINT_ID,
 };

 TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT :: struct {
    PropagationCookie : ULONG,
    UOW               : GUID,
    TmIdentity        : GUID,
    BufferLength      : ULONG,
 };
 PTRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT :: ^struct {
    PropagationCookie : ULONG,
    UOW               : GUID,
    TmIdentity        : GUID,
    BufferLength      : ULONG,
 };

 TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT :: struct {
    MarshalCookie : ULONG,
    UOW           : GUID,
 };
 PTRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT :: ^struct {
    MarshalCookie : ULONG,
    UOW           : GUID,
 };

 TRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT :: TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT;
 PTRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT :: ^TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT;

 KCRM_MARSHAL_HEADER :: struct {
    VersionMajor : ULONG,
    VersionMinor : ULONG,
    NumProtocols : ULONG,
    Unused       : ULONG,
 };
 PKCRM_MARSHAL_HEADER :: ^struct {
    VersionMajor : ULONG,
    VersionMinor : ULONG,
    NumProtocols : ULONG,
    Unused       : ULONG,
 };
 PRKCRM_MARSHAL_HEADER :: ^struct {
    VersionMajor : ULONG,
    VersionMinor : ULONG,
    NumProtocols : ULONG,
    Unused       : ULONG,
 };

 KCRM_TRANSACTION_BLOB :: struct {
    UOW            : UOW,
    TmIdentity     : GUID,
    IsolationLevel : ULONG,
    IsolationFlags : ULONG,
    Timeout        : ULONG,
    Description    : [64]WCHAR,
 };
 PKCRM_TRANSACTION_BLOB :: ^struct {
    UOW            : UOW,
    TmIdentity     : GUID,
    IsolationLevel : ULONG,
    IsolationFlags : ULONG,
    Timeout        : ULONG,
    Description    : [64]WCHAR,
 };
 PRKCRM_TRANSACTION_BLOB :: ^struct {
    UOW            : UOW,
    TmIdentity     : GUID,
    IsolationLevel : ULONG,
    IsolationFlags : ULONG,
    Timeout        : ULONG,
    Description    : [64]WCHAR,
 };

 KCRM_PROTOCOL_BLOB :: struct {
    ProtocolId              : CRM_PROTOCOL_ID,
    StaticInfoLength        : ULONG,
    TransactionIdInfoLength : ULONG,
    Unused1                 : ULONG,
    Unused2                 : ULONG,
 };
 PKCRM_PROTOCOL_BLOB :: ^struct {
    ProtocolId              : CRM_PROTOCOL_ID,
    StaticInfoLength        : ULONG,
    TransactionIdInfoLength : ULONG,
    Unused1                 : ULONG,
    Unused2                 : ULONG,
 };
 PRKCRM_PROTOCOL_BLOB :: ^struct {
    ProtocolId              : CRM_PROTOCOL_ID,
    StaticInfoLength        : ULONG,
    TransactionIdInfoLength : ULONG,
    Unused1                 : ULONG,
    Unused2                 : ULONG,
 };

 TRANSACTION_OUTCOME :: enum {
    TransactionOutcomeUndetermined = 1,
    TransactionOutcomeCommitted,
    TransactionOutcomeAborted,
 };

 TRANSACTION_STATE :: enum {
    TransactionStateNormal = 1,
    TransactionStateIndoubt,
    TransactionStateCommittedNotify,
 };

 TRANSACTION_BASIC_INFORMATION :: struct {
    TransactionId : GUID,
    State         : u32,
    Outcome       : u32,
 };
 PTRANSACTION_BASIC_INFORMATION :: ^struct {
    TransactionId : GUID,
    State         : u32,
    Outcome       : u32,
 };

 TRANSACTIONMANAGER_BASIC_INFORMATION :: struct {
    TmIdentity   : GUID,
    VirtualClock : LARGE_INTEGER,
 };
 PTRANSACTIONMANAGER_BASIC_INFORMATION :: ^struct {
    TmIdentity   : GUID,
    VirtualClock : LARGE_INTEGER,
 };

 TRANSACTIONMANAGER_LOG_INFORMATION :: struct {
    LogIdentity : GUID,
 };
 PTRANSACTIONMANAGER_LOG_INFORMATION :: ^struct {
    LogIdentity : GUID,
 };

 TRANSACTIONMANAGER_LOGPATH_INFORMATION :: struct {
    LogPathLength : u32,
    LogPath       : [1]WCHAR,
 };
 PTRANSACTIONMANAGER_LOGPATH_INFORMATION :: ^struct {
    LogPathLength : u32,
    LogPath       : [1]WCHAR,
 };

 TRANSACTIONMANAGER_RECOVERY_INFORMATION :: struct {
    LastRecoveredLsn : ULONGLONG,
 };
 PTRANSACTIONMANAGER_RECOVERY_INFORMATION :: ^struct {
    LastRecoveredLsn : ULONGLONG,
 };

 TRANSACTIONMANAGER_OLDEST_INFORMATION :: struct {
    OldestTransactionGuid : GUID,
 };
 PTRANSACTIONMANAGER_OLDEST_INFORMATION :: ^struct {
    OldestTransactionGuid : GUID,
 };

 TRANSACTION_PROPERTIES_INFORMATION :: struct {
    IsolationLevel    : u32,
    IsolationFlags    : u32,
    Timeout           : LARGE_INTEGER,
    Outcome           : u32,
    DescriptionLength : u32,
    Description       : [1]WCHAR,
 };
 PTRANSACTION_PROPERTIES_INFORMATION :: ^struct {
    IsolationLevel    : u32,
    IsolationFlags    : u32,
    Timeout           : LARGE_INTEGER,
    Outcome           : u32,
    DescriptionLength : u32,
    Description       : [1]WCHAR,
 };

 TRANSACTION_BIND_INFORMATION :: struct {
    TmHandle : HANDLE,
 };
 PTRANSACTION_BIND_INFORMATION :: ^struct {
    TmHandle : HANDLE,
 };

 TRANSACTION_ENLISTMENT_PAIR :: struct {
    EnlistmentId      : GUID,
    ResourceManagerId : GUID,
 };
 PTRANSACTION_ENLISTMENT_PAIR :: ^struct {
    EnlistmentId      : GUID,
    ResourceManagerId : GUID,
 };

 TRANSACTION_ENLISTMENTS_INFORMATION :: struct {
    NumberOfEnlistments : u32,
    EnlistmentPair      : [1]TRANSACTION_ENLISTMENT_PAIR,
 };
 PTRANSACTION_ENLISTMENTS_INFORMATION :: ^struct {
    NumberOfEnlistments : u32,
    EnlistmentPair      : [1]TRANSACTION_ENLISTMENT_PAIR,
 };

 TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION :: struct {
    SuperiorEnlistmentPair : TRANSACTION_ENLISTMENT_PAIR,
 };
 PTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION :: ^struct {
    SuperiorEnlistmentPair : TRANSACTION_ENLISTMENT_PAIR,
 };

 RESOURCEMANAGER_BASIC_INFORMATION :: struct {
    ResourceManagerId : GUID,
    DescriptionLength : u32,
    Description       : [1]WCHAR,
 };
 PRESOURCEMANAGER_BASIC_INFORMATION :: ^struct {
    ResourceManagerId : GUID,
    DescriptionLength : u32,
    Description       : [1]WCHAR,
 };

 RESOURCEMANAGER_COMPLETION_INFORMATION :: struct {
    IoCompletionPortHandle : HANDLE,
    CompletionKey          : ULONG_PTR,
 };
 PRESOURCEMANAGER_COMPLETION_INFORMATION :: ^struct {
    IoCompletionPortHandle : HANDLE,
    CompletionKey          : ULONG_PTR,
 };

 TRANSACTION_INFORMATION_CLASS :: enum {
    TransactionBasicInformation,
    TransactionPropertiesInformation,
    TransactionEnlistmentInformation,
    TransactionSuperiorEnlistmentInformation,
    TransactionBindInformation,
    TransactionDTCPrivateInformation,
 };

 TRANSACTIONMANAGER_INFORMATION_CLASS :: enum {
    TransactionManagerBasicInformation,
    TransactionManagerLogInformation,
    TransactionManagerLogPathInformation,
    TransactionManagerRecoveryInformation = 4,
    TransactionManagerOnlineProbeInformation = 3,
    TransactionManagerOldestTransactionInformation = 5,
 };

 RESOURCEMANAGER_INFORMATION_CLASS :: enum {
    ResourceManagerBasicInformation,
    ResourceManagerCompletionInformation,
 };

 ENLISTMENT_BASIC_INFORMATION :: struct {
    EnlistmentId      : GUID,
    TransactionId     : GUID,
    ResourceManagerId : GUID,
 };
 PENLISTMENT_BASIC_INFORMATION :: ^struct {
    EnlistmentId      : GUID,
    TransactionId     : GUID,
    ResourceManagerId : GUID,
 };

 ENLISTMENT_CRM_INFORMATION :: struct {
    CrmTransactionManagerId : GUID,
    CrmResourceManagerId    : GUID,
    CrmEnlistmentId         : GUID,
 };
 PENLISTMENT_CRM_INFORMATION :: ^struct {
    CrmTransactionManagerId : GUID,
    CrmResourceManagerId    : GUID,
    CrmEnlistmentId         : GUID,
 };

 ENLISTMENT_INFORMATION_CLASS :: enum {
    EnlistmentBasicInformation,
    EnlistmentRecoveryInformation,
    EnlistmentCrmInformation,
 };

 TRANSACTION_LIST_ENTRY :: struct {
    UOW : UOW,
 };
 PTRANSACTION_LIST_ENTRY :: ^struct {
    UOW : UOW,
 };

 TRANSACTION_LIST_INFORMATION :: struct {
    NumberOfTransactions   : u32,
    TransactionInformation : [1]TRANSACTION_LIST_ENTRY,
 };
 PTRANSACTION_LIST_INFORMATION :: ^struct {
    NumberOfTransactions   : u32,
    TransactionInformation : [1]TRANSACTION_LIST_ENTRY,
 };

 KTMOBJECT_TYPE :: enum {
    KTMOBJECT_TRANSACTION,
    KTMOBJECT_TRANSACTION_MANAGER,
    KTMOBJECT_RESOURCE_MANAGER,
    KTMOBJECT_ENLISTMENT,
    KTMOBJECT_INVALID,
 };
 PKTMOBJECT_TYPE :: ^enum {
    KTMOBJECT_TRANSACTION,
    KTMOBJECT_TRANSACTION_MANAGER,
    KTMOBJECT_RESOURCE_MANAGER,
    KTMOBJECT_ENLISTMENT,
    KTMOBJECT_INVALID,
 };

 KTMOBJECT_CURSOR :: struct {
    LastQuery     : GUID,
    ObjectIdCount : u32,
    ObjectIds     : [1]GUID,
 };
 PKTMOBJECT_CURSOR :: ^struct {
    LastQuery     : GUID,
    ObjectIdCount : u32,
    ObjectIds     : [1]GUID,
 };

 TP_VERSION :: u32;
 PTP_VERSION :: ^u32;

 TP_CALLBACK_INSTANCE :: struct {};

 PTP_CALLBACK_INSTANCE :: ^TP_CALLBACK_INSTANCE;

 PTP_SIMPLE_CALLBACK :: proc(Instance : PTP_CALLBACK_INSTANCE, Context : PVOID);

 TP_POOL :: struct {};

 PTP_POOL :: ^TP_POOL;

 TP_CALLBACK_PRIORITY :: enum {
    TP_CALLBACK_PRIORITY_HIGH,
    TP_CALLBACK_PRIORITY_NORMAL,
    TP_CALLBACK_PRIORITY_LOW,
    TP_CALLBACK_PRIORITY_INVALID,
    TP_CALLBACK_PRIORITY_COUNT =     TP_CALLBACK_PRIORITY_INVALID,
 };

 TP_POOL_STACK_INFORMATION :: struct {
    StackReserve : SIZE_T,
    StackCommit  : SIZE_T,
 };
 PTP_POOL_STACK_INFORMATION :: ^struct {
    StackReserve : SIZE_T,
    StackCommit  : SIZE_T,
 };

 TP_CLEANUP_GROUP :: struct {};

 PTP_CLEANUP_GROUP :: ^TP_CLEANUP_GROUP;

 PTP_CLEANUP_GROUP_CANCEL_CALLBACK :: proc(ObjectContext : PVOID, CleanupContext : PVOID);

 TP_CALLBACK_ENVIRON_V3 :: struct {
    Version                    : TP_VERSION,
    Pool                       : PTP_POOL,
    CleanupGroup               : PTP_CLEANUP_GROUP,
    CleanupGroupCancelCallback : PTP_CLEANUP_GROUP_CANCEL_CALLBACK,
    RaceDll                    : PVOID,
    ActivationContext          : ^_ACTIVATION_CONTEXT,
    FinalizationCallback       : PTP_SIMPLE_CALLBACK,
    u : struct #raw_union {
        Flags : u32,
        s : struct {
            LongFunction : ,
            Persistent   : ,
            Private      : ,
        },
    },
    CallbackPriority           : TP_CALLBACK_PRIORITY,
    Size                       : u32,
 };

 TP_CALLBACK_ENVIRON :: TP_CALLBACK_ENVIRON_V3;
 PTP_CALLBACK_ENVIRON :: ^TP_CALLBACK_ENVIRON_V3;

 TP_WORK :: struct {};

 PTP_WORK :: ^TP_WORK;

 PTP_WORK_CALLBACK :: proc(Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Work : PTP_WORK);

 TP_TIMER :: struct {};

 PTP_TIMER :: ^TP_TIMER;

 PTP_TIMER_CALLBACK :: proc(Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Timer : PTP_TIMER);

 TP_WAIT_RESULT :: u32;

 TP_WAIT :: struct {};

 PTP_WAIT :: ^TP_WAIT;

 PTP_WAIT_CALLBACK :: proc(Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Wait : PTP_WAIT, WaitResult : TP_WAIT_RESULT);

 TP_IO :: struct {};

 PTP_IO :: ^TP_IO;

 WPARAM :: UINT_PTR;

 LPARAM :: LONG_PTR;

 LRESULT :: LONG_PTR;

 SPHANDLE :: ^HANDLE;

 LPHANDLE :: ^HANDLE;

 HGLOBAL :: HANDLE;

 HLOCAL :: HANDLE;

 GLOBALHANDLE :: HANDLE;

 LOCALHANDLE :: HANDLE;

 FARPROC :: (proc() -> i32);

 NEARPROC :: (proc() -> i32);

 PROC :: (proc() -> i32);

 ATOM :: u16;

 HKEY__ :: struct {
    unused : i32,
 };

 HKEY :: ^HKEY__;

 PHKEY :: ^HKEY;

 HMETAFILE__ :: struct {
    unused : i32,
 };

 HMETAFILE :: ^HMETAFILE__;

 HINSTANCE__ :: struct {
    unused : i32,
 };

 HINSTANCE :: ^HINSTANCE__;

 HMODULE :: HINSTANCE;

 HRGN__ :: struct {
    unused : i32,
 };

 HRGN :: ^HRGN__;

 HRSRC__ :: struct {
    unused : i32,
 };

 HRSRC :: ^HRSRC__;

 HSPRITE__ :: struct {
    unused : i32,
 };

 HSPRITE :: ^HSPRITE__;

 HLSURF__ :: struct {
    unused : i32,
 };

 HLSURF :: ^HLSURF__;

 HSTR__ :: struct {
    unused : i32,
 };

 HSTR :: ^HSTR__;

 HTASK__ :: struct {
    unused : i32,
 };

 HTASK :: ^HTASK__;

 HWINSTA__ :: struct {
    unused : i32,
 };

 HWINSTA :: ^HWINSTA__;

 HKL__ :: struct {
    unused : i32,
 };

 HKL :: ^HKL__;

 HFILE :: i32;

 FILETIME :: struct {
    dwLowDateTime  : u32,
    dwHighDateTime : u32,
 };
 PFILETIME :: ^struct {
    dwLowDateTime  : u32,
    dwHighDateTime : u32,
 };
 LPFILETIME :: ^struct {
    dwLowDateTime  : u32,
    dwHighDateTime : u32,
 };

 HWND__ :: struct {
    unused : i32,
 };

 HWND :: ^HWND__;

 HHOOK__ :: struct {
    unused : i32,
 };

 HHOOK :: ^HHOOK__;

 HGDIOBJ :: rawptr;

 HACCEL__ :: struct {
    unused : i32,
 };

 HACCEL :: ^HACCEL__;

 HBITMAP__ :: struct {
    unused : i32,
 };

 HBITMAP :: ^HBITMAP__;

 HBRUSH__ :: struct {
    unused : i32,
 };

 HBRUSH :: ^HBRUSH__;

 HCOLORSPACE__ :: struct {
    unused : i32,
 };

 HCOLORSPACE :: ^HCOLORSPACE__;

 HDC__ :: struct {
    unused : i32,
 };

 HDC :: ^HDC__;

 HGLRC__ :: struct {
    unused : i32,
 };

 HGLRC :: ^HGLRC__;

 HDESK__ :: struct {
    unused : i32,
 };

 HDESK :: ^HDESK__;

 HENHMETAFILE__ :: struct {
    unused : i32,
 };

 HENHMETAFILE :: ^HENHMETAFILE__;

 HFONT__ :: struct {
    unused : i32,
 };

 HFONT :: ^HFONT__;

 HICON__ :: struct {
    unused : i32,
 };

 HICON :: ^HICON__;

 HMENU__ :: struct {
    unused : i32,
 };

 HMENU :: ^HMENU__;

 HPALETTE__ :: struct {
    unused : i32,
 };

 HPALETTE :: ^HPALETTE__;

 HPEN__ :: struct {
    unused : i32,
 };

 HPEN :: ^HPEN__;

 HWINEVENTHOOK__ :: struct {
    unused : i32,
 };

 HWINEVENTHOOK :: ^HWINEVENTHOOK__;

 HMONITOR__ :: struct {
    unused : i32,
 };

 HMONITOR :: ^HMONITOR__;

 HUMPD__ :: struct {
    unused : i32,
 };

 HUMPD :: ^HUMPD__;

 HCURSOR :: HICON;

 COLORREF :: u32;

 LPCOLORREF :: ^u32;

 RECT :: struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
 };
 PRECT :: ^struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
 };
 NPRECT :: ^struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
 };
 LPRECT :: ^struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
 };

 LPCRECT :: ^RECT;

 RECTL :: struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
 };
 PRECTL :: ^struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
 };
 LPRECTL :: ^struct {
    left   : LONG,
    top    : LONG,
    right  : LONG,
    bottom : LONG,
 };

 LPCRECTL :: ^RECTL;

 POINT :: struct {
    x : LONG,
    y : LONG,
 };
 PPOINT :: ^struct {
    x : LONG,
    y : LONG,
 };
 NPPOINT :: ^struct {
    x : LONG,
    y : LONG,
 };
 LPPOINT :: ^struct {
    x : LONG,
    y : LONG,
 };

 POINTL :: struct {
    x : LONG,
    y : LONG,
 };
 PPOINTL :: ^struct {
    x : LONG,
    y : LONG,
 };

 SIZE :: struct {
    cx : LONG,
    cy : LONG,
 };
 PSIZE :: ^struct {
    cx : LONG,
    cy : LONG,
 };
 LPSIZE :: ^struct {
    cx : LONG,
    cy : LONG,
 };

 SIZEL :: SIZE;

 PSIZEL :: ^SIZE;
 LPSIZEL :: ^SIZE;

 POINTS :: struct {
    x : SHORT,
    y : SHORT,
 };
 PPOINTS :: ^struct {
    x : SHORT,
    y : SHORT,
 };
 LPPOINTS :: ^struct {
    x : SHORT,
    y : SHORT,
 };

 DPI_AWARENESS_CONTEXT__ :: struct {
    unused : i32,
 };

 DPI_AWARENESS_CONTEXT :: ^DPI_AWARENESS_CONTEXT__;

 DPI_AWARENESS :: enum {
    DPI_AWARENESS_INVALID = -1,
    DPI_AWARENESS_UNAWARE = 0,
    DPI_AWARENESS_SYSTEM_AWARE = 1,
    DPI_AWARENESS_PER_MONITOR_AWARE = 2,
 };

 DPI_HOSTING_BEHAVIOR :: enum {
    DPI_HOSTING_BEHAVIOR_INVALID = -1,
    DPI_HOSTING_BEHAVIOR_DEFAULT = 0,
    DPI_HOSTING_BEHAVIOR_MIXED = 1,
 };

 SECURITY_ATTRIBUTES :: struct {
    nLength              : u32,
    lpSecurityDescriptor : LPVOID,
    bInheritHandle       : BOOL,
 };
 PSECURITY_ATTRIBUTES :: ^struct {
    nLength              : u32,
    lpSecurityDescriptor : LPVOID,
    bInheritHandle       : BOOL,
 };
 LPSECURITY_ATTRIBUTES :: ^struct {
    nLength              : u32,
    lpSecurityDescriptor : LPVOID,
    bInheritHandle       : BOOL,
 };

 OVERLAPPED :: struct {
    Internal     : ULONG_PTR,
    InternalHigh : ULONG_PTR,
    u : struct #raw_union {
        s : struct {
            Offset     : u32,
            OffsetHigh : u32,
        },
        Pointer : PVOID,
    },
    hEvent       : HANDLE,
 };
 LPOVERLAPPED :: ^struct {
    Internal     : ULONG_PTR,
    InternalHigh : ULONG_PTR,
    u : struct #raw_union {
        s : struct {
            Offset     : u32,
            OffsetHigh : u32,
        },
        Pointer : PVOID,
    },
    hEvent       : HANDLE,
 };

 OVERLAPPED_ENTRY :: struct {
    lpCompletionKey            : ULONG_PTR,
    lpOverlapped               : LPOVERLAPPED,
    Internal                   : ULONG_PTR,
    dwNumberOfBytesTransferred : u32,
 };
 LPOVERLAPPED_ENTRY :: ^struct {
    lpCompletionKey            : ULONG_PTR,
    lpOverlapped               : LPOVERLAPPED,
    Internal                   : ULONG_PTR,
    dwNumberOfBytesTransferred : u32,
 };

 SYSTEMTIME :: struct {
    wYear         : u16,
    wMonth        : u16,
    wDayOfWeek    : u16,
    wDay          : u16,
    wHour         : u16,
    wMinute       : u16,
    wSecond       : u16,
    wMilliseconds : u16,
 };
 PSYSTEMTIME :: ^struct {
    wYear         : u16,
    wMonth        : u16,
    wDayOfWeek    : u16,
    wDay          : u16,
    wHour         : u16,
    wMinute       : u16,
    wSecond       : u16,
    wMilliseconds : u16,
 };
 LPSYSTEMTIME :: ^struct {
    wYear         : u16,
    wMonth        : u16,
    wDayOfWeek    : u16,
    wDay          : u16,
    wHour         : u16,
    wMinute       : u16,
    wSecond       : u16,
    wMilliseconds : u16,
 };

 WIN32_FIND_DATAA :: struct {
    dwFileAttributes   : u32,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : u32,
    nFileSizeLow       : u32,
    dwReserved0        : u32,
    dwReserved1        : u32,
    cFileName          : [260]CHAR,
    cAlternateFileName : [14]CHAR,
 };
 PWIN32_FIND_DATAA :: ^struct {
    dwFileAttributes   : u32,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : u32,
    nFileSizeLow       : u32,
    dwReserved0        : u32,
    dwReserved1        : u32,
    cFileName          : [260]CHAR,
    cAlternateFileName : [14]CHAR,
 };
 LPWIN32_FIND_DATAA :: ^struct {
    dwFileAttributes   : u32,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : u32,
    nFileSizeLow       : u32,
    dwReserved0        : u32,
    dwReserved1        : u32,
    cFileName          : [260]CHAR,
    cAlternateFileName : [14]CHAR,
 };

 WIN32_FIND_DATAW :: struct {
    dwFileAttributes   : u32,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : u32,
    nFileSizeLow       : u32,
    dwReserved0        : u32,
    dwReserved1        : u32,
    cFileName          : [260]WCHAR,
    cAlternateFileName : [14]WCHAR,
 };
 PWIN32_FIND_DATAW :: ^struct {
    dwFileAttributes   : u32,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : u32,
    nFileSizeLow       : u32,
    dwReserved0        : u32,
    dwReserved1        : u32,
    cFileName          : [260]WCHAR,
    cAlternateFileName : [14]WCHAR,
 };
 LPWIN32_FIND_DATAW :: ^struct {
    dwFileAttributes   : u32,
    ftCreationTime     : FILETIME,
    ftLastAccessTime   : FILETIME,
    ftLastWriteTime    : FILETIME,
    nFileSizeHigh      : u32,
    nFileSizeLow       : u32,
    dwReserved0        : u32,
    dwReserved1        : u32,
    cFileName          : [260]WCHAR,
    cAlternateFileName : [14]WCHAR,
 };

 WIN32_FIND_DATA :: WIN32_FIND_DATAA;

 PWIN32_FIND_DATA :: PWIN32_FIND_DATAA;

 LPWIN32_FIND_DATA :: LPWIN32_FIND_DATAA;

 FINDEX_INFO_LEVELS :: enum {
    FindExInfoStandard,
    FindExInfoBasic,
    FindExInfoMaxInfoLevel,
 };

 FINDEX_SEARCH_OPS :: enum {
    FindExSearchNameMatch,
    FindExSearchLimitToDirectories,
    FindExSearchLimitToDevices,
    FindExSearchMaxSearchOp,
 };

 READ_DIRECTORY_NOTIFY_INFORMATION_CLASS :: enum {
    ReadDirectoryNotifyInformation = 1,
    ReadDirectoryNotifyExtendedInformation,
 };
 PREAD_DIRECTORY_NOTIFY_INFORMATION_CLASS :: ^enum {
    ReadDirectoryNotifyInformation = 1,
    ReadDirectoryNotifyExtendedInformation,
 };

 GET_FILEEX_INFO_LEVELS :: enum {
    GetFileExInfoStandard,
    GetFileExMaxInfoLevel,
 };

 FILE_INFO_BY_HANDLE_CLASS :: enum {
    FileBasicInfo,
    FileStandardInfo,
    FileNameInfo,
    FileRenameInfo,
    FileDispositionInfo,
    FileAllocationInfo,
    FileEndOfFileInfo,
    FileStreamInfo,
    FileCompressionInfo,
    FileAttributeTagInfo,
    FileIdBothDirectoryInfo,
    FileIdBothDirectoryRestartInfo,
    FileIoPriorityHintInfo,
    FileRemoteProtocolInfo,
    FileFullDirectoryInfo,
    FileFullDirectoryRestartInfo,
    FileStorageInfo,
    FileAlignmentInfo,
    FileIdInfo,
    FileIdExtdDirectoryInfo,
    FileIdExtdDirectoryRestartInfo,
    FileDispositionInfoEx,
    FileRenameInfoEx,
    FileCaseSensitiveInfo,
    FileNormalizedNameInfo,
    MaximumFileInfoByHandleClass,
 };
 PFILE_INFO_BY_HANDLE_CLASS :: ^enum {
    FileBasicInfo,
    FileStandardInfo,
    FileNameInfo,
    FileRenameInfo,
    FileDispositionInfo,
    FileAllocationInfo,
    FileEndOfFileInfo,
    FileStreamInfo,
    FileCompressionInfo,
    FileAttributeTagInfo,
    FileIdBothDirectoryInfo,
    FileIdBothDirectoryRestartInfo,
    FileIoPriorityHintInfo,
    FileRemoteProtocolInfo,
    FileFullDirectoryInfo,
    FileFullDirectoryRestartInfo,
    FileStorageInfo,
    FileAlignmentInfo,
    FileIdInfo,
    FileIdExtdDirectoryInfo,
    FileIdExtdDirectoryRestartInfo,
    FileDispositionInfoEx,
    FileRenameInfoEx,
    FileCaseSensitiveInfo,
    FileNormalizedNameInfo,
    MaximumFileInfoByHandleClass,
 };

 CRITICAL_SECTION :: RTL_CRITICAL_SECTION;

 PCRITICAL_SECTION :: PRTL_CRITICAL_SECTION;

 LPCRITICAL_SECTION :: PRTL_CRITICAL_SECTION;

 CRITICAL_SECTION_DEBUG :: RTL_CRITICAL_SECTION_DEBUG;

 PCRITICAL_SECTION_DEBUG :: PRTL_CRITICAL_SECTION_DEBUG;

 LPCRITICAL_SECTION_DEBUG :: PRTL_CRITICAL_SECTION_DEBUG;

 LPOVERLAPPED_COMPLETION_ROUTINE :: proc(dwErrorCode : u32, dwNumberOfBytesTransfered : u32, lpOverlapped : LPOVERLAPPED);

 PROCESS_HEAP_ENTRY :: struct {
    lpData       : PVOID,
    cbData       : u32,
    cbOverhead   : BYTE,
    iRegionIndex : BYTE,
    wFlags       : u16,
    u : struct #raw_union {
        Block : struct {
            hMem       : HANDLE,
            dwReserved : [3]u32,
        },
        Region : struct {
            dwCommittedSize   : u32,
            dwUnCommittedSize : u32,
            lpFirstBlock      : LPVOID,
            lpLastBlock       : LPVOID,
        },
    },
 };
 LPPROCESS_HEAP_ENTRY :: ^struct {
    lpData       : PVOID,
    cbData       : u32,
    cbOverhead   : BYTE,
    iRegionIndex : BYTE,
    wFlags       : u16,
    u : struct #raw_union {
        Block : struct {
            hMem       : HANDLE,
            dwReserved : [3]u32,
        },
        Region : struct {
            dwCommittedSize   : u32,
            dwUnCommittedSize : u32,
            lpFirstBlock      : LPVOID,
            lpLastBlock       : LPVOID,
        },
    },
 };
 PPROCESS_HEAP_ENTRY :: ^struct {
    lpData       : PVOID,
    cbData       : u32,
    cbOverhead   : BYTE,
    iRegionIndex : BYTE,
    wFlags       : u16,
    u : struct #raw_union {
        Block : struct {
            hMem       : HANDLE,
            dwReserved : [3]u32,
        },
        Region : struct {
            dwCommittedSize   : u32,
            dwUnCommittedSize : u32,
            lpFirstBlock      : LPVOID,
            lpLastBlock       : LPVOID,
        },
    },
 };

 REASON_CONTEXT :: struct {
    Version : ULONG,
    Flags   : u32,
    Reason : struct #raw_union {
        Detailed : struct {
            LocalizedReasonModule : HMODULE,
            LocalizedReasonId     : ULONG,
            ReasonStringCount     : ULONG,
            ReasonStrings         : ^LPWSTR,
        },
        SimpleReasonString : LPWSTR,
    },
 };
 PREASON_CONTEXT :: ^struct {
    Version : ULONG,
    Flags   : u32,
    Reason : struct #raw_union {
        Detailed : struct {
            LocalizedReasonModule : HMODULE,
            LocalizedReasonId     : ULONG,
            ReasonStringCount     : ULONG,
            ReasonStrings         : ^LPWSTR,
        },
        SimpleReasonString : LPWSTR,
    },
 };

 PTHREAD_START_ROUTINE :: (proc(lpThreadParameter : LPVOID) -> u32);

 LPTHREAD_START_ROUTINE :: PTHREAD_START_ROUTINE;

 PENCLAVE_ROUTINE :: (proc(lpThreadParameter : LPVOID) -> LPVOID);

 LPENCLAVE_ROUTINE :: PENCLAVE_ROUTINE;

 EXCEPTION_DEBUG_INFO :: struct {
    ExceptionRecord : EXCEPTION_RECORD,
    dwFirstChance   : u32,
 };
 LPEXCEPTION_DEBUG_INFO :: ^struct {
    ExceptionRecord : EXCEPTION_RECORD,
    dwFirstChance   : u32,
 };

 CREATE_THREAD_DEBUG_INFO :: struct {
    hThread           : HANDLE,
    lpThreadLocalBase : LPVOID,
    lpStartAddress    : LPTHREAD_START_ROUTINE,
 };
 LPCREATE_THREAD_DEBUG_INFO :: ^struct {
    hThread           : HANDLE,
    lpThreadLocalBase : LPVOID,
    lpStartAddress    : LPTHREAD_START_ROUTINE,
 };

 CREATE_PROCESS_DEBUG_INFO :: struct {
    hFile                 : HANDLE,
    hProcess              : HANDLE,
    hThread               : HANDLE,
    lpBaseOfImage         : LPVOID,
    dwDebugInfoFileOffset : u32,
    nDebugInfoSize        : u32,
    lpThreadLocalBase     : LPVOID,
    lpStartAddress        : LPTHREAD_START_ROUTINE,
    lpImageName           : LPVOID,
    fUnicode              : u16,
 };
 LPCREATE_PROCESS_DEBUG_INFO :: ^struct {
    hFile                 : HANDLE,
    hProcess              : HANDLE,
    hThread               : HANDLE,
    lpBaseOfImage         : LPVOID,
    dwDebugInfoFileOffset : u32,
    nDebugInfoSize        : u32,
    lpThreadLocalBase     : LPVOID,
    lpStartAddress        : LPTHREAD_START_ROUTINE,
    lpImageName           : LPVOID,
    fUnicode              : u16,
 };

 EXIT_THREAD_DEBUG_INFO :: struct {
    dwExitCode : u32,
 };
 LPEXIT_THREAD_DEBUG_INFO :: ^struct {
    dwExitCode : u32,
 };

 EXIT_PROCESS_DEBUG_INFO :: struct {
    dwExitCode : u32,
 };
 LPEXIT_PROCESS_DEBUG_INFO :: ^struct {
    dwExitCode : u32,
 };

 LOAD_DLL_DEBUG_INFO :: struct {
    hFile                 : HANDLE,
    lpBaseOfDll           : LPVOID,
    dwDebugInfoFileOffset : u32,
    nDebugInfoSize        : u32,
    lpImageName           : LPVOID,
    fUnicode              : u16,
 };
 LPLOAD_DLL_DEBUG_INFO :: ^struct {
    hFile                 : HANDLE,
    lpBaseOfDll           : LPVOID,
    dwDebugInfoFileOffset : u32,
    nDebugInfoSize        : u32,
    lpImageName           : LPVOID,
    fUnicode              : u16,
 };

 UNLOAD_DLL_DEBUG_INFO :: struct {
    lpBaseOfDll : LPVOID,
 };
 LPUNLOAD_DLL_DEBUG_INFO :: ^struct {
    lpBaseOfDll : LPVOID,
 };

 OUTPUT_DEBUG_STRING_INFO :: struct {
    lpDebugStringData  : LPSTR,
    fUnicode           : u16,
    nDebugStringLength : u16,
 };
 LPOUTPUT_DEBUG_STRING_INFO :: ^struct {
    lpDebugStringData  : LPSTR,
    fUnicode           : u16,
    nDebugStringLength : u16,
 };

 RIP_INFO :: struct {
    dwError : u32,
    dwType  : u32,
 };
 LPRIP_INFO :: ^struct {
    dwError : u32,
    dwType  : u32,
 };

 DEBUG_EVENT :: struct {
    dwDebugEventCode : u32,
    dwProcessId      : u32,
    dwThreadId       : u32,
    u : struct #raw_union {
        Exception         : EXCEPTION_DEBUG_INFO,
        CreateThread      : CREATE_THREAD_DEBUG_INFO,
        CreateProcessInfo : CREATE_PROCESS_DEBUG_INFO,
        ExitThread        : EXIT_THREAD_DEBUG_INFO,
        ExitProcess       : EXIT_PROCESS_DEBUG_INFO,
        LoadDll           : LOAD_DLL_DEBUG_INFO,
        UnloadDll         : UNLOAD_DLL_DEBUG_INFO,
        DebugString       : OUTPUT_DEBUG_STRING_INFO,
        RipInfo           : RIP_INFO,
    },
 };
 LPDEBUG_EVENT :: ^struct {
    dwDebugEventCode : u32,
    dwProcessId      : u32,
    dwThreadId       : u32,
    u : struct #raw_union {
        Exception         : EXCEPTION_DEBUG_INFO,
        CreateThread      : CREATE_THREAD_DEBUG_INFO,
        CreateProcessInfo : CREATE_PROCESS_DEBUG_INFO,
        ExitThread        : EXIT_THREAD_DEBUG_INFO,
        ExitProcess       : EXIT_PROCESS_DEBUG_INFO,
        LoadDll           : LOAD_DLL_DEBUG_INFO,
        UnloadDll         : UNLOAD_DLL_DEBUG_INFO,
        DebugString       : OUTPUT_DEBUG_STRING_INFO,
        RipInfo           : RIP_INFO,
    },
 };

 LPCONTEXT :: PCONTEXT;

 DISK_SPACE_INFORMATION :: struct {
    ActualTotalAllocationUnits           : ULONGLONG,
    ActualAvailableAllocationUnits       : ULONGLONG,
    ActualPoolUnavailableAllocationUnits : ULONGLONG,
    CallerTotalAllocationUnits           : ULONGLONG,
    CallerAvailableAllocationUnits       : ULONGLONG,
    CallerPoolUnavailableAllocationUnits : ULONGLONG,
    UsedAllocationUnits                  : ULONGLONG,
    TotalReservedAllocationUnits         : ULONGLONG,
    VolumeStorageReserveAllocationUnits  : ULONGLONG,
    AvailableCommittedAllocationUnits    : ULONGLONG,
    PoolAvailableAllocationUnits         : ULONGLONG,
    SectorsPerAllocationUnit             : u32,
    BytesPerSector                       : u32,
 };

 WIN32_FILE_ATTRIBUTE_DATA :: struct {
    dwFileAttributes : u32,
    ftCreationTime   : FILETIME,
    ftLastAccessTime : FILETIME,
    ftLastWriteTime  : FILETIME,
    nFileSizeHigh    : u32,
    nFileSizeLow     : u32,
 };
 LPWIN32_FILE_ATTRIBUTE_DATA :: ^struct {
    dwFileAttributes : u32,
    ftCreationTime   : FILETIME,
    ftLastAccessTime : FILETIME,
    ftLastWriteTime  : FILETIME,
    nFileSizeHigh    : u32,
    nFileSizeLow     : u32,
 };

 BY_HANDLE_FILE_INFORMATION :: struct {
    dwFileAttributes     : u32,
    ftCreationTime       : FILETIME,
    ftLastAccessTime     : FILETIME,
    ftLastWriteTime      : FILETIME,
    dwVolumeSerialNumber : u32,
    nFileSizeHigh        : u32,
    nFileSizeLow         : u32,
    nNumberOfLinks       : u32,
    nFileIndexHigh       : u32,
    nFileIndexLow        : u32,
 };
 PBY_HANDLE_FILE_INFORMATION :: ^struct {
    dwFileAttributes     : u32,
    ftCreationTime       : FILETIME,
    ftLastAccessTime     : FILETIME,
    ftLastWriteTime      : FILETIME,
    dwVolumeSerialNumber : u32,
    nFileSizeHigh        : u32,
    nFileSizeLow         : u32,
    nNumberOfLinks       : u32,
    nFileIndexHigh       : u32,
    nFileIndexLow        : u32,
 };
 LPBY_HANDLE_FILE_INFORMATION :: ^struct {
    dwFileAttributes     : u32,
    ftCreationTime       : FILETIME,
    ftLastAccessTime     : FILETIME,
    ftLastWriteTime      : FILETIME,
    dwVolumeSerialNumber : u32,
    nFileSizeHigh        : u32,
    nFileSizeLow         : u32,
    nNumberOfLinks       : u32,
    nFileIndexHigh       : u32,
    nFileIndexLow        : u32,
 };

 CREATEFILE2_EXTENDED_PARAMETERS :: struct {
    dwSize               : u32,
    dwFileAttributes     : u32,
    dwFileFlags          : u32,
    dwSecurityQosFlags   : u32,
    lpSecurityAttributes : LPSECURITY_ATTRIBUTES,
    hTemplateFile        : HANDLE,
 };
 PCREATEFILE2_EXTENDED_PARAMETERS :: ^struct {
    dwSize               : u32,
    dwFileAttributes     : u32,
    dwFileFlags          : u32,
    dwSecurityQosFlags   : u32,
    lpSecurityAttributes : LPSECURITY_ATTRIBUTES,
    hTemplateFile        : HANDLE,
 };
 LPCREATEFILE2_EXTENDED_PARAMETERS :: ^struct {
    dwSize               : u32,
    dwFileAttributes     : u32,
    dwFileFlags          : u32,
    dwSecurityQosFlags   : u32,
    lpSecurityAttributes : LPSECURITY_ATTRIBUTES,
    hTemplateFile        : HANDLE,
 };

 STREAM_INFO_LEVELS :: enum {
    FindStreamInfoStandard,
    FindStreamInfoMaxInfoLevel,
 };

 WIN32_FIND_STREAM_DATA :: struct {
    StreamSize  : LARGE_INTEGER,
    cStreamName : [260 + 36]WCHAR,
 };
 PWIN32_FIND_STREAM_DATA :: ^struct {
    StreamSize  : LARGE_INTEGER,
    cStreamName : [260 + 36]WCHAR,
 };

 PTOP_LEVEL_EXCEPTION_FILTER :: (proc(ExceptionInfo : ^EXCEPTION_POINTERS) -> LONG);

 LPTOP_LEVEL_EXCEPTION_FILTER :: PTOP_LEVEL_EXCEPTION_FILTER;

 HEAP_SUMMARY :: struct {
    cb           : u32,
    cbAllocated  : SIZE_T,
    cbCommitted  : SIZE_T,
    cbReserved   : SIZE_T,
    cbMaxReserve : SIZE_T,
 };
 PHEAP_SUMMARY :: ^struct {
    cb           : u32,
    cbAllocated  : SIZE_T,
    cbCommitted  : SIZE_T,
    cbReserved   : SIZE_T,
    cbMaxReserve : SIZE_T,
 };

 LPHEAP_SUMMARY :: PHEAP_SUMMARY;

 SRWLOCK :: RTL_SRWLOCK;
 PSRWLOCK :: ^RTL_SRWLOCK;

 INIT_ONCE :: RTL_RUN_ONCE;

 PINIT_ONCE :: PRTL_RUN_ONCE;

 LPINIT_ONCE :: PRTL_RUN_ONCE;

 PINIT_ONCE_FN :: (proc(InitOnce : PINIT_ONCE, Parameter : PVOID, Context : ^PVOID) -> BOOL);

 CONDITION_VARIABLE :: RTL_CONDITION_VARIABLE;
 PCONDITION_VARIABLE :: ^RTL_CONDITION_VARIABLE;

 PTIMERAPCROUTINE :: proc(lpArgToCompletionRoutine : LPVOID, dwTimerLowValue : u32, dwTimerHighValue : u32);

 SYNCHRONIZATION_BARRIER :: RTL_BARRIER;

 PSYNCHRONIZATION_BARRIER :: PRTL_BARRIER;

 LPSYNCHRONIZATION_BARRIER :: PRTL_BARRIER;

 PROCESS_INFORMATION :: struct {
    hProcess    : HANDLE,
    hThread     : HANDLE,
    dwProcessId : u32,
    dwThreadId  : u32,
 };
 PPROCESS_INFORMATION :: ^struct {
    hProcess    : HANDLE,
    hThread     : HANDLE,
    dwProcessId : u32,
    dwThreadId  : u32,
 };
 LPPROCESS_INFORMATION :: ^struct {
    hProcess    : HANDLE,
    hThread     : HANDLE,
    dwProcessId : u32,
    dwThreadId  : u32,
 };

 STARTUPINFOA :: struct {
    cb              : u32,
    lpReserved      : LPSTR,
    lpDesktop       : LPSTR,
    lpTitle         : LPSTR,
    dwX             : u32,
    dwY             : u32,
    dwXSize         : u32,
    dwYSize         : u32,
    dwXCountChars   : u32,
    dwYCountChars   : u32,
    dwFillAttribute : u32,
    dwFlags         : u32,
    wShowWindow     : u16,
    cbReserved2     : u16,
    lpReserved2     : LPBYTE,
    hStdInput       : HANDLE,
    hStdOutput      : HANDLE,
    hStdError       : HANDLE,
 };
 LPSTARTUPINFOA :: ^struct {
    cb              : u32,
    lpReserved      : LPSTR,
    lpDesktop       : LPSTR,
    lpTitle         : LPSTR,
    dwX             : u32,
    dwY             : u32,
    dwXSize         : u32,
    dwYSize         : u32,
    dwXCountChars   : u32,
    dwYCountChars   : u32,
    dwFillAttribute : u32,
    dwFlags         : u32,
    wShowWindow     : u16,
    cbReserved2     : u16,
    lpReserved2     : LPBYTE,
    hStdInput       : HANDLE,
    hStdOutput      : HANDLE,
    hStdError       : HANDLE,
 };

 STARTUPINFOW :: struct {
    cb              : u32,
    lpReserved      : LPWSTR,
    lpDesktop       : LPWSTR,
    lpTitle         : LPWSTR,
    dwX             : u32,
    dwY             : u32,
    dwXSize         : u32,
    dwYSize         : u32,
    dwXCountChars   : u32,
    dwYCountChars   : u32,
    dwFillAttribute : u32,
    dwFlags         : u32,
    wShowWindow     : u16,
    cbReserved2     : u16,
    lpReserved2     : LPBYTE,
    hStdInput       : HANDLE,
    hStdOutput      : HANDLE,
    hStdError       : HANDLE,
 };
 LPSTARTUPINFOW :: ^struct {
    cb              : u32,
    lpReserved      : LPWSTR,
    lpDesktop       : LPWSTR,
    lpTitle         : LPWSTR,
    dwX             : u32,
    dwY             : u32,
    dwXSize         : u32,
    dwYSize         : u32,
    dwXCountChars   : u32,
    dwYCountChars   : u32,
    dwFillAttribute : u32,
    dwFlags         : u32,
    wShowWindow     : u16,
    cbReserved2     : u16,
    lpReserved2     : LPBYTE,
    hStdInput       : HANDLE,
    hStdOutput      : HANDLE,
    hStdError       : HANDLE,
 };

 STARTUPINFO :: STARTUPINFOA;

 LPSTARTUPINFO :: LPSTARTUPINFOA;

 _PROC_THREAD_ATTRIBUTE_LIST :: struct {};

 PPROC_THREAD_ATTRIBUTE_LIST :: ^_PROC_THREAD_ATTRIBUTE_LIST;
 LPPROC_THREAD_ATTRIBUTE_LIST :: ^_PROC_THREAD_ATTRIBUTE_LIST;

 THREAD_INFORMATION_CLASS :: enum {
    ThreadMemoryPriority,
    ThreadAbsoluteCpuPriority,
    ThreadDynamicCodePolicy,
    ThreadPowerThrottling,
    ThreadInformationClassMax,
 };

 MEMORY_PRIORITY_INFORMATION :: struct {
    MemoryPriority : ULONG,
 };
 PMEMORY_PRIORITY_INFORMATION :: ^struct {
    MemoryPriority : ULONG,
 };

 THREAD_POWER_THROTTLING_STATE :: struct {
    Version     : ULONG,
    ControlMask : ULONG,
    StateMask   : ULONG,
 };

 PROCESS_INFORMATION_CLASS :: enum {
    ProcessMemoryPriority,
    ProcessMemoryExhaustionInfo,
    ProcessAppMemoryInfo,
    ProcessInPrivateInfo,
    ProcessPowerThrottling,
    ProcessReservedValue1,
    ProcessTelemetryCoverageInfo,
    ProcessProtectionLevelInfo,
    ProcessLeapSecondInfo,
    ProcessInformationClassMax,
 };

 APP_MEMORY_INFORMATION :: struct {
    AvailableCommit        : ULONG64,
    PrivateCommitUsage     : ULONG64,
    PeakPrivateCommitUsage : ULONG64,
    TotalCommitUsage       : ULONG64,
 };
 PAPP_MEMORY_INFORMATION :: ^struct {
    AvailableCommit        : ULONG64,
    PrivateCommitUsage     : ULONG64,
    PeakPrivateCommitUsage : ULONG64,
    TotalCommitUsage       : ULONG64,
 };

 PROCESS_MEMORY_EXHAUSTION_TYPE :: enum {
    PMETypeFailFastOnCommitFailure,
    PMETypeMax,
 };
 PPROCESS_MEMORY_EXHAUSTION_TYPE :: ^enum {
    PMETypeFailFastOnCommitFailure,
    PMETypeMax,
 };

 PROCESS_MEMORY_EXHAUSTION_INFO :: struct {
    Version  : USHORT,
    Reserved : USHORT,
    Type     : PROCESS_MEMORY_EXHAUSTION_TYPE,
    Value    : ULONG_PTR,
 };
 PPROCESS_MEMORY_EXHAUSTION_INFO :: ^struct {
    Version  : USHORT,
    Reserved : USHORT,
    Type     : PROCESS_MEMORY_EXHAUSTION_TYPE,
    Value    : ULONG_PTR,
 };

 PROCESS_POWER_THROTTLING_STATE :: struct {
    Version     : ULONG,
    ControlMask : ULONG,
    StateMask   : ULONG,
 };
 PPROCESS_POWER_THROTTLING_STATE :: ^struct {
    Version     : ULONG,
    ControlMask : ULONG,
    StateMask   : ULONG,
 };

 PROCESS_PROTECTION_LEVEL_INFORMATION :: struct {
    ProtectionLevel : u32,
 };

 PROCESS_LEAP_SECOND_INFO :: struct {
    Flags    : ULONG,
    Reserved : ULONG,
 };
 PPROCESS_LEAP_SECOND_INFO :: ^struct {
    Flags    : ULONG,
    Reserved : ULONG,
 };

 SYSTEM_INFO :: struct {
    u : struct #raw_union {
        dwOemId : u32,
        s : struct {
            wProcessorArchitecture : u16,
            wReserved              : u16,
        },
    },
    dwPageSize                  : u32,
    lpMinimumApplicationAddress : LPVOID,
    lpMaximumApplicationAddress : LPVOID,
    dwActiveProcessorMask       : DWORD_PTR,
    dwNumberOfProcessors        : u32,
    dwProcessorType             : u32,
    dwAllocationGranularity     : u32,
    wProcessorLevel             : u16,
    wProcessorRevision          : u16,
 };
 LPSYSTEM_INFO :: ^struct {
    u : struct #raw_union {
        dwOemId : u32,
        s : struct {
            wProcessorArchitecture : u16,
            wReserved              : u16,
        },
    },
    dwPageSize                  : u32,
    lpMinimumApplicationAddress : LPVOID,
    lpMaximumApplicationAddress : LPVOID,
    dwActiveProcessorMask       : DWORD_PTR,
    dwNumberOfProcessors        : u32,
    dwProcessorType             : u32,
    dwAllocationGranularity     : u32,
    wProcessorLevel             : u16,
    wProcessorRevision          : u16,
 };

 MEMORYSTATUSEX :: struct {
    dwLength                : u32,
    dwMemoryLoad            : u32,
    ullTotalPhys            : DWORDLONG,
    ullAvailPhys            : DWORDLONG,
    ullTotalPageFile        : DWORDLONG,
    ullAvailPageFile        : DWORDLONG,
    ullTotalVirtual         : DWORDLONG,
    ullAvailVirtual         : DWORDLONG,
    ullAvailExtendedVirtual : DWORDLONG,
 };
 LPMEMORYSTATUSEX :: ^struct {
    dwLength                : u32,
    dwMemoryLoad            : u32,
    ullTotalPhys            : DWORDLONG,
    ullAvailPhys            : DWORDLONG,
    ullTotalPageFile        : DWORDLONG,
    ullAvailPageFile        : DWORDLONG,
    ullTotalVirtual         : DWORDLONG,
    ullAvailVirtual         : DWORDLONG,
    ullAvailExtendedVirtual : DWORDLONG,
 };

 COMPUTER_NAME_FORMAT :: enum {
    ComputerNameNetBIOS,
    ComputerNameDnsHostname,
    ComputerNameDnsDomain,
    ComputerNameDnsFullyQualified,
    ComputerNamePhysicalNetBIOS,
    ComputerNamePhysicalDnsHostname,
    ComputerNamePhysicalDnsDomain,
    ComputerNamePhysicalDnsFullyQualified,
    ComputerNameMax,
 };

 MEMORY_RESOURCE_NOTIFICATION_TYPE :: enum {
    LowMemoryResourceNotification,
    HighMemoryResourceNotification,
 };

 WIN32_MEMORY_RANGE_ENTRY :: struct {
    VirtualAddress : PVOID,
    NumberOfBytes  : SIZE_T,
 };
 PWIN32_MEMORY_RANGE_ENTRY :: ^struct {
    VirtualAddress : PVOID,
    NumberOfBytes  : SIZE_T,
 };

 BAD_MEMORY_CALLBACK_ROUTINE :: #type proc(void);

 PBAD_MEMORY_CALLBACK_ROUTINE :: ^BAD_MEMORY_CALLBACK_ROUTINE;

 OFFER_PRIORITY :: enum {
    VmOfferPriorityVeryLow = 1,
    VmOfferPriorityLow,
    VmOfferPriorityBelowNormal,
    VmOfferPriorityNormal,
 };

 WIN32_MEMORY_INFORMATION_CLASS :: enum {
    MemoryRegionInfo,
 };

 WIN32_MEMORY_REGION_INFORMATION :: struct {
    AllocationBase    : PVOID,
    AllocationProtect : ULONG,
    u : struct #raw_union {
        Flags : ULONG,
        s : struct {
            Private        : ,
            MappedDataFile : ,
            MappedImage    : ,
            MappedPageFile : ,
            MappedPhysical : ,
            DirectMapped   : ,
            Reserved       : ,
        },
    },
    RegionSize        : SIZE_T,
    CommitSize        : SIZE_T,
 };

 PTP_WIN32_IO_CALLBACK :: proc(Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Overlapped : PVOID, IoResult : ULONG, NumberOfBytesTransferred : ULONG_PTR, Io : PTP_IO);

 JOBOBJECT_IO_RATE_CONTROL_INFORMATION :: struct {
    MaxIops         : LONG64,
    MaxBandwidth    : LONG64,
    ReservationIops : LONG64,
    VolumeName      : PCWSTR,
    BaseIoSize      : ULONG,
    ControlFlags    : ULONG,
 };

 ENUMUILANG :: struct {
    NumOfEnumUILang    : ULONG,
    SizeOfEnumUIBuffer : ULONG,
    pEnumUIBuffer      : ^LANGID,
 };
 PENUMUILANG :: ^struct {
    NumOfEnumUILang    : ULONG,
    SizeOfEnumUIBuffer : ULONG,
    pEnumUIBuffer      : ^LANGID,
 };

 ENUMRESLANGPROCA :: (proc(hModule : HMODULE, lpType : LPCSTR, lpName : LPCSTR, wLanguage : u16, lParam : LONG_PTR) -> BOOL);

 ENUMRESLANGPROCW :: (proc(hModule : HMODULE, lpType : LPCWSTR, lpName : LPCWSTR, wLanguage : u16, lParam : LONG_PTR) -> BOOL);

 ENUMRESNAMEPROCA :: (proc(hModule : HMODULE, lpType : LPCSTR, lpName : LPSTR, lParam : LONG_PTR) -> BOOL);

 ENUMRESNAMEPROCW :: (proc(hModule : HMODULE, lpType : LPCWSTR, lpName : LPWSTR, lParam : LONG_PTR) -> BOOL);

 ENUMRESTYPEPROCA :: (proc(hModule : HMODULE, lpType : LPSTR, lParam : LONG_PTR) -> BOOL);

 ENUMRESTYPEPROCW :: (proc(hModule : HMODULE, lpType : LPWSTR, lParam : LONG_PTR) -> BOOL);

 PGET_MODULE_HANDLE_EXA :: (proc(dwFlags : u32, lpModuleName : LPCSTR, phModule : ^HMODULE) -> BOOL);

 PGET_MODULE_HANDLE_EXW :: (proc(dwFlags : u32, lpModuleName : LPCWSTR, phModule : ^HMODULE) -> BOOL);

 REDIRECTION_FUNCTION_DESCRIPTOR :: struct {
    DllName           : PCSTR,
    FunctionName      : PCSTR,
    RedirectionTarget : PVOID,
 };
 PREDIRECTION_FUNCTION_DESCRIPTOR :: ^struct {
    DllName           : PCSTR,
    FunctionName      : PCSTR,
    RedirectionTarget : PVOID,
 };

 PCREDIRECTION_FUNCTION_DESCRIPTOR :: ^REDIRECTION_FUNCTION_DESCRIPTOR;

 REDIRECTION_DESCRIPTOR :: struct {
    Version       : ULONG,
    FunctionCount : ULONG,
    Redirections  : PCREDIRECTION_FUNCTION_DESCRIPTOR,
 };
 PREDIRECTION_DESCRIPTOR :: ^struct {
    Version       : ULONG,
    FunctionCount : ULONG,
    Redirections  : PCREDIRECTION_FUNCTION_DESCRIPTOR,
 };

 PCREDIRECTION_DESCRIPTOR :: ^REDIRECTION_DESCRIPTOR;

 DLL_DIRECTORY_COOKIE :: PVOID;
 PDLL_DIRECTORY_COOKIE :: ^PVOID;

 PFIBER_START_ROUTINE :: proc(lpFiberParameter : LPVOID);

 LPFIBER_START_ROUTINE :: PFIBER_START_ROUTINE;

 PFIBER_CALLOUT_ROUTINE :: (proc(lpParameter : LPVOID) -> LPVOID);

 LPLDT_ENTRY :: PLDT_ENTRY;

 COMMPROP :: struct {
    wPacketLength       : u16,
    wPacketVersion      : u16,
    dwServiceMask       : u32,
    dwReserved1         : u32,
    dwMaxTxQueue        : u32,
    dwMaxRxQueue        : u32,
    dwMaxBaud           : u32,
    dwProvSubType       : u32,
    dwProvCapabilities  : u32,
    dwSettableParams    : u32,
    dwSettableBaud      : u32,
    wSettableData       : u16,
    wSettableStopParity : u16,
    dwCurrentTxQueue    : u32,
    dwCurrentRxQueue    : u32,
    dwProvSpec1         : u32,
    dwProvSpec2         : u32,
    wcProvChar          : [1]WCHAR,
 };
 LPCOMMPROP :: ^struct {
    wPacketLength       : u16,
    wPacketVersion      : u16,
    dwServiceMask       : u32,
    dwReserved1         : u32,
    dwMaxTxQueue        : u32,
    dwMaxRxQueue        : u32,
    dwMaxBaud           : u32,
    dwProvSubType       : u32,
    dwProvCapabilities  : u32,
    dwSettableParams    : u32,
    dwSettableBaud      : u32,
    wSettableData       : u16,
    wSettableStopParity : u16,
    dwCurrentTxQueue    : u32,
    dwCurrentRxQueue    : u32,
    dwProvSpec1         : u32,
    dwProvSpec2         : u32,
    wcProvChar          : [1]WCHAR,
 };

 COMSTAT :: struct {
    fCtsHold  : ,
    fDsrHold  : ,
    fRlsdHold : ,
    fXoffHold : ,
    fXoffSent : ,
    fEof      : ,
    fTxim     : ,
    fReserved : ,
    cbInQue   : u32,
    cbOutQue  : u32,
 };
 LPCOMSTAT :: ^struct {
    fCtsHold  : ,
    fDsrHold  : ,
    fRlsdHold : ,
    fXoffHold : ,
    fXoffSent : ,
    fEof      : ,
    fTxim     : ,
    fReserved : ,
    cbInQue   : u32,
    cbOutQue  : u32,
 };

 DCB :: struct {
    DCBlength         : u32,
    BaudRate          : u32,
    fBinary           : ,
    fParity           : ,
    fOutxCtsFlow      : ,
    fOutxDsrFlow      : ,
    fDtrControl       : ,
    fDsrSensitivity   : ,
    fTXContinueOnXoff : ,
    fOutX             : ,
    fInX              : ,
    fErrorChar        : ,
    fNull             : ,
    fRtsControl       : ,
    fAbortOnError     : ,
    fDummy2           : ,
    wReserved         : u16,
    XonLim            : u16,
    XoffLim           : u16,
    ByteSize          : BYTE,
    Parity            : BYTE,
    StopBits          : BYTE,
    XonChar           : u8,
    XoffChar          : u8,
    ErrorChar         : u8,
    EofChar           : u8,
    EvtChar           : u8,
    wReserved1        : u16,
 };
 LPDCB :: ^struct {
    DCBlength         : u32,
    BaudRate          : u32,
    fBinary           : ,
    fParity           : ,
    fOutxCtsFlow      : ,
    fOutxDsrFlow      : ,
    fDtrControl       : ,
    fDsrSensitivity   : ,
    fTXContinueOnXoff : ,
    fOutX             : ,
    fInX              : ,
    fErrorChar        : ,
    fNull             : ,
    fRtsControl       : ,
    fAbortOnError     : ,
    fDummy2           : ,
    wReserved         : u16,
    XonLim            : u16,
    XoffLim           : u16,
    ByteSize          : BYTE,
    Parity            : BYTE,
    StopBits          : BYTE,
    XonChar           : u8,
    XoffChar          : u8,
    ErrorChar         : u8,
    EofChar           : u8,
    EvtChar           : u8,
    wReserved1        : u16,
 };

 COMMTIMEOUTS :: struct {
    ReadIntervalTimeout         : u32,
    ReadTotalTimeoutMultiplier  : u32,
    ReadTotalTimeoutConstant    : u32,
    WriteTotalTimeoutMultiplier : u32,
    WriteTotalTimeoutConstant   : u32,
 };
 LPCOMMTIMEOUTS :: ^struct {
    ReadIntervalTimeout         : u32,
    ReadTotalTimeoutMultiplier  : u32,
    ReadTotalTimeoutConstant    : u32,
    WriteTotalTimeoutMultiplier : u32,
    WriteTotalTimeoutConstant   : u32,
 };

 COMMCONFIG :: struct {
    dwSize            : u32,
    wVersion          : u16,
    wReserved         : u16,
    dcb               : DCB,
    dwProviderSubType : u32,
    dwProviderOffset  : u32,
    dwProviderSize    : u32,
    wcProviderData    : [1]WCHAR,
 };
 LPCOMMCONFIG :: ^struct {
    dwSize            : u32,
    wVersion          : u16,
    wReserved         : u16,
    dcb               : DCB,
    dwProviderSubType : u32,
    dwProviderOffset  : u32,
    dwProviderSize    : u32,
    wcProviderData    : [1]WCHAR,
 };

 MEMORYSTATUS :: struct {
    dwLength        : u32,
    dwMemoryLoad    : u32,
    dwTotalPhys     : SIZE_T,
    dwAvailPhys     : SIZE_T,
    dwTotalPageFile : SIZE_T,
    dwAvailPageFile : SIZE_T,
    dwTotalVirtual  : SIZE_T,
    dwAvailVirtual  : SIZE_T,
 };
 LPMEMORYSTATUS :: ^struct {
    dwLength        : u32,
    dwMemoryLoad    : u32,
    dwTotalPhys     : SIZE_T,
    dwAvailPhys     : SIZE_T,
    dwTotalPageFile : SIZE_T,
    dwAvailPageFile : SIZE_T,
    dwTotalVirtual  : SIZE_T,
    dwAvailVirtual  : SIZE_T,
 };

 JIT_DEBUG_INFO :: struct {
    dwSize                  : u32,
    dwProcessorArchitecture : u32,
    dwThreadID              : u32,
    dwReserved0             : u32,
    lpExceptionAddress      : ULONG64,
    lpExceptionRecord       : ULONG64,
    lpContextRecord         : ULONG64,
 };
 LPJIT_DEBUG_INFO :: ^struct {
    dwSize                  : u32,
    dwProcessorArchitecture : u32,
    dwThreadID              : u32,
    dwReserved0             : u32,
    lpExceptionAddress      : ULONG64,
    lpExceptionRecord       : ULONG64,
    lpContextRecord         : ULONG64,
 };

 JIT_DEBUG_INFO32 :: JIT_DEBUG_INFO;
 LPJIT_DEBUG_INFO32 :: ^JIT_DEBUG_INFO;

 JIT_DEBUG_INFO64 :: JIT_DEBUG_INFO;
 LPJIT_DEBUG_INFO64 :: ^JIT_DEBUG_INFO;

 LPEXCEPTION_RECORD :: PEXCEPTION_RECORD;

 LPEXCEPTION_POINTERS :: PEXCEPTION_POINTERS;

 OFSTRUCT :: struct {
    cBytes     : BYTE,
    fFixedDisk : BYTE,
    nErrCode   : u16,
    Reserved1  : u16,
    Reserved2  : u16,
    szPathName : [128]CHAR,
 };
 LPOFSTRUCT :: ^struct {
    cBytes     : BYTE,
    fFixedDisk : BYTE,
    nErrCode   : u16,
    Reserved1  : u16,
    Reserved2  : u16,
    szPathName : [128]CHAR,
 };
 POFSTRUCT :: ^struct {
    cBytes     : BYTE,
    fFixedDisk : BYTE,
    nErrCode   : u16,
    Reserved1  : u16,
    Reserved2  : u16,
    szPathName : [128]CHAR,
 };

 PUMS_CONTEXT :: rawptr;

 PUMS_COMPLETION_LIST :: rawptr;

 UMS_THREAD_INFO_CLASS :: struct {};

 PUMS_THREAD_INFO_CLASS :: ^UMS_THREAD_INFO_CLASS;

 UMS_SCHEDULER_REASON :: struct {};

 ;

 PUMS_SCHEDULER_ENTRY_POINT :: PRTL_UMS_SCHEDULER_ENTRY_POINT;

 UMS_SCHEDULER_STARTUP_INFO :: struct {
    UmsVersion     : ULONG,
    CompletionList : PUMS_COMPLETION_LIST,
    SchedulerProc  : PUMS_SCHEDULER_ENTRY_POINT,
    SchedulerParam : PVOID,
 };
 PUMS_SCHEDULER_STARTUP_INFO :: ^struct {
    UmsVersion     : ULONG,
    CompletionList : PUMS_COMPLETION_LIST,
    SchedulerProc  : PUMS_SCHEDULER_ENTRY_POINT,
    SchedulerParam : PVOID,
 };

 UMS_SYSTEM_THREAD_INFORMATION :: struct {
    UmsVersion : ULONG,
    u : struct #raw_union {
        s : struct {
            IsUmsSchedulerThread : ,
            IsUmsWorkerThread    : ,
        },
        ThreadUmsFlags : ULONG,
    },
 };
 PUMS_SYSTEM_THREAD_INFORMATION :: ^struct {
    UmsVersion : ULONG,
    u : struct #raw_union {
        s : struct {
            IsUmsSchedulerThread : ,
            IsUmsWorkerThread    : ,
        },
        ThreadUmsFlags : ULONG,
    },
 };

 POWER_REQUEST_CONTEXT :: REASON_CONTEXT;
 PPOWER_REQUEST_CONTEXT :: ^REASON_CONTEXT;
 LPPOWER_REQUEST_CONTEXT :: ^REASON_CONTEXT;

 DEP_SYSTEM_POLICY_TYPE :: enum {
    DEPPolicyAlwaysOff = 0,
    DEPPolicyAlwaysOn,
    DEPPolicyOptIn,
    DEPPolicyOptOut,
    DEPTotalPolicyCount,
 };

 PFE_EXPORT_FUNC :: (proc(pbData : PBYTE, pvCallbackContext : PVOID, ulLength : ULONG) -> u32);

 PFE_IMPORT_FUNC :: (proc(pbData : PBYTE, pvCallbackContext : PVOID, ulLength : PULONG) -> u32);

 WIN32_STREAM_ID :: struct {
    dwStreamId         : u32,
    dwStreamAttributes : u32,
    Size               : LARGE_INTEGER,
    dwStreamNameSize   : u32,
    cStreamName        : [1]WCHAR,
 };
 LPWIN32_STREAM_ID :: ^struct {
    dwStreamId         : u32,
    dwStreamAttributes : u32,
    Size               : LARGE_INTEGER,
    dwStreamNameSize   : u32,
    cStreamName        : [1]WCHAR,
 };

 STARTUPINFOEXA :: struct {
    StartupInfo     : STARTUPINFOA,
    lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST,
 };
 LPSTARTUPINFOEXA :: ^struct {
    StartupInfo     : STARTUPINFOA,
    lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST,
 };

 STARTUPINFOEXW :: struct {
    StartupInfo     : STARTUPINFOW,
    lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST,
 };
 LPSTARTUPINFOEXW :: ^struct {
    StartupInfo     : STARTUPINFOW,
    lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST,
 };

 STARTUPINFOEX :: STARTUPINFOEXA;

 LPSTARTUPINFOEX :: LPSTARTUPINFOEXA;

 PROC_THREAD_ATTRIBUTE_NUM :: enum {
    ProcThreadAttributeParentProcess = 0,
    ProcThreadAttributeHandleList = 2,
    ProcThreadAttributeGroupAffinity = 3,
    ProcThreadAttributePreferredNode = 4,
    ProcThreadAttributeIdealProcessor = 5,
    ProcThreadAttributeUmsThread = 6,
    ProcThreadAttributeMitigationPolicy = 7,
    ProcThreadAttributeSecurityCapabilities = 9,
    ProcThreadAttributeProtectionLevel = 11,
    ProcThreadAttributeJobList = 13,
    ProcThreadAttributeChildProcessPolicy = 14,
    ProcThreadAttributeAllApplicationPackagesPolicy = 15,
    ProcThreadAttributeWin32kFilter = 16,
    ProcThreadAttributeSafeOpenPromptOriginClaim = 17,
    ProcThreadAttributeDesktopAppPolicy = 18,
    ProcThreadAttributePseudoConsole = 22,
 };

 PGET_SYSTEM_WOW64_DIRECTORY_A :: (proc(lpBuffer : LPSTR, uSize : UINT) -> UINT);

 PGET_SYSTEM_WOW64_DIRECTORY_W :: (proc(lpBuffer : LPWSTR, uSize : UINT) -> UINT);

 LPPROGRESS_ROUTINE :: (proc(TotalFileSize : LARGE_INTEGER, TotalBytesTransferred : LARGE_INTEGER, StreamSize : LARGE_INTEGER, StreamBytesTransferred : LARGE_INTEGER, dwStreamNumber : u32, dwCallbackReason : u32, hSourceFile : HANDLE, hDestinationFile : HANDLE, lpData : LPVOID) -> u32);

 COPYFILE2_MESSAGE_TYPE :: enum {
    COPYFILE2_CALLBACK_NONE = 0,
    COPYFILE2_CALLBACK_CHUNK_STARTED,
    COPYFILE2_CALLBACK_CHUNK_FINISHED,
    COPYFILE2_CALLBACK_STREAM_STARTED,
    COPYFILE2_CALLBACK_STREAM_FINISHED,
    COPYFILE2_CALLBACK_POLL_CONTINUE,
    COPYFILE2_CALLBACK_ERROR,
    COPYFILE2_CALLBACK_MAX,
 };

 COPYFILE2_MESSAGE_ACTION :: enum {
    COPYFILE2_PROGRESS_CONTINUE = 0,
    COPYFILE2_PROGRESS_CANCEL,
    COPYFILE2_PROGRESS_STOP,
    COPYFILE2_PROGRESS_QUIET,
    COPYFILE2_PROGRESS_PAUSE,
 };

 COPYFILE2_COPY_PHASE :: enum {
    COPYFILE2_PHASE_NONE = 0,
    COPYFILE2_PHASE_PREPARE_SOURCE,
    COPYFILE2_PHASE_PREPARE_DEST,
    COPYFILE2_PHASE_READ_SOURCE,
    COPYFILE2_PHASE_WRITE_DESTINATION,
    COPYFILE2_PHASE_SERVER_COPY,
    COPYFILE2_PHASE_NAMEGRAFT_COPY,
    COPYFILE2_PHASE_MAX,
 };

 COPYFILE2_MESSAGE :: struct {
    Type      : COPYFILE2_MESSAGE_TYPE,
    dwPadding : u32,
    Info : struct #raw_union {
        ChunkStarted : struct {
            dwStreamNumber   : u32,
            dwReserved       : u32,
            hSourceFile      : HANDLE,
            hDestinationFile : HANDLE,
            uliChunkNumber   : ULARGE_INTEGER,
            uliChunkSize     : ULARGE_INTEGER,
            uliStreamSize    : ULARGE_INTEGER,
            uliTotalFileSize : ULARGE_INTEGER,
        },
        ChunkFinished : struct {
            dwStreamNumber            : u32,
            dwFlags                   : u32,
            hSourceFile               : HANDLE,
            hDestinationFile          : HANDLE,
            uliChunkNumber            : ULARGE_INTEGER,
            uliChunkSize              : ULARGE_INTEGER,
            uliStreamSize             : ULARGE_INTEGER,
            uliStreamBytesTransferred : ULARGE_INTEGER,
            uliTotalFileSize          : ULARGE_INTEGER,
            uliTotalBytesTransferred  : ULARGE_INTEGER,
        },
        StreamStarted : struct {
            dwStreamNumber   : u32,
            dwReserved       : u32,
            hSourceFile      : HANDLE,
            hDestinationFile : HANDLE,
            uliStreamSize    : ULARGE_INTEGER,
            uliTotalFileSize : ULARGE_INTEGER,
        },
        StreamFinished : struct {
            dwStreamNumber            : u32,
            dwReserved                : u32,
            hSourceFile               : HANDLE,
            hDestinationFile          : HANDLE,
            uliStreamSize             : ULARGE_INTEGER,
            uliStreamBytesTransferred : ULARGE_INTEGER,
            uliTotalFileSize          : ULARGE_INTEGER,
            uliTotalBytesTransferred  : ULARGE_INTEGER,
        },
        PollContinue : struct {
            dwReserved : u32,
        },
        Error : struct {
            CopyPhase                 : COPYFILE2_COPY_PHASE,
            dwStreamNumber            : u32,
            hrFailure                 : HRESULT,
            dwReserved                : u32,
            uliChunkNumber            : ULARGE_INTEGER,
            uliStreamSize             : ULARGE_INTEGER,
            uliStreamBytesTransferred : ULARGE_INTEGER,
            uliTotalFileSize          : ULARGE_INTEGER,
            uliTotalBytesTransferred  : ULARGE_INTEGER,
        },
    },
 };

 PCOPYFILE2_PROGRESS_ROUTINE :: (proc(pMessage : ^COPYFILE2_MESSAGE, pvCallbackContext : PVOID) -> COPYFILE2_MESSAGE_ACTION);

 COPYFILE2_EXTENDED_PARAMETERS :: struct {
    dwSize            : u32,
    dwCopyFlags       : u32,
    pfCancel          : ^BOOL,
    pProgressRoutine  : PCOPYFILE2_PROGRESS_ROUTINE,
    pvCallbackContext : PVOID,
 };

 EVENTLOG_FULL_INFORMATION :: struct {
    dwFull : u32,
 };
 LPEVENTLOG_FULL_INFORMATION :: ^struct {
    dwFull : u32,
 };

 OPERATION_ID :: ULONG;

 OPERATION_START_PARAMETERS :: struct {
    Version     : ULONG,
    OperationId : OPERATION_ID,
    Flags       : ULONG,
 };
 POPERATION_START_PARAMETERS :: ^struct {
    Version     : ULONG,
    OperationId : OPERATION_ID,
    Flags       : ULONG,
 };

 OPERATION_END_PARAMETERS :: struct {
    Version     : ULONG,
    OperationId : OPERATION_ID,
    Flags       : ULONG,
 };
 POPERATION_END_PARAMETERS :: ^struct {
    Version     : ULONG,
    OperationId : OPERATION_ID,
    Flags       : ULONG,
 };

 HW_PROFILE_INFOA :: struct {
    dwDockInfo      : u32,
    szHwProfileGuid : [39]CHAR,
    szHwProfileName : [80]CHAR,
 };
 LPHW_PROFILE_INFOA :: ^struct {
    dwDockInfo      : u32,
    szHwProfileGuid : [39]CHAR,
    szHwProfileName : [80]CHAR,
 };

 HW_PROFILE_INFOW :: struct {
    dwDockInfo      : u32,
    szHwProfileGuid : [39]WCHAR,
    szHwProfileName : [80]WCHAR,
 };
 LPHW_PROFILE_INFOW :: ^struct {
    dwDockInfo      : u32,
    szHwProfileGuid : [39]WCHAR,
    szHwProfileName : [80]WCHAR,
 };

 HW_PROFILE_INFO :: HW_PROFILE_INFOA;

 LPHW_PROFILE_INFO :: LPHW_PROFILE_INFOA;

 TIME_ZONE_INFORMATION :: struct {
    Bias         : LONG,
    StandardName : [32]WCHAR,
    StandardDate : SYSTEMTIME,
    StandardBias : LONG,
    DaylightName : [32]WCHAR,
    DaylightDate : SYSTEMTIME,
    DaylightBias : LONG,
 };
 PTIME_ZONE_INFORMATION :: ^struct {
    Bias         : LONG,
    StandardName : [32]WCHAR,
    StandardDate : SYSTEMTIME,
    StandardBias : LONG,
    DaylightName : [32]WCHAR,
    DaylightDate : SYSTEMTIME,
    DaylightBias : LONG,
 };
 LPTIME_ZONE_INFORMATION :: ^struct {
    Bias         : LONG,
    StandardName : [32]WCHAR,
    StandardDate : SYSTEMTIME,
    StandardBias : LONG,
    DaylightName : [32]WCHAR,
    DaylightDate : SYSTEMTIME,
    DaylightBias : LONG,
 };

 DYNAMIC_TIME_ZONE_INFORMATION :: struct {
    Bias                        : LONG,
    StandardName                : [32]WCHAR,
    StandardDate                : SYSTEMTIME,
    StandardBias                : LONG,
    DaylightName                : [32]WCHAR,
    DaylightDate                : SYSTEMTIME,
    DaylightBias                : LONG,
    TimeZoneKeyName             : [128]WCHAR,
    DynamicDaylightTimeDisabled : BOOLEAN,
 };
 PDYNAMIC_TIME_ZONE_INFORMATION :: ^struct {
    Bias                        : LONG,
    StandardName                : [32]WCHAR,
    StandardDate                : SYSTEMTIME,
    StandardBias                : LONG,
    DaylightName                : [32]WCHAR,
    DaylightDate                : SYSTEMTIME,
    DaylightBias                : LONG,
    TimeZoneKeyName             : [128]WCHAR,
    DynamicDaylightTimeDisabled : BOOLEAN,
 };

 SYSTEM_POWER_STATUS :: struct {
    ACLineStatus        : BYTE,
    BatteryFlag         : BYTE,
    BatteryLifePercent  : BYTE,
    SystemStatusFlag    : BYTE,
    BatteryLifeTime     : u32,
    BatteryFullLifeTime : u32,
 };
 LPSYSTEM_POWER_STATUS :: ^struct {
    ACLineStatus        : BYTE,
    BatteryFlag         : BYTE,
    BatteryLifePercent  : BYTE,
    SystemStatusFlag    : BYTE,
    BatteryLifeTime     : u32,
    BatteryFullLifeTime : u32,
 };

 ACTCTXA :: struct {
    cbSize                 : ULONG,
    dwFlags                : u32,
    lpSource               : LPCSTR,
    wProcessorArchitecture : USHORT,
    wLangId                : LANGID,
    lpAssemblyDirectory    : LPCSTR,
    lpResourceName         : LPCSTR,
    lpApplicationName      : LPCSTR,
    hModule                : HMODULE,
 };
 PACTCTXA :: ^struct {
    cbSize                 : ULONG,
    dwFlags                : u32,
    lpSource               : LPCSTR,
    wProcessorArchitecture : USHORT,
    wLangId                : LANGID,
    lpAssemblyDirectory    : LPCSTR,
    lpResourceName         : LPCSTR,
    lpApplicationName      : LPCSTR,
    hModule                : HMODULE,
 };

 ACTCTXW :: struct {
    cbSize                 : ULONG,
    dwFlags                : u32,
    lpSource               : LPCWSTR,
    wProcessorArchitecture : USHORT,
    wLangId                : LANGID,
    lpAssemblyDirectory    : LPCWSTR,
    lpResourceName         : LPCWSTR,
    lpApplicationName      : LPCWSTR,
    hModule                : HMODULE,
 };
 PACTCTXW :: ^struct {
    cbSize                 : ULONG,
    dwFlags                : u32,
    lpSource               : LPCWSTR,
    wProcessorArchitecture : USHORT,
    wLangId                : LANGID,
    lpAssemblyDirectory    : LPCWSTR,
    lpResourceName         : LPCWSTR,
    lpApplicationName      : LPCWSTR,
    hModule                : HMODULE,
 };

 ACTCTX :: ACTCTXA;

 PACTCTX :: PACTCTXA;

 PCACTCTXA :: ^ACTCTXA;

 PCACTCTXW :: ^ACTCTXW;

 PCACTCTX :: PCACTCTXA;

 ACTCTX_SECTION_KEYED_DATA_2600 :: struct {
    cbSize                    : ULONG,
    ulDataFormatVersion       : ULONG,
    lpData                    : PVOID,
    ulLength                  : ULONG,
    lpSectionGlobalData       : PVOID,
    ulSectionGlobalDataLength : ULONG,
    lpSectionBase             : PVOID,
    ulSectionTotalLength      : ULONG,
    hActCtx                   : HANDLE,
    ulAssemblyRosterIndex     : ULONG,
 };
 PACTCTX_SECTION_KEYED_DATA_2600 :: ^struct {
    cbSize                    : ULONG,
    ulDataFormatVersion       : ULONG,
    lpData                    : PVOID,
    ulLength                  : ULONG,
    lpSectionGlobalData       : PVOID,
    ulSectionGlobalDataLength : ULONG,
    lpSectionBase             : PVOID,
    ulSectionTotalLength      : ULONG,
    hActCtx                   : HANDLE,
    ulAssemblyRosterIndex     : ULONG,
 };

 PCACTCTX_SECTION_KEYED_DATA_2600 :: ^ACTCTX_SECTION_KEYED_DATA_2600;

 ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: struct {
    lpInformation             : PVOID,
    lpSectionBase             : PVOID,
    ulSectionLength           : ULONG,
    lpSectionGlobalDataBase   : PVOID,
    ulSectionGlobalDataLength : ULONG,
 };
 PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: ^struct {
    lpInformation             : PVOID,
    lpSectionBase             : PVOID,
    ulSectionLength           : ULONG,
    lpSectionGlobalDataBase   : PVOID,
    ulSectionGlobalDataLength : ULONG,
 };

 PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: ^ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;

 ACTCTX_SECTION_KEYED_DATA :: struct {
    cbSize                    : ULONG,
    ulDataFormatVersion       : ULONG,
    lpData                    : PVOID,
    ulLength                  : ULONG,
    lpSectionGlobalData       : PVOID,
    ulSectionGlobalDataLength : ULONG,
    lpSectionBase             : PVOID,
    ulSectionTotalLength      : ULONG,
    hActCtx                   : HANDLE,
    ulAssemblyRosterIndex     : ULONG,
    ulFlags                   : ULONG,
    AssemblyMetadata          : ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA,
 };
 PACTCTX_SECTION_KEYED_DATA :: ^struct {
    cbSize                    : ULONG,
    ulDataFormatVersion       : ULONG,
    lpData                    : PVOID,
    ulLength                  : ULONG,
    lpSectionGlobalData       : PVOID,
    ulSectionGlobalDataLength : ULONG,
    lpSectionBase             : PVOID,
    ulSectionTotalLength      : ULONG,
    hActCtx                   : HANDLE,
    ulAssemblyRosterIndex     : ULONG,
    ulFlags                   : ULONG,
    AssemblyMetadata          : ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA,
 };

 PCACTCTX_SECTION_KEYED_DATA :: ^ACTCTX_SECTION_KEYED_DATA;

 ACTIVATION_CONTEXT_BASIC_INFORMATION :: struct {
    hActCtx : HANDLE,
    dwFlags : u32,
 };
 PACTIVATION_CONTEXT_BASIC_INFORMATION :: ^struct {
    hActCtx : HANDLE,
    dwFlags : u32,
 };

 PCACTIVATION_CONTEXT_BASIC_INFORMATION :: ^ACTIVATION_CONTEXT_BASIC_INFORMATION;

 PQUERYACTCTXW_FUNC :: (proc(dwFlags : u32, hActCtx : HANDLE, pvSubInstance : PVOID, ulInfoClass : ULONG, pvBuffer : PVOID, cbBuffer : SIZE_T, pcbWrittenOrRequired : ^SIZE_T) -> BOOL);

 APPLICATION_RECOVERY_CALLBACK :: (proc(pvParameter : PVOID) -> u32);

 FILE_BASIC_INFO :: struct {
    CreationTime   : LARGE_INTEGER,
    LastAccessTime : LARGE_INTEGER,
    LastWriteTime  : LARGE_INTEGER,
    ChangeTime     : LARGE_INTEGER,
    FileAttributes : u32,
 };
 PFILE_BASIC_INFO :: ^struct {
    CreationTime   : LARGE_INTEGER,
    LastAccessTime : LARGE_INTEGER,
    LastWriteTime  : LARGE_INTEGER,
    ChangeTime     : LARGE_INTEGER,
    FileAttributes : u32,
 };

 FILE_STANDARD_INFO :: struct {
    AllocationSize : LARGE_INTEGER,
    EndOfFile      : LARGE_INTEGER,
    NumberOfLinks  : u32,
    DeletePending  : BOOLEAN,
    Directory      : BOOLEAN,
 };
 PFILE_STANDARD_INFO :: ^struct {
    AllocationSize : LARGE_INTEGER,
    EndOfFile      : LARGE_INTEGER,
    NumberOfLinks  : u32,
    DeletePending  : BOOLEAN,
    Directory      : BOOLEAN,
 };

 FILE_NAME_INFO :: struct {
    FileNameLength : u32,
    FileName       : [1]WCHAR,
 };
 PFILE_NAME_INFO :: ^struct {
    FileNameLength : u32,
    FileName       : [1]WCHAR,
 };

 FILE_CASE_SENSITIVE_INFO :: struct {
    Flags : ULONG,
 };
 PFILE_CASE_SENSITIVE_INFO :: ^struct {
    Flags : ULONG,
 };

 FILE_RENAME_INFO :: struct {
    u : struct #raw_union {
        ReplaceIfExists : BOOLEAN,
        Flags           : u32,
    },
    RootDirectory  : HANDLE,
    FileNameLength : u32,
    FileName       : [1]WCHAR,
 };
 PFILE_RENAME_INFO :: ^struct {
    u : struct #raw_union {
        ReplaceIfExists : BOOLEAN,
        Flags           : u32,
    },
    RootDirectory  : HANDLE,
    FileNameLength : u32,
    FileName       : [1]WCHAR,
 };

 FILE_ALLOCATION_INFO :: struct {
    AllocationSize : LARGE_INTEGER,
 };
 PFILE_ALLOCATION_INFO :: ^struct {
    AllocationSize : LARGE_INTEGER,
 };

 FILE_END_OF_FILE_INFO :: struct {
    EndOfFile : LARGE_INTEGER,
 };
 PFILE_END_OF_FILE_INFO :: ^struct {
    EndOfFile : LARGE_INTEGER,
 };

 FILE_STREAM_INFO :: struct {
    NextEntryOffset      : u32,
    StreamNameLength     : u32,
    StreamSize           : LARGE_INTEGER,
    StreamAllocationSize : LARGE_INTEGER,
    StreamName           : [1]WCHAR,
 };
 PFILE_STREAM_INFO :: ^struct {
    NextEntryOffset      : u32,
    StreamNameLength     : u32,
    StreamSize           : LARGE_INTEGER,
    StreamAllocationSize : LARGE_INTEGER,
    StreamName           : [1]WCHAR,
 };

 FILE_COMPRESSION_INFO :: struct {
    CompressedFileSize   : LARGE_INTEGER,
    CompressionFormat    : u16,
    CompressionUnitShift : UCHAR,
    ChunkShift           : UCHAR,
    ClusterShift         : UCHAR,
    Reserved             : [3]UCHAR,
 };
 PFILE_COMPRESSION_INFO :: ^struct {
    CompressedFileSize   : LARGE_INTEGER,
    CompressionFormat    : u16,
    CompressionUnitShift : UCHAR,
    ChunkShift           : UCHAR,
    ClusterShift         : UCHAR,
    Reserved             : [3]UCHAR,
 };

 FILE_ATTRIBUTE_TAG_INFO :: struct {
    FileAttributes : u32,
    ReparseTag     : u32,
 };
 PFILE_ATTRIBUTE_TAG_INFO :: ^struct {
    FileAttributes : u32,
    ReparseTag     : u32,
 };

 FILE_DISPOSITION_INFO :: struct {
    DeleteFileA : BOOLEAN,
 };
 PFILE_DISPOSITION_INFO :: ^struct {
    DeleteFileA : BOOLEAN,
 };

 FILE_DISPOSITION_INFO_EX :: struct {
    Flags : u32,
 };
 PFILE_DISPOSITION_INFO_EX :: ^struct {
    Flags : u32,
 };

 FILE_ID_BOTH_DIR_INFO :: struct {
    NextEntryOffset : u32,
    FileIndex       : u32,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : u32,
    FileNameLength  : u32,
    EaSize          : u32,
    ShortNameLength : CCHAR,
    ShortName       : [12]WCHAR,
    FileId          : LARGE_INTEGER,
    FileName        : [1]WCHAR,
 };
 PFILE_ID_BOTH_DIR_INFO :: ^struct {
    NextEntryOffset : u32,
    FileIndex       : u32,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : u32,
    FileNameLength  : u32,
    EaSize          : u32,
    ShortNameLength : CCHAR,
    ShortName       : [12]WCHAR,
    FileId          : LARGE_INTEGER,
    FileName        : [1]WCHAR,
 };

 FILE_FULL_DIR_INFO :: struct {
    NextEntryOffset : ULONG,
    FileIndex       : ULONG,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : ULONG,
    FileNameLength  : ULONG,
    EaSize          : ULONG,
    FileName        : [1]WCHAR,
 };
 PFILE_FULL_DIR_INFO :: ^struct {
    NextEntryOffset : ULONG,
    FileIndex       : ULONG,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : ULONG,
    FileNameLength  : ULONG,
    EaSize          : ULONG,
    FileName        : [1]WCHAR,
 };

 PRIORITY_HINT :: enum {
    IoPriorityHintVeryLow = 0,
    IoPriorityHintLow,
    IoPriorityHintNormal,
    MaximumIoPriorityHintType,
 };

 FILE_IO_PRIORITY_HINT_INFO :: struct {
    PriorityHint : PRIORITY_HINT,
 };
 PFILE_IO_PRIORITY_HINT_INFO :: ^struct {
    PriorityHint : PRIORITY_HINT,
 };

 FILE_ALIGNMENT_INFO :: struct {
    AlignmentRequirement : ULONG,
 };
 PFILE_ALIGNMENT_INFO :: ^struct {
    AlignmentRequirement : ULONG,
 };

 FILE_STORAGE_INFO :: struct {
    LogicalBytesPerSector                                 : ULONG,
    PhysicalBytesPerSectorForAtomicity                    : ULONG,
    PhysicalBytesPerSectorForPerformance                  : ULONG,
    FileSystemEffectivePhysicalBytesPerSectorForAtomicity : ULONG,
    Flags                                                 : ULONG,
    ByteOffsetForSectorAlignment                          : ULONG,
    ByteOffsetForPartitionAlignment                       : ULONG,
 };
 PFILE_STORAGE_INFO :: ^struct {
    LogicalBytesPerSector                                 : ULONG,
    PhysicalBytesPerSectorForAtomicity                    : ULONG,
    PhysicalBytesPerSectorForPerformance                  : ULONG,
    FileSystemEffectivePhysicalBytesPerSectorForAtomicity : ULONG,
    Flags                                                 : ULONG,
    ByteOffsetForSectorAlignment                          : ULONG,
    ByteOffsetForPartitionAlignment                       : ULONG,
 };

 FILE_ID_INFO :: struct {
    VolumeSerialNumber : ULONGLONG,
    FileId             : FILE_ID_128,
 };
 PFILE_ID_INFO :: ^struct {
    VolumeSerialNumber : ULONGLONG,
    FileId             : FILE_ID_128,
 };

 FILE_ID_EXTD_DIR_INFO :: struct {
    NextEntryOffset : ULONG,
    FileIndex       : ULONG,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : ULONG,
    FileNameLength  : ULONG,
    EaSize          : ULONG,
    ReparsePointTag : ULONG,
    FileId          : FILE_ID_128,
    FileName        : [1]WCHAR,
 };
 PFILE_ID_EXTD_DIR_INFO :: ^struct {
    NextEntryOffset : ULONG,
    FileIndex       : ULONG,
    CreationTime    : LARGE_INTEGER,
    LastAccessTime  : LARGE_INTEGER,
    LastWriteTime   : LARGE_INTEGER,
    ChangeTime      : LARGE_INTEGER,
    EndOfFile       : LARGE_INTEGER,
    AllocationSize  : LARGE_INTEGER,
    FileAttributes  : ULONG,
    FileNameLength  : ULONG,
    EaSize          : ULONG,
    ReparsePointTag : ULONG,
    FileId          : FILE_ID_128,
    FileName        : [1]WCHAR,
 };

 FILE_REMOTE_PROTOCOL_INFO :: struct {
    StructureVersion     : USHORT,
    StructureSize        : USHORT,
    Protocol             : ULONG,
    ProtocolMajorVersion : USHORT,
    ProtocolMinorVersion : USHORT,
    ProtocolRevision     : USHORT,
    Reserved             : USHORT,
    Flags                : ULONG,
    GenericReserved : struct {
        Reserved : [8]ULONG,
    },
    ProtocolSpecific : struct #raw_union {
        Smb2 : struct {
            Server : struct {
                Capabilities : ULONG,
            },
            Share : struct {
                Capabilities : ULONG,
                CachingFlags : ULONG,
            },
        },
        Reserved : [16]ULONG,
    },
 };
 PFILE_REMOTE_PROTOCOL_INFO :: ^struct {
    StructureVersion     : USHORT,
    StructureSize        : USHORT,
    Protocol             : ULONG,
    ProtocolMajorVersion : USHORT,
    ProtocolMinorVersion : USHORT,
    ProtocolRevision     : USHORT,
    Reserved             : USHORT,
    Flags                : ULONG,
    GenericReserved : struct {
        Reserved : [8]ULONG,
    },
    ProtocolSpecific : struct #raw_union {
        Smb2 : struct {
            Server : struct {
                Capabilities : ULONG,
            },
            Share : struct {
                Capabilities : ULONG,
                CachingFlags : ULONG,
            },
        },
        Reserved : [16]ULONG,
    },
 };

 FILE_ID_TYPE :: enum {
    FileIdType,
    ObjectIdType,
    ExtendedFileIdType,
    MaximumFileIdType,
 };
 PFILE_ID_TYPE :: ^enum {
    FileIdType,
    ObjectIdType,
    ExtendedFileIdType,
    MaximumFileIdType,
 };

 FILE_ID_DESCRIPTOR :: struct {
    dwSize : u32,
    Type   : FILE_ID_TYPE,
    u : struct #raw_union {
        FileId         : LARGE_INTEGER,
        ObjectId       : GUID,
        ExtendedFileId : FILE_ID_128,
    },
 };
 LPFILE_ID_DESCRIPTOR :: ^struct {
    dwSize : u32,
    Type   : FILE_ID_TYPE,
    u : struct #raw_union {
        FileId         : LARGE_INTEGER,
        ObjectId       : GUID,
        ExtendedFileId : FILE_ID_128,
    },
 };

 DRAWPATRECT :: struct {
    ptPosition : POINT,
    ptSize     : POINT,
    wStyle     : u16,
    wPattern   : u16,
 };
 PDRAWPATRECT :: ^struct {
    ptPosition : POINT,
    ptSize     : POINT,
    wStyle     : u16,
    wPattern   : u16,
 };

 PSINJECTDATA :: struct {
    DataBytes      : u32,
    InjectionPoint : u16,
    PageNumber     : u16,
 };
 PPSINJECTDATA :: ^struct {
    DataBytes      : u32,
    InjectionPoint : u16,
    PageNumber     : u16,
 };

 PSFEATURE_OUTPUT :: struct {
    bPageIndependent : BOOL,
    bSetPageDevice   : BOOL,
 };
 PPSFEATURE_OUTPUT :: ^struct {
    bPageIndependent : BOOL,
    bSetPageDevice   : BOOL,
 };

 PSFEATURE_CUSTPAPER :: struct {
    lOrientation  : LONG,
    lWidth        : LONG,
    lHeight       : LONG,
    lWidthOffset  : LONG,
    lHeightOffset : LONG,
 };
 PPSFEATURE_CUSTPAPER :: ^struct {
    lOrientation  : LONG,
    lWidth        : LONG,
    lHeight       : LONG,
    lWidthOffset  : LONG,
    lHeightOffset : LONG,
 };

 XFORM :: struct {
    eM11 : FLOAT,
    eM12 : FLOAT,
    eM21 : FLOAT,
    eM22 : FLOAT,
    eDx  : FLOAT,
    eDy  : FLOAT,
 };
 PXFORM :: ^struct {
    eM11 : FLOAT,
    eM12 : FLOAT,
    eM21 : FLOAT,
    eM22 : FLOAT,
    eDx  : FLOAT,
    eDy  : FLOAT,
 };
 LPXFORM :: ^struct {
    eM11 : FLOAT,
    eM12 : FLOAT,
    eM21 : FLOAT,
    eM22 : FLOAT,
    eDx  : FLOAT,
    eDy  : FLOAT,
 };

 BITMAP :: struct {
    bmType       : LONG,
    bmWidth      : LONG,
    bmHeight     : LONG,
    bmWidthBytes : LONG,
    bmPlanes     : u16,
    bmBitsPixel  : u16,
    bmBits       : LPVOID,
 };
 PBITMAP :: ^struct {
    bmType       : LONG,
    bmWidth      : LONG,
    bmHeight     : LONG,
    bmWidthBytes : LONG,
    bmPlanes     : u16,
    bmBitsPixel  : u16,
    bmBits       : LPVOID,
 };
 NPBITMAP :: ^struct {
    bmType       : LONG,
    bmWidth      : LONG,
    bmHeight     : LONG,
    bmWidthBytes : LONG,
    bmPlanes     : u16,
    bmBitsPixel  : u16,
    bmBits       : LPVOID,
 };
 LPBITMAP :: ^struct {
    bmType       : LONG,
    bmWidth      : LONG,
    bmHeight     : LONG,
    bmWidthBytes : LONG,
    bmPlanes     : u16,
    bmBitsPixel  : u16,
    bmBits       : LPVOID,
 };

 RGBTRIPLE :: struct {
    rgbtBlue  : BYTE,
    rgbtGreen : BYTE,
    rgbtRed   : BYTE,
 };
 PRGBTRIPLE :: ^struct {
    rgbtBlue  : BYTE,
    rgbtGreen : BYTE,
    rgbtRed   : BYTE,
 };
 NPRGBTRIPLE :: ^struct {
    rgbtBlue  : BYTE,
    rgbtGreen : BYTE,
    rgbtRed   : BYTE,
 };
 LPRGBTRIPLE :: ^struct {
    rgbtBlue  : BYTE,
    rgbtGreen : BYTE,
    rgbtRed   : BYTE,
 };

 RGBQUAD :: struct {
    rgbBlue     : BYTE,
    rgbGreen    : BYTE,
    rgbRed      : BYTE,
    rgbReserved : BYTE,
 };

 LPRGBQUAD :: ^RGBQUAD;

 LCSCSTYPE :: LONG;

 LCSGAMUTMATCH :: LONG;

 FXPT16DOT16 :: i64;
 LPFXPT16DOT16 :: ^i64;

 FXPT2DOT30 :: i64;
 LPFXPT2DOT30 :: ^i64;

 CIEXYZ :: struct {
    ciexyzX : FXPT2DOT30,
    ciexyzY : FXPT2DOT30,
    ciexyzZ : FXPT2DOT30,
 };

 LPCIEXYZ :: ^CIEXYZ;

 CIEXYZTRIPLE :: struct {
    ciexyzRed   : CIEXYZ,
    ciexyzGreen : CIEXYZ,
    ciexyzBlue  : CIEXYZ,
 };

 LPCIEXYZTRIPLE :: ^CIEXYZTRIPLE;

 LOGCOLORSPACEA :: struct {
    lcsSignature  : u32,
    lcsVersion    : u32,
    lcsSize       : u32,
    lcsCSType     : LCSCSTYPE,
    lcsIntent     : LCSGAMUTMATCH,
    lcsEndpoints  : CIEXYZTRIPLE,
    lcsGammaRed   : u32,
    lcsGammaGreen : u32,
    lcsGammaBlue  : u32,
    lcsFilename   : [260]CHAR,
 };
 LPLOGCOLORSPACEA :: ^struct {
    lcsSignature  : u32,
    lcsVersion    : u32,
    lcsSize       : u32,
    lcsCSType     : LCSCSTYPE,
    lcsIntent     : LCSGAMUTMATCH,
    lcsEndpoints  : CIEXYZTRIPLE,
    lcsGammaRed   : u32,
    lcsGammaGreen : u32,
    lcsGammaBlue  : u32,
    lcsFilename   : [260]CHAR,
 };

 LOGCOLORSPACEW :: struct {
    lcsSignature  : u32,
    lcsVersion    : u32,
    lcsSize       : u32,
    lcsCSType     : LCSCSTYPE,
    lcsIntent     : LCSGAMUTMATCH,
    lcsEndpoints  : CIEXYZTRIPLE,
    lcsGammaRed   : u32,
    lcsGammaGreen : u32,
    lcsGammaBlue  : u32,
    lcsFilename   : [260]WCHAR,
 };
 LPLOGCOLORSPACEW :: ^struct {
    lcsSignature  : u32,
    lcsVersion    : u32,
    lcsSize       : u32,
    lcsCSType     : LCSCSTYPE,
    lcsIntent     : LCSGAMUTMATCH,
    lcsEndpoints  : CIEXYZTRIPLE,
    lcsGammaRed   : u32,
    lcsGammaGreen : u32,
    lcsGammaBlue  : u32,
    lcsFilename   : [260]WCHAR,
 };

 LOGCOLORSPACE :: LOGCOLORSPACEA;

 LPLOGCOLORSPACE :: LPLOGCOLORSPACEA;

 BITMAPCOREHEADER :: struct {
    bcSize     : u32,
    bcWidth    : u16,
    bcHeight   : u16,
    bcPlanes   : u16,
    bcBitCount : u16,
 };
 LPBITMAPCOREHEADER :: ^struct {
    bcSize     : u32,
    bcWidth    : u16,
    bcHeight   : u16,
    bcPlanes   : u16,
    bcBitCount : u16,
 };
 PBITMAPCOREHEADER :: ^struct {
    bcSize     : u32,
    bcWidth    : u16,
    bcHeight   : u16,
    bcPlanes   : u16,
    bcBitCount : u16,
 };

 BITMAPINFOHEADER :: struct {
    biSize          : u32,
    biWidth         : LONG,
    biHeight        : LONG,
    biPlanes        : u16,
    biBitCount      : u16,
    biCompression   : u32,
    biSizeImage     : u32,
    biXPelsPerMeter : LONG,
    biYPelsPerMeter : LONG,
    biClrUsed       : u32,
    biClrImportant  : u32,
 };
 LPBITMAPINFOHEADER :: ^struct {
    biSize          : u32,
    biWidth         : LONG,
    biHeight        : LONG,
    biPlanes        : u16,
    biBitCount      : u16,
    biCompression   : u32,
    biSizeImage     : u32,
    biXPelsPerMeter : LONG,
    biYPelsPerMeter : LONG,
    biClrUsed       : u32,
    biClrImportant  : u32,
 };
 PBITMAPINFOHEADER :: ^struct {
    biSize          : u32,
    biWidth         : LONG,
    biHeight        : LONG,
    biPlanes        : u16,
    biBitCount      : u16,
    biCompression   : u32,
    biSizeImage     : u32,
    biXPelsPerMeter : LONG,
    biYPelsPerMeter : LONG,
    biClrUsed       : u32,
    biClrImportant  : u32,
 };

 BITMAPV4HEADER :: struct {
    bV4Size          : u32,
    bV4Width         : LONG,
    bV4Height        : LONG,
    bV4Planes        : u16,
    bV4BitCount      : u16,
    bV4V4Compression : u32,
    bV4SizeImage     : u32,
    bV4XPelsPerMeter : LONG,
    bV4YPelsPerMeter : LONG,
    bV4ClrUsed       : u32,
    bV4ClrImportant  : u32,
    bV4RedMask       : u32,
    bV4GreenMask     : u32,
    bV4BlueMask      : u32,
    bV4AlphaMask     : u32,
    bV4CSType        : u32,
    bV4Endpoints     : CIEXYZTRIPLE,
    bV4GammaRed      : u32,
    bV4GammaGreen    : u32,
    bV4GammaBlue     : u32,
 };
 LPBITMAPV4HEADER :: ^struct {
    bV4Size          : u32,
    bV4Width         : LONG,
    bV4Height        : LONG,
    bV4Planes        : u16,
    bV4BitCount      : u16,
    bV4V4Compression : u32,
    bV4SizeImage     : u32,
    bV4XPelsPerMeter : LONG,
    bV4YPelsPerMeter : LONG,
    bV4ClrUsed       : u32,
    bV4ClrImportant  : u32,
    bV4RedMask       : u32,
    bV4GreenMask     : u32,
    bV4BlueMask      : u32,
    bV4AlphaMask     : u32,
    bV4CSType        : u32,
    bV4Endpoints     : CIEXYZTRIPLE,
    bV4GammaRed      : u32,
    bV4GammaGreen    : u32,
    bV4GammaBlue     : u32,
 };
 PBITMAPV4HEADER :: ^struct {
    bV4Size          : u32,
    bV4Width         : LONG,
    bV4Height        : LONG,
    bV4Planes        : u16,
    bV4BitCount      : u16,
    bV4V4Compression : u32,
    bV4SizeImage     : u32,
    bV4XPelsPerMeter : LONG,
    bV4YPelsPerMeter : LONG,
    bV4ClrUsed       : u32,
    bV4ClrImportant  : u32,
    bV4RedMask       : u32,
    bV4GreenMask     : u32,
    bV4BlueMask      : u32,
    bV4AlphaMask     : u32,
    bV4CSType        : u32,
    bV4Endpoints     : CIEXYZTRIPLE,
    bV4GammaRed      : u32,
    bV4GammaGreen    : u32,
    bV4GammaBlue     : u32,
 };

 BITMAPV5HEADER :: struct {
    bV5Size          : u32,
    bV5Width         : LONG,
    bV5Height        : LONG,
    bV5Planes        : u16,
    bV5BitCount      : u16,
    bV5Compression   : u32,
    bV5SizeImage     : u32,
    bV5XPelsPerMeter : LONG,
    bV5YPelsPerMeter : LONG,
    bV5ClrUsed       : u32,
    bV5ClrImportant  : u32,
    bV5RedMask       : u32,
    bV5GreenMask     : u32,
    bV5BlueMask      : u32,
    bV5AlphaMask     : u32,
    bV5CSType        : u32,
    bV5Endpoints     : CIEXYZTRIPLE,
    bV5GammaRed      : u32,
    bV5GammaGreen    : u32,
    bV5GammaBlue     : u32,
    bV5Intent        : u32,
    bV5ProfileData   : u32,
    bV5ProfileSize   : u32,
    bV5Reserved      : u32,
 };
 LPBITMAPV5HEADER :: ^struct {
    bV5Size          : u32,
    bV5Width         : LONG,
    bV5Height        : LONG,
    bV5Planes        : u16,
    bV5BitCount      : u16,
    bV5Compression   : u32,
    bV5SizeImage     : u32,
    bV5XPelsPerMeter : LONG,
    bV5YPelsPerMeter : LONG,
    bV5ClrUsed       : u32,
    bV5ClrImportant  : u32,
    bV5RedMask       : u32,
    bV5GreenMask     : u32,
    bV5BlueMask      : u32,
    bV5AlphaMask     : u32,
    bV5CSType        : u32,
    bV5Endpoints     : CIEXYZTRIPLE,
    bV5GammaRed      : u32,
    bV5GammaGreen    : u32,
    bV5GammaBlue     : u32,
    bV5Intent        : u32,
    bV5ProfileData   : u32,
    bV5ProfileSize   : u32,
    bV5Reserved      : u32,
 };
 PBITMAPV5HEADER :: ^struct {
    bV5Size          : u32,
    bV5Width         : LONG,
    bV5Height        : LONG,
    bV5Planes        : u16,
    bV5BitCount      : u16,
    bV5Compression   : u32,
    bV5SizeImage     : u32,
    bV5XPelsPerMeter : LONG,
    bV5YPelsPerMeter : LONG,
    bV5ClrUsed       : u32,
    bV5ClrImportant  : u32,
    bV5RedMask       : u32,
    bV5GreenMask     : u32,
    bV5BlueMask      : u32,
    bV5AlphaMask     : u32,
    bV5CSType        : u32,
    bV5Endpoints     : CIEXYZTRIPLE,
    bV5GammaRed      : u32,
    bV5GammaGreen    : u32,
    bV5GammaBlue     : u32,
    bV5Intent        : u32,
    bV5ProfileData   : u32,
    bV5ProfileSize   : u32,
    bV5Reserved      : u32,
 };

 BITMAPINFO :: struct {
    bmiHeader : BITMAPINFOHEADER,
    bmiColors : [1]RGBQUAD,
 };
 LPBITMAPINFO :: ^struct {
    bmiHeader : BITMAPINFOHEADER,
    bmiColors : [1]RGBQUAD,
 };
 PBITMAPINFO :: ^struct {
    bmiHeader : BITMAPINFOHEADER,
    bmiColors : [1]RGBQUAD,
 };

 BITMAPCOREINFO :: struct {
    bmciHeader : BITMAPCOREHEADER,
    bmciColors : [1]RGBTRIPLE,
 };
 LPBITMAPCOREINFO :: ^struct {
    bmciHeader : BITMAPCOREHEADER,
    bmciColors : [1]RGBTRIPLE,
 };
 PBITMAPCOREINFO :: ^struct {
    bmciHeader : BITMAPCOREHEADER,
    bmciColors : [1]RGBTRIPLE,
 };

 BITMAPFILEHEADER :: struct {
    bfType      : u16,
    bfSize      : u32,
    bfReserved1 : u16,
    bfReserved2 : u16,
    bfOffBits   : u32,
 };
 LPBITMAPFILEHEADER :: ^struct {
    bfType      : u16,
    bfSize      : u32,
    bfReserved1 : u16,
    bfReserved2 : u16,
    bfOffBits   : u32,
 };
 PBITMAPFILEHEADER :: ^struct {
    bfType      : u16,
    bfSize      : u32,
    bfReserved1 : u16,
    bfReserved2 : u16,
    bfOffBits   : u32,
 };

 FONTSIGNATURE :: struct {
    fsUsb : [4]u32,
    fsCsb : [2]u32,
 };
 PFONTSIGNATURE :: ^struct {
    fsUsb : [4]u32,
    fsCsb : [2]u32,
 };
 LPFONTSIGNATURE :: ^struct {
    fsUsb : [4]u32,
    fsCsb : [2]u32,
 };

 CHARSETINFO :: struct {
    ciCharset : UINT,
    ciACP     : UINT,
    fs        : FONTSIGNATURE,
 };
 PCHARSETINFO :: ^struct {
    ciCharset : UINT,
    ciACP     : UINT,
    fs        : FONTSIGNATURE,
 };
 NPCHARSETINFO :: ^struct {
    ciCharset : UINT,
    ciACP     : UINT,
    fs        : FONTSIGNATURE,
 };
 LPCHARSETINFO :: ^struct {
    ciCharset : UINT,
    ciACP     : UINT,
    fs        : FONTSIGNATURE,
 };

 LOCALESIGNATURE :: struct {
    lsUsb          : [4]u32,
    lsCsbDefault   : [2]u32,
    lsCsbSupported : [2]u32,
 };
 PLOCALESIGNATURE :: ^struct {
    lsUsb          : [4]u32,
    lsCsbDefault   : [2]u32,
    lsCsbSupported : [2]u32,
 };
 LPLOCALESIGNATURE :: ^struct {
    lsUsb          : [4]u32,
    lsCsbDefault   : [2]u32,
    lsCsbSupported : [2]u32,
 };

 HANDLETABLE :: struct {
    objectHandle : [1]HGDIOBJ,
 };
 PHANDLETABLE :: ^struct {
    objectHandle : [1]HGDIOBJ,
 };
 LPHANDLETABLE :: ^struct {
    objectHandle : [1]HGDIOBJ,
 };

 METARECORD :: struct {
    rdSize     : u32,
    rdFunction : u16,
    rdParm     : [1]u16,
 };

 PMETARECORD :: ^METARECORD;

 LPMETARECORD :: ^METARECORD;

 METAFILEPICT :: struct {
    mm   : LONG,
    xExt : LONG,
    yExt : LONG,
    hMF  : HMETAFILE,
 };
 LPMETAFILEPICT :: ^struct {
    mm   : LONG,
    xExt : LONG,
    yExt : LONG,
    hMF  : HMETAFILE,
 };

 METAHEADER :: struct {
    mtType         : u16,
    mtHeaderSize   : u16,
    mtVersion      : u16,
    mtSize         : u32,
    mtNoObjects    : u16,
    mtMaxRecord    : u32,
    mtNoParameters : u16,
 };

 PMETAHEADER :: ^METAHEADER;

 LPMETAHEADER :: ^METAHEADER;

 ENHMETARECORD :: struct {
    iType : u32,
    nSize : u32,
    dParm : [1]u32,
 };
 PENHMETARECORD :: ^struct {
    iType : u32,
    nSize : u32,
    dParm : [1]u32,
 };
 LPENHMETARECORD :: ^struct {
    iType : u32,
    nSize : u32,
    dParm : [1]u32,
 };

 ENHMETAHEADER :: struct {
    iType          : u32,
    nSize          : u32,
    rclBounds      : RECTL,
    rclFrame       : RECTL,
    dSignature     : u32,
    nVersion       : u32,
    nBytes         : u32,
    nRecords       : u32,
    nHandles       : u16,
    sReserved      : u16,
    nDescription   : u32,
    offDescription : u32,
    nPalEntries    : u32,
    szlDevice      : SIZEL,
    szlMillimeters : SIZEL,
    cbPixelFormat  : u32,
    offPixelFormat : u32,
    bOpenGL        : u32,
    szlMicrometers : SIZEL,
 };
 PENHMETAHEADER :: ^struct {
    iType          : u32,
    nSize          : u32,
    rclBounds      : RECTL,
    rclFrame       : RECTL,
    dSignature     : u32,
    nVersion       : u32,
    nBytes         : u32,
    nRecords       : u32,
    nHandles       : u16,
    sReserved      : u16,
    nDescription   : u32,
    offDescription : u32,
    nPalEntries    : u32,
    szlDevice      : SIZEL,
    szlMillimeters : SIZEL,
    cbPixelFormat  : u32,
    offPixelFormat : u32,
    bOpenGL        : u32,
    szlMicrometers : SIZEL,
 };
 LPENHMETAHEADER :: ^struct {
    iType          : u32,
    nSize          : u32,
    rclBounds      : RECTL,
    rclFrame       : RECTL,
    dSignature     : u32,
    nVersion       : u32,
    nBytes         : u32,
    nRecords       : u32,
    nHandles       : u16,
    sReserved      : u16,
    nDescription   : u32,
    offDescription : u32,
    nPalEntries    : u32,
    szlDevice      : SIZEL,
    szlMillimeters : SIZEL,
    cbPixelFormat  : u32,
    offPixelFormat : u32,
    bOpenGL        : u32,
    szlMicrometers : SIZEL,
 };

 BCHAR :: BYTE;

 TEXTMETRICA :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };
 PTEXTMETRICA :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };
 NPTEXTMETRICA :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };
 LPTEXTMETRICA :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };

 TEXTMETRICW :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };
 PTEXTMETRICW :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };
 NPTEXTMETRICW :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };
 LPTEXTMETRICW :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
 };

 TEXTMETRIC :: TEXTMETRICA;

 PTEXTMETRIC :: PTEXTMETRICA;

 NPTEXTMETRIC :: NPTEXTMETRICA;

 LPTEXTMETRIC :: LPTEXTMETRICA;

 NEWTEXTMETRICA :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };
 PNEWTEXTMETRICA :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };
 NPNEWTEXTMETRICA :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };
 LPNEWTEXTMETRICA :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : BYTE,
    tmLastChar         : BYTE,
    tmDefaultChar      : BYTE,
    tmBreakChar        : BYTE,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };

 NEWTEXTMETRICW :: struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };
 PNEWTEXTMETRICW :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };
 NPNEWTEXTMETRICW :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };
 LPNEWTEXTMETRICW :: ^struct {
    tmHeight           : LONG,
    tmAscent           : LONG,
    tmDescent          : LONG,
    tmInternalLeading  : LONG,
    tmExternalLeading  : LONG,
    tmAveCharWidth     : LONG,
    tmMaxCharWidth     : LONG,
    tmWeight           : LONG,
    tmOverhang         : LONG,
    tmDigitizedAspectX : LONG,
    tmDigitizedAspectY : LONG,
    tmFirstChar        : WCHAR,
    tmLastChar         : WCHAR,
    tmDefaultChar      : WCHAR,
    tmBreakChar        : WCHAR,
    tmItalic           : BYTE,
    tmUnderlined       : BYTE,
    tmStruckOut        : BYTE,
    tmPitchAndFamily   : BYTE,
    tmCharSet          : BYTE,
    ntmFlags           : u32,
    ntmSizeEM          : UINT,
    ntmCellHeight      : UINT,
    ntmAvgWidth        : UINT,
 };

 NEWTEXTMETRIC :: NEWTEXTMETRICA;

 PNEWTEXTMETRIC :: PNEWTEXTMETRICA;

 NPNEWTEXTMETRIC :: NPNEWTEXTMETRICA;

 LPNEWTEXTMETRIC :: LPNEWTEXTMETRICA;

 NEWTEXTMETRICEXA :: struct {
    ntmTm      : NEWTEXTMETRICA,
    ntmFontSig : FONTSIGNATURE,
 };

 NEWTEXTMETRICEXW :: struct {
    ntmTm      : NEWTEXTMETRICW,
    ntmFontSig : FONTSIGNATURE,
 };

 NEWTEXTMETRICEX :: NEWTEXTMETRICEXA;

 PELARRAY :: struct {
    paXCount : LONG,
    paYCount : LONG,
    paXExt   : LONG,
    paYExt   : LONG,
    paRGBs   : BYTE,
 };
 PPELARRAY :: ^struct {
    paXCount : LONG,
    paYCount : LONG,
    paXExt   : LONG,
    paYExt   : LONG,
    paRGBs   : BYTE,
 };
 NPPELARRAY :: ^struct {
    paXCount : LONG,
    paYCount : LONG,
    paXExt   : LONG,
    paYExt   : LONG,
    paRGBs   : BYTE,
 };
 LPPELARRAY :: ^struct {
    paXCount : LONG,
    paYCount : LONG,
    paXExt   : LONG,
    paYExt   : LONG,
    paRGBs   : BYTE,
 };

 LOGBRUSH :: struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG_PTR,
 };
 PLOGBRUSH :: ^struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG_PTR,
 };
 NPLOGBRUSH :: ^struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG_PTR,
 };
 LPLOGBRUSH :: ^struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG_PTR,
 };

 LOGBRUSH32 :: struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG,
 };
 PLOGBRUSH32 :: ^struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG,
 };
 NPLOGBRUSH32 :: ^struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG,
 };
 LPLOGBRUSH32 :: ^struct {
    lbStyle : UINT,
    lbColor : COLORREF,
    lbHatch : ULONG,
 };

 PATTERN :: LOGBRUSH;

 PPATTERN :: ^PATTERN;

 NPPATTERN :: ^PATTERN;

 LPPATTERN :: ^PATTERN;

 LOGPEN :: struct {
    lopnStyle : UINT,
    lopnWidth : POINT,
    lopnColor : COLORREF,
 };
 PLOGPEN :: ^struct {
    lopnStyle : UINT,
    lopnWidth : POINT,
    lopnColor : COLORREF,
 };
 NPLOGPEN :: ^struct {
    lopnStyle : UINT,
    lopnWidth : POINT,
    lopnColor : COLORREF,
 };
 LPLOGPEN :: ^struct {
    lopnStyle : UINT,
    lopnWidth : POINT,
    lopnColor : COLORREF,
 };

 EXTLOGPEN :: struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG_PTR,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };
 PEXTLOGPEN :: ^struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG_PTR,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };
 NPEXTLOGPEN :: ^struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG_PTR,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };
 LPEXTLOGPEN :: ^struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG_PTR,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };

 EXTLOGPEN32 :: struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };
 PEXTLOGPEN32 :: ^struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };
 NPEXTLOGPEN32 :: ^struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };
 LPEXTLOGPEN32 :: ^struct {
    elpPenStyle   : u32,
    elpWidth      : u32,
    elpBrushStyle : UINT,
    elpColor      : COLORREF,
    elpHatch      : ULONG,
    elpNumEntries : u32,
    elpStyleEntry : [1]u32,
 };

 PALETTEENTRY :: struct {
    peRed   : BYTE,
    peGreen : BYTE,
    peBlue  : BYTE,
    peFlags : BYTE,
 };
 PPALETTEENTRY :: ^struct {
    peRed   : BYTE,
    peGreen : BYTE,
    peBlue  : BYTE,
    peFlags : BYTE,
 };
 LPPALETTEENTRY :: ^struct {
    peRed   : BYTE,
    peGreen : BYTE,
    peBlue  : BYTE,
    peFlags : BYTE,
 };

 LOGPALETTE :: struct {
    palVersion    : u16,
    palNumEntries : u16,
    palPalEntry   : [1]PALETTEENTRY,
 };
 PLOGPALETTE :: ^struct {
    palVersion    : u16,
    palNumEntries : u16,
    palPalEntry   : [1]PALETTEENTRY,
 };
 NPLOGPALETTE :: ^struct {
    palVersion    : u16,
    palNumEntries : u16,
    palPalEntry   : [1]PALETTEENTRY,
 };
 LPLOGPALETTE :: ^struct {
    palVersion    : u16,
    palNumEntries : u16,
    palPalEntry   : [1]PALETTEENTRY,
 };

 LOGFONTA :: struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]CHAR,
 };
 PLOGFONTA :: ^struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]CHAR,
 };
 NPLOGFONTA :: ^struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]CHAR,
 };
 LPLOGFONTA :: ^struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]CHAR,
 };

 LOGFONTW :: struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]WCHAR,
 };
 PLOGFONTW :: ^struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]WCHAR,
 };
 NPLOGFONTW :: ^struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]WCHAR,
 };
 LPLOGFONTW :: ^struct {
    lfHeight         : LONG,
    lfWidth          : LONG,
    lfEscapement     : LONG,
    lfOrientation    : LONG,
    lfWeight         : LONG,
    lfItalic         : BYTE,
    lfUnderline      : BYTE,
    lfStrikeOut      : BYTE,
    lfCharSet        : BYTE,
    lfOutPrecision   : BYTE,
    lfClipPrecision  : BYTE,
    lfQuality        : BYTE,
    lfPitchAndFamily : BYTE,
    lfFaceName       : [32]WCHAR,
 };

 LOGFONT :: LOGFONTA;

 PLOGFONT :: PLOGFONTA;

 NPLOGFONT :: NPLOGFONTA;

 LPLOGFONT :: LPLOGFONTA;

 ENUMLOGFONTA :: struct {
    elfLogFont  : LOGFONTA,
    elfFullName : [64]BYTE,
    elfStyle    : [32]BYTE,
 };
 LPENUMLOGFONTA :: ^struct {
    elfLogFont  : LOGFONTA,
    elfFullName : [64]BYTE,
    elfStyle    : [32]BYTE,
 };

 ENUMLOGFONTW :: struct {
    elfLogFont  : LOGFONTW,
    elfFullName : [64]WCHAR,
    elfStyle    : [32]WCHAR,
 };
 LPENUMLOGFONTW :: ^struct {
    elfLogFont  : LOGFONTW,
    elfFullName : [64]WCHAR,
    elfStyle    : [32]WCHAR,
 };

 ENUMLOGFONT :: ENUMLOGFONTA;

 LPENUMLOGFONT :: LPENUMLOGFONTA;

 ENUMLOGFONTEXA :: struct {
    elfLogFont  : LOGFONTA,
    elfFullName : [64]BYTE,
    elfStyle    : [32]BYTE,
    elfScript   : [32]BYTE,
 };
 LPENUMLOGFONTEXA :: ^struct {
    elfLogFont  : LOGFONTA,
    elfFullName : [64]BYTE,
    elfStyle    : [32]BYTE,
    elfScript   : [32]BYTE,
 };

 ENUMLOGFONTEXW :: struct {
    elfLogFont  : LOGFONTW,
    elfFullName : [64]WCHAR,
    elfStyle    : [32]WCHAR,
    elfScript   : [32]WCHAR,
 };
 LPENUMLOGFONTEXW :: ^struct {
    elfLogFont  : LOGFONTW,
    elfFullName : [64]WCHAR,
    elfStyle    : [32]WCHAR,
    elfScript   : [32]WCHAR,
 };

 ENUMLOGFONTEX :: ENUMLOGFONTEXA;

 LPENUMLOGFONTEX :: LPENUMLOGFONTEXA;

 PANOSE :: struct {
    bFamilyType      : BYTE,
    bSerifStyle      : BYTE,
    bWeight          : BYTE,
    bProportion      : BYTE,
    bContrast        : BYTE,
    bStrokeVariation : BYTE,
    bArmStyle        : BYTE,
    bLetterform      : BYTE,
    bMidline         : BYTE,
    bXHeight         : BYTE,
 };
 LPPANOSE :: ^struct {
    bFamilyType      : BYTE,
    bSerifStyle      : BYTE,
    bWeight          : BYTE,
    bProportion      : BYTE,
    bContrast        : BYTE,
    bStrokeVariation : BYTE,
    bArmStyle        : BYTE,
    bLetterform      : BYTE,
    bMidline         : BYTE,
    bXHeight         : BYTE,
 };

 EXTLOGFONTA :: struct {
    elfLogFont   : LOGFONTA,
    elfFullName  : [64]BYTE,
    elfStyle     : [32]BYTE,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };
 PEXTLOGFONTA :: ^struct {
    elfLogFont   : LOGFONTA,
    elfFullName  : [64]BYTE,
    elfStyle     : [32]BYTE,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };
 NPEXTLOGFONTA :: ^struct {
    elfLogFont   : LOGFONTA,
    elfFullName  : [64]BYTE,
    elfStyle     : [32]BYTE,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };
 LPEXTLOGFONTA :: ^struct {
    elfLogFont   : LOGFONTA,
    elfFullName  : [64]BYTE,
    elfStyle     : [32]BYTE,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };

 EXTLOGFONTW :: struct {
    elfLogFont   : LOGFONTW,
    elfFullName  : [64]WCHAR,
    elfStyle     : [32]WCHAR,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };
 PEXTLOGFONTW :: ^struct {
    elfLogFont   : LOGFONTW,
    elfFullName  : [64]WCHAR,
    elfStyle     : [32]WCHAR,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };
 NPEXTLOGFONTW :: ^struct {
    elfLogFont   : LOGFONTW,
    elfFullName  : [64]WCHAR,
    elfStyle     : [32]WCHAR,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };
 LPEXTLOGFONTW :: ^struct {
    elfLogFont   : LOGFONTW,
    elfFullName  : [64]WCHAR,
    elfStyle     : [32]WCHAR,
    elfVersion   : u32,
    elfStyleSize : u32,
    elfMatch     : u32,
    elfReserved  : u32,
    elfVendorId  : [4]BYTE,
    elfCulture   : u32,
    elfPanose    : PANOSE,
 };

 EXTLOGFONT :: EXTLOGFONTA;

 PEXTLOGFONT :: PEXTLOGFONTA;

 NPEXTLOGFONT :: NPEXTLOGFONTA;

 LPEXTLOGFONT :: LPEXTLOGFONTA;

 DEVMODEA :: struct {
    dmDeviceName       : [32]BYTE,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]BYTE,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };
 PDEVMODEA :: ^struct {
    dmDeviceName       : [32]BYTE,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]BYTE,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };
 NPDEVMODEA :: ^struct {
    dmDeviceName       : [32]BYTE,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]BYTE,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };
 LPDEVMODEA :: ^struct {
    dmDeviceName       : [32]BYTE,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]BYTE,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };

 DEVMODEW :: struct {
    dmDeviceName       : [32]WCHAR,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]WCHAR,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };
 PDEVMODEW :: ^struct {
    dmDeviceName       : [32]WCHAR,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]WCHAR,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };
 NPDEVMODEW :: ^struct {
    dmDeviceName       : [32]WCHAR,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]WCHAR,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };
 LPDEVMODEW :: ^struct {
    dmDeviceName       : [32]WCHAR,
    dmSpecVersion      : u16,
    dmDriverVersion    : u16,
    dmSize             : u16,
    dmDriverExtra      : u16,
    dmFields           : u32,
    u : struct #raw_union {
        s : struct {
            dmOrientation   : i16,
            dmPaperSize     : i16,
            dmPaperLength   : i16,
            dmPaperWidth    : i16,
            dmScale         : i16,
            dmCopies        : i16,
            dmDefaultSource : i16,
            dmPrintQuality  : i16,
        },
        s2 : struct {
            dmPosition           : POINTL,
            dmDisplayOrientation : u32,
            dmDisplayFixedOutput : u32,
        },
    },
    dmColor            : i16,
    dmDuplex           : i16,
    dmYResolution      : i16,
    dmTTOption         : i16,
    dmCollate          : i16,
    dmFormName         : [32]WCHAR,
    dmLogPixels        : u16,
    dmBitsPerPel       : u32,
    dmPelsWidth        : u32,
    dmPelsHeight       : u32,
    u2 : struct #raw_union {
        dmDisplayFlags : u32,
        dmNup          : u32,
    },
    dmDisplayFrequency : u32,
    dmICMMethod        : u32,
    dmICMIntent        : u32,
    dmMediaType        : u32,
    dmDitherType       : u32,
    dmReserved1        : u32,
    dmReserved2        : u32,
    dmPanningWidth     : u32,
    dmPanningHeight    : u32,
 };

 DEVMODE :: DEVMODEA;

 PDEVMODE :: PDEVMODEA;

 NPDEVMODE :: NPDEVMODEA;

 LPDEVMODE :: LPDEVMODEA;

 DISPLAY_DEVICEA :: struct {
    cb           : u32,
    DeviceName   : [32]CHAR,
    DeviceString : [128]CHAR,
    StateFlags   : u32,
    DeviceID     : [128]CHAR,
    DeviceKey    : [128]CHAR,
 };
 PDISPLAY_DEVICEA :: ^struct {
    cb           : u32,
    DeviceName   : [32]CHAR,
    DeviceString : [128]CHAR,
    StateFlags   : u32,
    DeviceID     : [128]CHAR,
    DeviceKey    : [128]CHAR,
 };
 LPDISPLAY_DEVICEA :: ^struct {
    cb           : u32,
    DeviceName   : [32]CHAR,
    DeviceString : [128]CHAR,
    StateFlags   : u32,
    DeviceID     : [128]CHAR,
    DeviceKey    : [128]CHAR,
 };

 DISPLAY_DEVICEW :: struct {
    cb           : u32,
    DeviceName   : [32]WCHAR,
    DeviceString : [128]WCHAR,
    StateFlags   : u32,
    DeviceID     : [128]WCHAR,
    DeviceKey    : [128]WCHAR,
 };
 PDISPLAY_DEVICEW :: ^struct {
    cb           : u32,
    DeviceName   : [32]WCHAR,
    DeviceString : [128]WCHAR,
    StateFlags   : u32,
    DeviceID     : [128]WCHAR,
    DeviceKey    : [128]WCHAR,
 };
 LPDISPLAY_DEVICEW :: ^struct {
    cb           : u32,
    DeviceName   : [32]WCHAR,
    DeviceString : [128]WCHAR,
    StateFlags   : u32,
    DeviceID     : [128]WCHAR,
    DeviceKey    : [128]WCHAR,
 };

 DISPLAY_DEVICE :: DISPLAY_DEVICEA;

 PDISPLAY_DEVICE :: PDISPLAY_DEVICEA;

 LPDISPLAY_DEVICE :: LPDISPLAY_DEVICEA;

 DISPLAYCONFIG_RATIONAL :: struct {
    Numerator   : UINT32,
    Denominator : UINT32,
 };

 DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY :: enum {
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = -1,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 = 0,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO = 1,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO = 2,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO = 3,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI = 4,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI = 5,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS = 6,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN = 8,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI = 9,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL = 10,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED = 11,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL = 12,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED = 13,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE = 14,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST = 15,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_WIRED = 16,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_VIRTUAL = 17,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = 0x80000000,
    DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_SCANLINE_ORDERING :: enum {
    DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED = 0,
    DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE = 1,
    DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED = 2,
    DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST =     DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED,
    DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST = 3,
    DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_2DREGION :: struct {
    cx : UINT32,
    cy : UINT32,
 };

 DISPLAYCONFIG_VIDEO_SIGNAL_INFO :: struct {
    pixelRate        : UINT64,
    hSyncFreq        : DISPLAYCONFIG_RATIONAL,
    vSyncFreq        : DISPLAYCONFIG_RATIONAL,
    activeSize       : DISPLAYCONFIG_2DREGION,
    totalSize        : DISPLAYCONFIG_2DREGION,
    u : struct #raw_union {
        AdditionalSignalInfo : struct {
            videoStandard    : ,
            vSyncFreqDivider : ,
            reserved         : ,
        },
        videoStandard        : UINT32,
    },
    scanLineOrdering : DISPLAYCONFIG_SCANLINE_ORDERING,
 };

 DISPLAYCONFIG_SCALING :: enum {
    DISPLAYCONFIG_SCALING_IDENTITY = 1,
    DISPLAYCONFIG_SCALING_CENTERED = 2,
    DISPLAYCONFIG_SCALING_STRETCHED = 3,
    DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
    DISPLAYCONFIG_SCALING_CUSTOM = 5,
    DISPLAYCONFIG_SCALING_PREFERRED = 128,
    DISPLAYCONFIG_SCALING_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_ROTATION :: enum {
    DISPLAYCONFIG_ROTATION_IDENTITY = 1,
    DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
    DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
    DISPLAYCONFIG_ROTATION_ROTATE270 = 4,
    DISPLAYCONFIG_ROTATION_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_MODE_INFO_TYPE :: enum {
    DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
    DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
    DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE = 3,
    DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_PIXELFORMAT :: enum {
    DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
    DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
    DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
    DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
    DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
    DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 = 0xffffffff,
 };

 DISPLAYCONFIG_SOURCE_MODE :: struct {
    width       : UINT32,
    height      : UINT32,
    pixelFormat : DISPLAYCONFIG_PIXELFORMAT,
    position    : POINTL,
 };

 DISPLAYCONFIG_TARGET_MODE :: struct {
    targetVideoSignalInfo : DISPLAYCONFIG_VIDEO_SIGNAL_INFO,
 };

 DISPLAYCONFIG_DESKTOP_IMAGE_INFO :: struct {
    PathSourceSize     : POINTL,
    DesktopImageRegion : RECTL,
    DesktopImageClip   : RECTL,
 };

 DISPLAYCONFIG_MODE_INFO :: struct {
    infoType  : DISPLAYCONFIG_MODE_INFO_TYPE,
    id        : UINT32,
    adapterId : LUID,
    u : struct #raw_union {
        targetMode       : DISPLAYCONFIG_TARGET_MODE,
        sourceMode       : DISPLAYCONFIG_SOURCE_MODE,
        desktopImageInfo : DISPLAYCONFIG_DESKTOP_IMAGE_INFO,
    },
 };

 DISPLAYCONFIG_PATH_SOURCE_INFO :: struct {
    adapterId   : LUID,
    id          : UINT32,
    u : struct #raw_union {
        modeInfoIdx : UINT32,
        s : struct {
            cloneGroupId      : ,
            sourceModeInfoIdx : ,
        },
    },
    statusFlags : UINT32,
 };

 DISPLAYCONFIG_PATH_TARGET_INFO :: struct {
    adapterId        : LUID,
    id               : UINT32,
    u : struct #raw_union {
        modeInfoIdx : UINT32,
        s : struct {
            desktopModeInfoIdx : ,
            targetModeInfoIdx  : ,
        },
    },
    outputTechnology : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
    rotation         : DISPLAYCONFIG_ROTATION,
    scaling          : DISPLAYCONFIG_SCALING,
    refreshRate      : DISPLAYCONFIG_RATIONAL,
    scanLineOrdering : DISPLAYCONFIG_SCANLINE_ORDERING,
    targetAvailable  : BOOL,
    statusFlags      : UINT32,
 };

 DISPLAYCONFIG_PATH_INFO :: struct {
    sourceInfo : DISPLAYCONFIG_PATH_SOURCE_INFO,
    targetInfo : DISPLAYCONFIG_PATH_TARGET_INFO,
    flags      : UINT32,
 };

 DISPLAYCONFIG_TOPOLOGY_ID :: enum {
    DISPLAYCONFIG_TOPOLOGY_INTERNAL = 0x00000001,
    DISPLAYCONFIG_TOPOLOGY_CLONE = 0x00000002,
    DISPLAYCONFIG_TOPOLOGY_EXTEND = 0x00000004,
    DISPLAYCONFIG_TOPOLOGY_EXTERNAL = 0x00000008,
    DISPLAYCONFIG_TOPOLOGY_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_DEVICE_INFO_TYPE :: enum {
    DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 1,
    DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 2,
    DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE = 3,
    DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME = 4,
    DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE = 5,
    DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE = 6,
    DISPLAYCONFIG_DEVICE_INFO_GET_SUPPORT_VIRTUAL_RESOLUTION = 7,
    DISPLAYCONFIG_DEVICE_INFO_SET_SUPPORT_VIRTUAL_RESOLUTION = 8,
    DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO = 9,
    DISPLAYCONFIG_DEVICE_INFO_SET_ADVANCED_COLOR_STATE = 10,
    DISPLAYCONFIG_DEVICE_INFO_GET_SDR_WHITE_LEVEL = 11,
    DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_DEVICE_INFO_HEADER :: struct {
    kind      : DISPLAYCONFIG_DEVICE_INFO_TYPE,
    size      : UINT32,
    adapterId : LUID,
    id        : UINT32,
 };

 DISPLAYCONFIG_SOURCE_DEVICE_NAME :: struct {
    header            : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    viewGdiDeviceName : [32]WCHAR,
 };

 DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS :: struct {
    u : struct #raw_union {
        s : struct {
            friendlyNameFromEdid : ,
            friendlyNameForced   : ,
            edidIdsValid         : ,
            reserved             : ,
        },
        value : UINT32,
    },
 };

 DISPLAYCONFIG_TARGET_DEVICE_NAME :: struct {
    header                    : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    flags                     : DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS,
    outputTechnology          : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
    edidManufactureId         : UINT16,
    edidProductCodeId         : UINT16,
    connectorInstance         : UINT32,
    monitorFriendlyDeviceName : [64]WCHAR,
    monitorDevicePath         : [128]WCHAR,
 };

 DISPLAYCONFIG_TARGET_PREFERRED_MODE :: struct {
    header     : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    width      : UINT32,
    height     : UINT32,
    targetMode : DISPLAYCONFIG_TARGET_MODE,
 };

 DISPLAYCONFIG_ADAPTER_NAME :: struct {
    header            : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    adapterDevicePath : [128]WCHAR,
 };

 DISPLAYCONFIG_TARGET_BASE_TYPE :: struct {
    header               : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    baseOutputTechnology : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY,
 };

 DISPLAYCONFIG_SET_TARGET_PERSISTENCE :: struct {
    header : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    u : struct #raw_union {
        s : struct {
            bootPersistenceOn : ,
            reserved          : ,
        },
        value : UINT32,
    },
 };

 DISPLAYCONFIG_SUPPORT_VIRTUAL_RESOLUTION :: struct {
    header : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    s : struct #raw_union {
        s : struct {
            disableMonitorVirtualResolution : ,
            reserved                        : ,
        },
        value : UINT32,
    },
 };

 DISPLAYCONFIG_COLOR_ENCODING :: enum {
    DISPLAYCONFIG_COLOR_ENCODING_RGB = 0,
    DISPLAYCONFIG_COLOR_ENCODING_YCBCR444 = 1,
    DISPLAYCONFIG_COLOR_ENCODING_YCBCR422 = 2,
    DISPLAYCONFIG_COLOR_ENCODING_YCBCR420 = 3,
    DISPLAYCONFIG_COLOR_ENCODING_INTENSITY = 4,
    DISPLAYCONFIG_COLOR_ENCODING_FORCE_UINT32 = 0xFFFFFFFF,
 };

 DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO :: struct {
    header              : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    u : struct #raw_union {
        s : struct {
            advancedColorSupported     : ,
            advancedColorEnabled       : ,
            wideColorEnforced          : ,
            advancedColorForceDisabled : ,
            reserved                   : ,
        },
        value : UINT32,
    },
    colorEncoding       : DISPLAYCONFIG_COLOR_ENCODING,
    bitsPerColorChannel : UINT32,
 };

 DISPLAYCONFIG_SET_ADVANCED_COLOR_STATE :: struct {
    header : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    u : struct #raw_union {
        s : struct {
            enableAdvancedColor : ,
            reserved            : ,
        },
        value : UINT32,
    },
 };

 DISPLAYCONFIG_SDR_WHITE_LEVEL :: struct {
    header        : DISPLAYCONFIG_DEVICE_INFO_HEADER,
    SDRWhiteLevel : ULONG,
 };

 RGNDATAHEADER :: struct {
    dwSize   : u32,
    iType    : u32,
    nCount   : u32,
    nRgnSize : u32,
    rcBound  : RECT,
 };
 PRGNDATAHEADER :: ^struct {
    dwSize   : u32,
    iType    : u32,
    nCount   : u32,
    nRgnSize : u32,
    rcBound  : RECT,
 };

 RGNDATA :: struct {
    rdh    : RGNDATAHEADER,
    Buffer : [1]u8,
 };
 PRGNDATA :: ^struct {
    rdh    : RGNDATAHEADER,
    Buffer : [1]u8,
 };
 NPRGNDATA :: ^struct {
    rdh    : RGNDATAHEADER,
    Buffer : [1]u8,
 };
 LPRGNDATA :: ^struct {
    rdh    : RGNDATAHEADER,
    Buffer : [1]u8,
 };

 ABC :: struct {
    abcA : i32,
    abcB : UINT,
    abcC : i32,
 };
 PABC :: ^struct {
    abcA : i32,
    abcB : UINT,
    abcC : i32,
 };
 NPABC :: ^struct {
    abcA : i32,
    abcB : UINT,
    abcC : i32,
 };
 LPABC :: ^struct {
    abcA : i32,
    abcB : UINT,
    abcC : i32,
 };

 ABCFLOAT :: struct {
    abcfA : FLOAT,
    abcfB : FLOAT,
    abcfC : FLOAT,
 };
 PABCFLOAT :: ^struct {
    abcfA : FLOAT,
    abcfB : FLOAT,
    abcfC : FLOAT,
 };
 NPABCFLOAT :: ^struct {
    abcfA : FLOAT,
    abcfB : FLOAT,
    abcfC : FLOAT,
 };
 LPABCFLOAT :: ^struct {
    abcfA : FLOAT,
    abcfB : FLOAT,
    abcfC : FLOAT,
 };

 OUTLINETEXTMETRICA :: struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICA,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };
 POUTLINETEXTMETRICA :: ^struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICA,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };
 NPOUTLINETEXTMETRICA :: ^struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICA,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };
 LPOUTLINETEXTMETRICA :: ^struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICA,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };

 OUTLINETEXTMETRICW :: struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICW,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };
 POUTLINETEXTMETRICW :: ^struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICW,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };
 NPOUTLINETEXTMETRICW :: ^struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICW,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };
 LPOUTLINETEXTMETRICW :: ^struct {
    otmSize                : UINT,
    otmTextMetrics         : TEXTMETRICW,
    otmFiller              : BYTE,
    otmPanoseNumber        : PANOSE,
    otmfsSelection         : UINT,
    otmfsType              : UINT,
    otmsCharSlopeRise      : i32,
    otmsCharSlopeRun       : i32,
    otmItalicAngle         : i32,
    otmEMSquare            : UINT,
    otmAscent              : i32,
    otmDescent             : i32,
    otmLineGap             : UINT,
    otmsCapEmHeight        : UINT,
    otmsXHeight            : UINT,
    otmrcFontBox           : RECT,
    otmMacAscent           : i32,
    otmMacDescent          : i32,
    otmMacLineGap          : UINT,
    otmusMinimumPPEM       : UINT,
    otmptSubscriptSize     : POINT,
    otmptSubscriptOffset   : POINT,
    otmptSuperscriptSize   : POINT,
    otmptSuperscriptOffset : POINT,
    otmsStrikeoutSize      : UINT,
    otmsStrikeoutPosition  : i32,
    otmsUnderscoreSize     : i32,
    otmsUnderscorePosition : i32,
    otmpFamilyName         : PSTR,
    otmpFaceName           : PSTR,
    otmpStyleName          : PSTR,
    otmpFullName           : PSTR,
 };

 OUTLINETEXTMETRIC :: OUTLINETEXTMETRICA;

 POUTLINETEXTMETRIC :: POUTLINETEXTMETRICA;

 NPOUTLINETEXTMETRIC :: NPOUTLINETEXTMETRICA;

 LPOUTLINETEXTMETRIC :: LPOUTLINETEXTMETRICA;

 POLYTEXTA :: struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };
 PPOLYTEXTA :: ^struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };
 NPPOLYTEXTA :: ^struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };
 LPPOLYTEXTA :: ^struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };

 POLYTEXTW :: struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCWSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };
 PPOLYTEXTW :: ^struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCWSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };
 NPPOLYTEXTW :: ^struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCWSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };
 LPPOLYTEXTW :: ^struct {
    x       : i32,
    y       : i32,
    n       : UINT,
    lpstr   : LPCWSTR,
    uiFlags : UINT,
    rcl     : RECT,
    pdx     : ^i32,
 };

 POLYTEXT :: POLYTEXTA;

 PPOLYTEXT :: PPOLYTEXTA;

 NPPOLYTEXT :: NPPOLYTEXTA;

 LPPOLYTEXT :: LPPOLYTEXTA;

 FIXED :: struct {
    fract : u16,
    value : i16,
 };

 MAT2 :: struct {
    eM11 : FIXED,
    eM12 : FIXED,
    eM21 : FIXED,
    eM22 : FIXED,
 };
 LPMAT2 :: ^struct {
    eM11 : FIXED,
    eM12 : FIXED,
    eM21 : FIXED,
    eM22 : FIXED,
 };

 GLYPHMETRICS :: struct {
    gmBlackBoxX     : UINT,
    gmBlackBoxY     : UINT,
    gmptGlyphOrigin : POINT,
    gmCellIncX      : i16,
    gmCellIncY      : i16,
 };
 LPGLYPHMETRICS :: ^struct {
    gmBlackBoxX     : UINT,
    gmBlackBoxY     : UINT,
    gmptGlyphOrigin : POINT,
    gmCellIncX      : i16,
    gmCellIncY      : i16,
 };

 POINTFX :: struct {
    x : FIXED,
    y : FIXED,
 };
 LPPOINTFX :: ^struct {
    x : FIXED,
    y : FIXED,
 };

 TTPOLYCURVE :: struct {
    wType : u16,
    cpfx  : u16,
    apfx  : [1]POINTFX,
 };
 LPTTPOLYCURVE :: ^struct {
    wType : u16,
    cpfx  : u16,
    apfx  : [1]POINTFX,
 };

 TTPOLYGONHEADER :: struct {
    cb       : u32,
    dwType   : u32,
    pfxStart : POINTFX,
 };
 LPTTPOLYGONHEADER :: ^struct {
    cb       : u32,
    dwType   : u32,
    pfxStart : POINTFX,
 };

 GCP_RESULTSA :: struct {
    lStructSize : u32,
    lpOutString : LPSTR,
    lpOrder     : ^UINT,
    lpDx        : ^i32,
    lpCaretPos  : ^i32,
    lpClass     : LPSTR,
    lpGlyphs    : LPWSTR,
    nGlyphs     : UINT,
    nMaxFit     : i32,
 };
 LPGCP_RESULTSA :: ^struct {
    lStructSize : u32,
    lpOutString : LPSTR,
    lpOrder     : ^UINT,
    lpDx        : ^i32,
    lpCaretPos  : ^i32,
    lpClass     : LPSTR,
    lpGlyphs    : LPWSTR,
    nGlyphs     : UINT,
    nMaxFit     : i32,
 };

 GCP_RESULTSW :: struct {
    lStructSize : u32,
    lpOutString : LPWSTR,
    lpOrder     : ^UINT,
    lpDx        : ^i32,
    lpCaretPos  : ^i32,
    lpClass     : LPSTR,
    lpGlyphs    : LPWSTR,
    nGlyphs     : UINT,
    nMaxFit     : i32,
 };
 LPGCP_RESULTSW :: ^struct {
    lStructSize : u32,
    lpOutString : LPWSTR,
    lpOrder     : ^UINT,
    lpDx        : ^i32,
    lpCaretPos  : ^i32,
    lpClass     : LPSTR,
    lpGlyphs    : LPWSTR,
    nGlyphs     : UINT,
    nMaxFit     : i32,
 };

 GCP_RESULTS :: GCP_RESULTSA;

 LPGCP_RESULTS :: LPGCP_RESULTSA;

 RASTERIZER_STATUS :: struct {
    nSize       : i16,
    wFlags      : i16,
    nLanguageID : i16,
 };
 LPRASTERIZER_STATUS :: ^struct {
    nSize       : i16,
    wFlags      : i16,
    nLanguageID : i16,
 };

 PIXELFORMATDESCRIPTOR :: struct {
    nSize           : u16,
    nVersion        : u16,
    dwFlags         : u32,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerType      : BYTE,
    bReserved       : BYTE,
    dwLayerMask     : u32,
    dwVisibleMask   : u32,
    dwDamageMask    : u32,
 };
 PPIXELFORMATDESCRIPTOR :: ^struct {
    nSize           : u16,
    nVersion        : u16,
    dwFlags         : u32,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerType      : BYTE,
    bReserved       : BYTE,
    dwLayerMask     : u32,
    dwVisibleMask   : u32,
    dwDamageMask    : u32,
 };
 LPPIXELFORMATDESCRIPTOR :: ^struct {
    nSize           : u16,
    nVersion        : u16,
    dwFlags         : u32,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerType      : BYTE,
    bReserved       : BYTE,
    dwLayerMask     : u32,
    dwVisibleMask   : u32,
    dwDamageMask    : u32,
 };

 OLDFONTENUMPROCA :: (proc(^LOGFONTA, ^TEXTMETRICA, u32, LPARAM) -> i32);

 OLDFONTENUMPROCW :: (proc(^LOGFONTW, ^TEXTMETRICW, u32, LPARAM) -> i32);

 FONTENUMPROCA :: OLDFONTENUMPROCA;

 FONTENUMPROCW :: OLDFONTENUMPROCW;

 FONTENUMPROC :: FONTENUMPROCA;

 GOBJENUMPROC :: (proc(LPVOID, LPARAM) -> i32);

 LINEDDAPROC :: proc(i32, i32, LPARAM);

 LPFNDEVMODE :: (proc(HWND, HMODULE, LPDEVMODE, LPSTR, LPSTR, LPDEVMODE, LPSTR, UINT) -> UINT);

 LPFNDEVCAPS :: (proc(LPSTR, LPSTR, UINT, LPSTR, LPDEVMODE) -> u32);

 WCRANGE :: struct {
    wcLow   : WCHAR,
    cGlyphs : USHORT,
 };
 PWCRANGE :: ^struct {
    wcLow   : WCHAR,
    cGlyphs : USHORT,
 };
 LPWCRANGE :: ^struct {
    wcLow   : WCHAR,
    cGlyphs : USHORT,
 };

 GLYPHSET :: struct {
    cbThis           : u32,
    flAccel          : u32,
    cGlyphsSupported : u32,
    cRanges          : u32,
    ranges           : [1]WCRANGE,
 };
 PGLYPHSET :: ^struct {
    cbThis           : u32,
    flAccel          : u32,
    cGlyphsSupported : u32,
    cRanges          : u32,
    ranges           : [1]WCRANGE,
 };
 LPGLYPHSET :: ^struct {
    cbThis           : u32,
    flAccel          : u32,
    cGlyphsSupported : u32,
    cRanges          : u32,
    ranges           : [1]WCRANGE,
 };

 DESIGNVECTOR :: struct {
    dvReserved : u32,
    dvNumAxes  : u32,
    dvValues   : [16]LONG,
 };
 PDESIGNVECTOR :: ^struct {
    dvReserved : u32,
    dvNumAxes  : u32,
    dvValues   : [16]LONG,
 };
 LPDESIGNVECTOR :: ^struct {
    dvReserved : u32,
    dvNumAxes  : u32,
    dvValues   : [16]LONG,
 };

 AXISINFOA :: struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]BYTE,
 };
 PAXISINFOA :: ^struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]BYTE,
 };
 LPAXISINFOA :: ^struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]BYTE,
 };

 AXISINFOW :: struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]WCHAR,
 };
 PAXISINFOW :: ^struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]WCHAR,
 };
 LPAXISINFOW :: ^struct {
    axMinValue : LONG,
    axMaxValue : LONG,
    axAxisName : [16]WCHAR,
 };

 AXISINFO :: AXISINFOA;

 PAXISINFO :: PAXISINFOA;

 LPAXISINFO :: LPAXISINFOA;

 AXESLISTA :: struct {
    axlReserved : u32,
    axlNumAxes  : u32,
    axlAxisInfo : [16]AXISINFOA,
 };
 PAXESLISTA :: ^struct {
    axlReserved : u32,
    axlNumAxes  : u32,
    axlAxisInfo : [16]AXISINFOA,
 };
 LPAXESLISTA :: ^struct {
    axlReserved : u32,
    axlNumAxes  : u32,
    axlAxisInfo : [16]AXISINFOA,
 };

 AXESLISTW :: struct {
    axlReserved : u32,
    axlNumAxes  : u32,
    axlAxisInfo : [16]AXISINFOW,
 };
 PAXESLISTW :: ^struct {
    axlReserved : u32,
    axlNumAxes  : u32,
    axlAxisInfo : [16]AXISINFOW,
 };
 LPAXESLISTW :: ^struct {
    axlReserved : u32,
    axlNumAxes  : u32,
    axlAxisInfo : [16]AXISINFOW,
 };

 AXESLIST :: AXESLISTA;

 PAXESLIST :: PAXESLISTA;

 LPAXESLIST :: LPAXESLISTA;

 ENUMLOGFONTEXDVA :: struct {
    elfEnumLogfontEx : ENUMLOGFONTEXA,
    elfDesignVector  : DESIGNVECTOR,
 };
 PENUMLOGFONTEXDVA :: ^struct {
    elfEnumLogfontEx : ENUMLOGFONTEXA,
    elfDesignVector  : DESIGNVECTOR,
 };
 LPENUMLOGFONTEXDVA :: ^struct {
    elfEnumLogfontEx : ENUMLOGFONTEXA,
    elfDesignVector  : DESIGNVECTOR,
 };

 ENUMLOGFONTEXDVW :: struct {
    elfEnumLogfontEx : ENUMLOGFONTEXW,
    elfDesignVector  : DESIGNVECTOR,
 };
 PENUMLOGFONTEXDVW :: ^struct {
    elfEnumLogfontEx : ENUMLOGFONTEXW,
    elfDesignVector  : DESIGNVECTOR,
 };
 LPENUMLOGFONTEXDVW :: ^struct {
    elfEnumLogfontEx : ENUMLOGFONTEXW,
    elfDesignVector  : DESIGNVECTOR,
 };

 ENUMLOGFONTEXDV :: ENUMLOGFONTEXDVA;

 PENUMLOGFONTEXDV :: PENUMLOGFONTEXDVA;

 LPENUMLOGFONTEXDV :: LPENUMLOGFONTEXDVA;

 ENUMTEXTMETRICA :: struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXA,
    etmAxesList        : AXESLISTA,
 };
 PENUMTEXTMETRICA :: ^struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXA,
    etmAxesList        : AXESLISTA,
 };
 LPENUMTEXTMETRICA :: ^struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXA,
    etmAxesList        : AXESLISTA,
 };

 ENUMTEXTMETRICW :: struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXW,
    etmAxesList        : AXESLISTW,
 };
 PENUMTEXTMETRICW :: ^struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXW,
    etmAxesList        : AXESLISTW,
 };
 LPENUMTEXTMETRICW :: ^struct {
    etmNewTextMetricEx : NEWTEXTMETRICEXW,
    etmAxesList        : AXESLISTW,
 };

 ENUMTEXTMETRIC :: ENUMTEXTMETRICA;

 PENUMTEXTMETRIC :: PENUMTEXTMETRICA;

 LPENUMTEXTMETRIC :: LPENUMTEXTMETRICA;

 COLOR16 :: USHORT;

 TRIVERTEX :: struct {
    x     : LONG,
    y     : LONG,
    Red   : COLOR16,
    Green : COLOR16,
    Blue  : COLOR16,
    Alpha : COLOR16,
 };
 PTRIVERTEX :: ^struct {
    x     : LONG,
    y     : LONG,
    Red   : COLOR16,
    Green : COLOR16,
    Blue  : COLOR16,
    Alpha : COLOR16,
 };
 LPTRIVERTEX :: ^struct {
    x     : LONG,
    y     : LONG,
    Red   : COLOR16,
    Green : COLOR16,
    Blue  : COLOR16,
    Alpha : COLOR16,
 };

 GRADIENT_TRIANGLE :: struct {
    Vertex1 : ULONG,
    Vertex2 : ULONG,
    Vertex3 : ULONG,
 };
 PGRADIENT_TRIANGLE :: ^struct {
    Vertex1 : ULONG,
    Vertex2 : ULONG,
    Vertex3 : ULONG,
 };
 LPGRADIENT_TRIANGLE :: ^struct {
    Vertex1 : ULONG,
    Vertex2 : ULONG,
    Vertex3 : ULONG,
 };

 GRADIENT_RECT :: struct {
    UpperLeft  : ULONG,
    LowerRight : ULONG,
 };
 PGRADIENT_RECT :: ^struct {
    UpperLeft  : ULONG,
    LowerRight : ULONG,
 };
 LPGRADIENT_RECT :: ^struct {
    UpperLeft  : ULONG,
    LowerRight : ULONG,
 };

 BLENDFUNCTION :: struct {
    BlendOp             : BYTE,
    BlendFlags          : BYTE,
    SourceConstantAlpha : BYTE,
    AlphaFormat         : BYTE,
 };
 PBLENDFUNCTION :: ^struct {
    BlendOp             : BYTE,
    BlendFlags          : BYTE,
    SourceConstantAlpha : BYTE,
    AlphaFormat         : BYTE,
 };

 MFENUMPROC :: (proc(hdc : HDC, lpht : ^HANDLETABLE, lpMR : ^METARECORD, nObj : i32, param : LPARAM) -> i32);

 ENHMFENUMPROC :: (proc(hdc : HDC, lpht : ^HANDLETABLE, lpmr : ^ENHMETARECORD, nHandles : i32, data : LPARAM) -> i32);

 DIBSECTION :: struct {
    dsBm        : BITMAP,
    dsBmih      : BITMAPINFOHEADER,
    dsBitfields : [3]u32,
    dshSection  : HANDLE,
    dsOffset    : u32,
 };
 LPDIBSECTION :: ^struct {
    dsBm        : BITMAP,
    dsBmih      : BITMAPINFOHEADER,
    dsBitfields : [3]u32,
    dshSection  : HANDLE,
    dsOffset    : u32,
 };
 PDIBSECTION :: ^struct {
    dsBm        : BITMAP,
    dsBmih      : BITMAPINFOHEADER,
    dsBitfields : [3]u32,
    dshSection  : HANDLE,
    dsOffset    : u32,
 };

 COLORADJUSTMENT :: struct {
    caSize            : u16,
    caFlags           : u16,
    caIlluminantIndex : u16,
    caRedGamma        : u16,
    caGreenGamma      : u16,
    caBlueGamma       : u16,
    caReferenceBlack  : u16,
    caReferenceWhite  : u16,
    caContrast        : SHORT,
    caBrightness      : SHORT,
    caColorfulness    : SHORT,
    caRedGreenTint    : SHORT,
 };
 PCOLORADJUSTMENT :: ^struct {
    caSize            : u16,
    caFlags           : u16,
    caIlluminantIndex : u16,
    caRedGamma        : u16,
    caGreenGamma      : u16,
    caBlueGamma       : u16,
    caReferenceBlack  : u16,
    caReferenceWhite  : u16,
    caContrast        : SHORT,
    caBrightness      : SHORT,
    caColorfulness    : SHORT,
    caRedGreenTint    : SHORT,
 };
 LPCOLORADJUSTMENT :: ^struct {
    caSize            : u16,
    caFlags           : u16,
    caIlluminantIndex : u16,
    caRedGamma        : u16,
    caGreenGamma      : u16,
    caBlueGamma       : u16,
    caReferenceBlack  : u16,
    caReferenceWhite  : u16,
    caContrast        : SHORT,
    caBrightness      : SHORT,
    caColorfulness    : SHORT,
    caRedGreenTint    : SHORT,
 };

 ABORTPROC :: (proc(HDC, i32) -> BOOL);

 DOCINFOA :: struct {
    cbSize       : i32,
    lpszDocName  : LPCSTR,
    lpszOutput   : LPCSTR,
    lpszDatatype : LPCSTR,
    fwType       : u32,
 };
 LPDOCINFOA :: ^struct {
    cbSize       : i32,
    lpszDocName  : LPCSTR,
    lpszOutput   : LPCSTR,
    lpszDatatype : LPCSTR,
    fwType       : u32,
 };

 DOCINFOW :: struct {
    cbSize       : i32,
    lpszDocName  : LPCWSTR,
    lpszOutput   : LPCWSTR,
    lpszDatatype : LPCWSTR,
    fwType       : u32,
 };
 LPDOCINFOW :: ^struct {
    cbSize       : i32,
    lpszDocName  : LPCWSTR,
    lpszOutput   : LPCWSTR,
    lpszDatatype : LPCWSTR,
    fwType       : u32,
 };

 DOCINFO :: DOCINFOA;

 LPDOCINFO :: LPDOCINFOA;

 KERNINGPAIR :: struct {
    wFirst      : u16,
    wSecond     : u16,
    iKernAmount : i32,
 };
 LPKERNINGPAIR :: ^struct {
    wFirst      : u16,
    wSecond     : u16,
    iKernAmount : i32,
 };

 ICMENUMPROCA :: (proc(LPSTR, LPARAM) -> i32);

 ICMENUMPROCW :: (proc(LPWSTR, LPARAM) -> i32);

 EMR :: struct {
    iType : u32,
    nSize : u32,
 };
 PEMR :: ^struct {
    iType : u32,
    nSize : u32,
 };

 EMRTEXT :: struct {
    ptlReference : POINTL,
    nChars       : u32,
    offString    : u32,
    fOptions     : u32,
    rcl          : RECTL,
    offDx        : u32,
 };
 PEMRTEXT :: ^struct {
    ptlReference : POINTL,
    nChars       : u32,
    offString    : u32,
    fOptions     : u32,
    rcl          : RECTL,
    offDx        : u32,
 };

 EMRABORTPATH :: struct {
    emr : EMR,
 };
 PEMRABORTPATH :: ^struct {
    emr : EMR,
 };
 EMRBEGINPATH :: struct {
    emr : EMR,
 };
 PEMRBEGINPATH :: ^struct {
    emr : EMR,
 };
 EMRENDPATH :: struct {
    emr : EMR,
 };
 PEMRENDPATH :: ^struct {
    emr : EMR,
 };
 EMRCLOSEFIGURE :: struct {
    emr : EMR,
 };
 PEMRCLOSEFIGURE :: ^struct {
    emr : EMR,
 };
 EMRFLATTENPATH :: struct {
    emr : EMR,
 };
 PEMRFLATTENPATH :: ^struct {
    emr : EMR,
 };
 EMRWIDENPATH :: struct {
    emr : EMR,
 };
 PEMRWIDENPATH :: ^struct {
    emr : EMR,
 };
 EMRSETMETARGN :: struct {
    emr : EMR,
 };
 PEMRSETMETARGN :: ^struct {
    emr : EMR,
 };
 EMRSAVEDC :: struct {
    emr : EMR,
 };
 PEMRSAVEDC :: ^struct {
    emr : EMR,
 };
 EMRREALIZEPALETTE :: struct {
    emr : EMR,
 };
 PEMRREALIZEPALETTE :: ^struct {
    emr : EMR,
 };

 EMRSELECTCLIPPATH :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSELECTCLIPPATH :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETBKMODE :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETBKMODE :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETMAPMODE :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETMAPMODE :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETLAYOUT :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETLAYOUT :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETPOLYFILLMODE :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETPOLYFILLMODE :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETROP2 :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETROP2 :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETSTRETCHBLTMODE :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETSTRETCHBLTMODE :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETICMMODE :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETICMMODE :: ^struct {
    emr   : EMR,
    iMode : u32,
 };
 EMRSETTEXTALIGN :: struct {
    emr   : EMR,
    iMode : u32,
 };
 PEMRSETTEXTALIGN :: ^struct {
    emr   : EMR,
    iMode : u32,
 };

 EMRSETMITERLIMIT :: struct {
    emr         : EMR,
    eMiterLimit : FLOAT,
 };
 PEMRSETMITERLIMIT :: ^struct {
    emr         : EMR,
    eMiterLimit : FLOAT,
 };

 EMRRESTOREDC :: struct {
    emr       : EMR,
    iRelative : LONG,
 };
 PEMRRESTOREDC :: ^struct {
    emr       : EMR,
    iRelative : LONG,
 };

 EMRSETARCDIRECTION :: struct {
    emr           : EMR,
    iArcDirection : u32,
 };
 PEMRSETARCDIRECTION :: ^struct {
    emr           : EMR,
    iArcDirection : u32,
 };

 EMRSETMAPPERFLAGS :: struct {
    emr     : EMR,
    dwFlags : u32,
 };
 PEMRSETMAPPERFLAGS :: ^struct {
    emr     : EMR,
    dwFlags : u32,
 };

 EMRSETBKCOLOR :: struct {
    emr     : EMR,
    crColor : COLORREF,
 };
 PEMRSETBKCOLOR :: ^struct {
    emr     : EMR,
    crColor : COLORREF,
 };
 EMRSETTEXTCOLOR :: struct {
    emr     : EMR,
    crColor : COLORREF,
 };
 PEMRSETTEXTCOLOR :: ^struct {
    emr     : EMR,
    crColor : COLORREF,
 };

 EMRSELECTOBJECT :: struct {
    emr      : EMR,
    ihObject : u32,
 };
 PEMRSELECTOBJECT :: ^struct {
    emr      : EMR,
    ihObject : u32,
 };
 EMRDELETEOBJECT :: struct {
    emr      : EMR,
    ihObject : u32,
 };
 PEMRDELETEOBJECT :: ^struct {
    emr      : EMR,
    ihObject : u32,
 };

 EMRSELECTPALETTE :: struct {
    emr   : EMR,
    ihPal : u32,
 };
 PEMRSELECTPALETTE :: ^struct {
    emr   : EMR,
    ihPal : u32,
 };

 EMRRESIZEPALETTE :: struct {
    emr      : EMR,
    ihPal    : u32,
    cEntries : u32,
 };
 PEMRRESIZEPALETTE :: ^struct {
    emr      : EMR,
    ihPal    : u32,
    cEntries : u32,
 };

 EMRSETPALETTEENTRIES :: struct {
    emr         : EMR,
    ihPal       : u32,
    iStart      : u32,
    cEntries    : u32,
    aPalEntries : [1]PALETTEENTRY,
 };
 PEMRSETPALETTEENTRIES :: ^struct {
    emr         : EMR,
    ihPal       : u32,
    iStart      : u32,
    cEntries    : u32,
    aPalEntries : [1]PALETTEENTRY,
 };

 EMRSETCOLORADJUSTMENT :: struct {
    emr             : EMR,
    ColorAdjustment : COLORADJUSTMENT,
 };
 PEMRSETCOLORADJUSTMENT :: ^struct {
    emr             : EMR,
    ColorAdjustment : COLORADJUSTMENT,
 };

 EMRGDICOMMENT :: struct {
    emr    : EMR,
    cbData : u32,
    Data   : [1]BYTE,
 };
 PEMRGDICOMMENT :: ^struct {
    emr    : EMR,
    cbData : u32,
    Data   : [1]BYTE,
 };

 EMREOF :: struct {
    emr           : EMR,
    nPalEntries   : u32,
    offPalEntries : u32,
    nSizeLast     : u32,
 };
 PEMREOF :: ^struct {
    emr           : EMR,
    nPalEntries   : u32,
    offPalEntries : u32,
    nSizeLast     : u32,
 };

 EMRLINETO :: struct {
    emr : EMR,
    ptl : POINTL,
 };
 PEMRLINETO :: ^struct {
    emr : EMR,
    ptl : POINTL,
 };
 EMRMOVETOEX :: struct {
    emr : EMR,
    ptl : POINTL,
 };
 PEMRMOVETOEX :: ^struct {
    emr : EMR,
    ptl : POINTL,
 };

 EMROFFSETCLIPRGN :: struct {
    emr       : EMR,
    ptlOffset : POINTL,
 };
 PEMROFFSETCLIPRGN :: ^struct {
    emr       : EMR,
    ptlOffset : POINTL,
 };

 EMRFILLPATH :: struct {
    emr       : EMR,
    rclBounds : RECTL,
 };
 PEMRFILLPATH :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
 };
 EMRSTROKEANDFILLPATH :: struct {
    emr       : EMR,
    rclBounds : RECTL,
 };
 PEMRSTROKEANDFILLPATH :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
 };
 EMRSTROKEPATH :: struct {
    emr       : EMR,
    rclBounds : RECTL,
 };
 PEMRSTROKEPATH :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
 };

 EMREXCLUDECLIPRECT :: struct {
    emr     : EMR,
    rclClip : RECTL,
 };
 PEMREXCLUDECLIPRECT :: ^struct {
    emr     : EMR,
    rclClip : RECTL,
 };
 EMRINTERSECTCLIPRECT :: struct {
    emr     : EMR,
    rclClip : RECTL,
 };
 PEMRINTERSECTCLIPRECT :: ^struct {
    emr     : EMR,
    rclClip : RECTL,
 };

 EMRSETVIEWPORTORGEX :: struct {
    emr       : EMR,
    ptlOrigin : POINTL,
 };
 PEMRSETVIEWPORTORGEX :: ^struct {
    emr       : EMR,
    ptlOrigin : POINTL,
 };
 EMRSETWINDOWORGEX :: struct {
    emr       : EMR,
    ptlOrigin : POINTL,
 };
 PEMRSETWINDOWORGEX :: ^struct {
    emr       : EMR,
    ptlOrigin : POINTL,
 };
 EMRSETBRUSHORGEX :: struct {
    emr       : EMR,
    ptlOrigin : POINTL,
 };
 PEMRSETBRUSHORGEX :: ^struct {
    emr       : EMR,
    ptlOrigin : POINTL,
 };

 EMRSETVIEWPORTEXTEX :: struct {
    emr       : EMR,
    szlExtent : SIZEL,
 };
 PEMRSETVIEWPORTEXTEX :: ^struct {
    emr       : EMR,
    szlExtent : SIZEL,
 };
 EMRSETWINDOWEXTEX :: struct {
    emr       : EMR,
    szlExtent : SIZEL,
 };
 PEMRSETWINDOWEXTEX :: ^struct {
    emr       : EMR,
    szlExtent : SIZEL,
 };

 EMRSCALEVIEWPORTEXTEX :: struct {
    emr    : EMR,
    xNum   : LONG,
    xDenom : LONG,
    yNum   : LONG,
    yDenom : LONG,
 };
 PEMRSCALEVIEWPORTEXTEX :: ^struct {
    emr    : EMR,
    xNum   : LONG,
    xDenom : LONG,
    yNum   : LONG,
    yDenom : LONG,
 };
 EMRSCALEWINDOWEXTEX :: struct {
    emr    : EMR,
    xNum   : LONG,
    xDenom : LONG,
    yNum   : LONG,
    yDenom : LONG,
 };
 PEMRSCALEWINDOWEXTEX :: ^struct {
    emr    : EMR,
    xNum   : LONG,
    xDenom : LONG,
    yNum   : LONG,
    yDenom : LONG,
 };

 EMRSETWORLDTRANSFORM :: struct {
    emr   : EMR,
    xform : XFORM,
 };
 PEMRSETWORLDTRANSFORM :: ^struct {
    emr   : EMR,
    xform : XFORM,
 };

 EMRMODIFYWORLDTRANSFORM :: struct {
    emr   : EMR,
    xform : XFORM,
    iMode : u32,
 };
 PEMRMODIFYWORLDTRANSFORM :: ^struct {
    emr   : EMR,
    xform : XFORM,
    iMode : u32,
 };

 EMRSETPIXELV :: struct {
    emr      : EMR,
    ptlPixel : POINTL,
    crColor  : COLORREF,
 };
 PEMRSETPIXELV :: ^struct {
    emr      : EMR,
    ptlPixel : POINTL,
    crColor  : COLORREF,
 };

 EMREXTFLOODFILL :: struct {
    emr      : EMR,
    ptlStart : POINTL,
    crColor  : COLORREF,
    iMode    : u32,
 };
 PEMREXTFLOODFILL :: ^struct {
    emr      : EMR,
    ptlStart : POINTL,
    crColor  : COLORREF,
    iMode    : u32,
 };

 EMRELLIPSE :: struct {
    emr    : EMR,
    rclBox : RECTL,
 };
 PEMRELLIPSE :: ^struct {
    emr    : EMR,
    rclBox : RECTL,
 };
 EMRRECTANGLE :: struct {
    emr    : EMR,
    rclBox : RECTL,
 };
 PEMRRECTANGLE :: ^struct {
    emr    : EMR,
    rclBox : RECTL,
 };

 EMRROUNDRECT :: struct {
    emr       : EMR,
    rclBox    : RECTL,
    szlCorner : SIZEL,
 };
 PEMRROUNDRECT :: ^struct {
    emr       : EMR,
    rclBox    : RECTL,
    szlCorner : SIZEL,
 };

 EMRARC :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };
 PEMRARC :: ^struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };
 EMRARCTO :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };
 PEMRARCTO :: ^struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };
 EMRCHORD :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };
 PEMRCHORD :: ^struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };
 EMRPIE :: struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };
 PEMRPIE :: ^struct {
    emr      : EMR,
    rclBox   : RECTL,
    ptlStart : POINTL,
    ptlEnd   : POINTL,
 };

 EMRANGLEARC :: struct {
    emr         : EMR,
    ptlCenter   : POINTL,
    nRadius     : u32,
    eStartAngle : FLOAT,
    eSweepAngle : FLOAT,
 };
 PEMRANGLEARC :: ^struct {
    emr         : EMR,
    ptlCenter   : POINTL,
    nRadius     : u32,
    eStartAngle : FLOAT,
    eSweepAngle : FLOAT,
 };

 EMRPOLYLINE :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 PEMRPOLYLINE :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 EMRPOLYBEZIER :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 PEMRPOLYBEZIER :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 EMRPOLYGON :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 PEMRPOLYGON :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 EMRPOLYBEZIERTO :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 PEMRPOLYBEZIERTO :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 EMRPOLYLINETO :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };
 PEMRPOLYLINETO :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
 };

 EMRPOLYLINE16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 PEMRPOLYLINE16 :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 EMRPOLYBEZIER16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 PEMRPOLYBEZIER16 :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 EMRPOLYGON16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 PEMRPOLYGON16 :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 EMRPOLYBEZIERTO16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 PEMRPOLYBEZIERTO16 :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 EMRPOLYLINETO16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };
 PEMRPOLYLINETO16 :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
 };

 EMRPOLYDRAW :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
    abTypes   : [1]BYTE,
 };
 PEMRPOLYDRAW :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cptl      : u32,
    aptl      : [1]POINTL,
    abTypes   : [1]BYTE,
 };

 EMRPOLYDRAW16 :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
    abTypes   : [1]BYTE,
 };
 PEMRPOLYDRAW16 :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cpts      : u32,
    apts      : [1]POINTS,
    abTypes   : [1]BYTE,
 };

 EMRPOLYPOLYLINE :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cptl        : u32,
    aPolyCounts : [1]u32,
    aptl        : [1]POINTL,
 };
 PEMRPOLYPOLYLINE :: ^struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cptl        : u32,
    aPolyCounts : [1]u32,
    aptl        : [1]POINTL,
 };
 EMRPOLYPOLYGON :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cptl        : u32,
    aPolyCounts : [1]u32,
    aptl        : [1]POINTL,
 };
 PEMRPOLYPOLYGON :: ^struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cptl        : u32,
    aPolyCounts : [1]u32,
    aptl        : [1]POINTL,
 };

 EMRPOLYPOLYLINE16 :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cpts        : u32,
    aPolyCounts : [1]u32,
    apts        : [1]POINTS,
 };
 PEMRPOLYPOLYLINE16 :: ^struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cpts        : u32,
    aPolyCounts : [1]u32,
    apts        : [1]POINTS,
 };
 EMRPOLYPOLYGON16 :: struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cpts        : u32,
    aPolyCounts : [1]u32,
    apts        : [1]POINTS,
 };
 PEMRPOLYPOLYGON16 :: ^struct {
    emr         : EMR,
    rclBounds   : RECTL,
    nPolys      : u32,
    cpts        : u32,
    aPolyCounts : [1]u32,
    apts        : [1]POINTS,
 };

 EMRINVERTRGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    RgnData   : [1]BYTE,
 };
 PEMRINVERTRGN :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    RgnData   : [1]BYTE,
 };
 EMRPAINTRGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    RgnData   : [1]BYTE,
 };
 PEMRPAINTRGN :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    RgnData   : [1]BYTE,
 };

 EMRFILLRGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    ihBrush   : u32,
    RgnData   : [1]BYTE,
 };
 PEMRFILLRGN :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    ihBrush   : u32,
    RgnData   : [1]BYTE,
 };

 EMRFRAMERGN :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    ihBrush   : u32,
    szlStroke : SIZEL,
    RgnData   : [1]BYTE,
 };
 PEMRFRAMERGN :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbRgnData : u32,
    ihBrush   : u32,
    szlStroke : SIZEL,
    RgnData   : [1]BYTE,
 };

 EMREXTSELECTCLIPRGN :: struct {
    emr       : EMR,
    cbRgnData : u32,
    iMode     : u32,
    RgnData   : [1]BYTE,
 };
 PEMREXTSELECTCLIPRGN :: ^struct {
    emr       : EMR,
    cbRgnData : u32,
    iMode     : u32,
    RgnData   : [1]BYTE,
 };

 EMREXTTEXTOUTA :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    emrtext       : EMRTEXT,
 };
 PEMREXTTEXTOUTA :: ^struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    emrtext       : EMRTEXT,
 };
 EMREXTTEXTOUTW :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    emrtext       : EMRTEXT,
 };
 PEMREXTTEXTOUTW :: ^struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    emrtext       : EMRTEXT,
 };

 EMRPOLYTEXTOUTA :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    cStrings      : LONG,
    aemrtext      : [1]EMRTEXT,
 };
 PEMRPOLYTEXTOUTA :: ^struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    cStrings      : LONG,
    aemrtext      : [1]EMRTEXT,
 };
 EMRPOLYTEXTOUTW :: struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    cStrings      : LONG,
    aemrtext      : [1]EMRTEXT,
 };
 PEMRPOLYTEXTOUTW :: ^struct {
    emr           : EMR,
    rclBounds     : RECTL,
    iGraphicsMode : u32,
    exScale       : FLOAT,
    eyScale       : FLOAT,
    cStrings      : LONG,
    aemrtext      : [1]EMRTEXT,
 };

 EMRBITBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
 };
 PEMRBITBLT :: ^struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
 };

 EMRSTRETCHBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    cxSrc        : LONG,
    cySrc        : LONG,
 };
 PEMRSTRETCHBLT :: ^struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    cxSrc        : LONG,
    cySrc        : LONG,
 };

 EMRMASKBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    xMask        : LONG,
    yMask        : LONG,
    iUsageMask   : u32,
    offBmiMask   : u32,
    cbBmiMask    : u32,
    offBitsMask  : u32,
    cbBitsMask   : u32,
 };
 PEMRMASKBLT :: ^struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    xMask        : LONG,
    yMask        : LONG,
    iUsageMask   : u32,
    offBmiMask   : u32,
    cbBmiMask    : u32,
    offBitsMask  : u32,
    cbBitsMask   : u32,
 };

 EMRPLGBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    aptlDest     : [3]POINTL,
    xSrc         : LONG,
    ySrc         : LONG,
    cxSrc        : LONG,
    cySrc        : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    xMask        : LONG,
    yMask        : LONG,
    iUsageMask   : u32,
    offBmiMask   : u32,
    cbBmiMask    : u32,
    offBitsMask  : u32,
    cbBitsMask   : u32,
 };
 PEMRPLGBLT :: ^struct {
    emr          : EMR,
    rclBounds    : RECTL,
    aptlDest     : [3]POINTL,
    xSrc         : LONG,
    ySrc         : LONG,
    cxSrc        : LONG,
    cySrc        : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    xMask        : LONG,
    yMask        : LONG,
    iUsageMask   : u32,
    offBmiMask   : u32,
    cbBmiMask    : u32,
    offBitsMask  : u32,
    cbBitsMask   : u32,
 };

 EMRSETDIBITSTODEVICE :: struct {
    emr        : EMR,
    rclBounds  : RECTL,
    xDest      : LONG,
    yDest      : LONG,
    xSrc       : LONG,
    ySrc       : LONG,
    cxSrc      : LONG,
    cySrc      : LONG,
    offBmiSrc  : u32,
    cbBmiSrc   : u32,
    offBitsSrc : u32,
    cbBitsSrc  : u32,
    iUsageSrc  : u32,
    iStartScan : u32,
    cScans     : u32,
 };
 PEMRSETDIBITSTODEVICE :: ^struct {
    emr        : EMR,
    rclBounds  : RECTL,
    xDest      : LONG,
    yDest      : LONG,
    xSrc       : LONG,
    ySrc       : LONG,
    cxSrc      : LONG,
    cySrc      : LONG,
    offBmiSrc  : u32,
    cbBmiSrc   : u32,
    offBitsSrc : u32,
    cbBitsSrc  : u32,
    iUsageSrc  : u32,
    iStartScan : u32,
    cScans     : u32,
 };

 EMRSTRETCHDIBITS :: struct {
    emr        : EMR,
    rclBounds  : RECTL,
    xDest      : LONG,
    yDest      : LONG,
    xSrc       : LONG,
    ySrc       : LONG,
    cxSrc      : LONG,
    cySrc      : LONG,
    offBmiSrc  : u32,
    cbBmiSrc   : u32,
    offBitsSrc : u32,
    cbBitsSrc  : u32,
    iUsageSrc  : u32,
    dwRop      : u32,
    cxDest     : LONG,
    cyDest     : LONG,
 };
 PEMRSTRETCHDIBITS :: ^struct {
    emr        : EMR,
    rclBounds  : RECTL,
    xDest      : LONG,
    yDest      : LONG,
    xSrc       : LONG,
    ySrc       : LONG,
    cxSrc      : LONG,
    cySrc      : LONG,
    offBmiSrc  : u32,
    cbBmiSrc   : u32,
    offBitsSrc : u32,
    cbBitsSrc  : u32,
    iUsageSrc  : u32,
    dwRop      : u32,
    cxDest     : LONG,
    cyDest     : LONG,
 };

 EMREXTCREATEFONTINDIRECTW :: struct {
    emr    : EMR,
    ihFont : u32,
    elfw   : EXTLOGFONTW,
 };
 PEMREXTCREATEFONTINDIRECTW :: ^struct {
    emr    : EMR,
    ihFont : u32,
    elfw   : EXTLOGFONTW,
 };

 EMRCREATEPALETTE :: struct {
    emr   : EMR,
    ihPal : u32,
    lgpl  : LOGPALETTE,
 };
 PEMRCREATEPALETTE :: ^struct {
    emr   : EMR,
    ihPal : u32,
    lgpl  : LOGPALETTE,
 };

 EMRCREATEPEN :: struct {
    emr   : EMR,
    ihPen : u32,
    lopn  : LOGPEN,
 };
 PEMRCREATEPEN :: ^struct {
    emr   : EMR,
    ihPen : u32,
    lopn  : LOGPEN,
 };

 EMREXTCREATEPEN :: struct {
    emr     : EMR,
    ihPen   : u32,
    offBmi  : u32,
    cbBmi   : u32,
    offBits : u32,
    cbBits  : u32,
    elp     : EXTLOGPEN32,
 };
 PEMREXTCREATEPEN :: ^struct {
    emr     : EMR,
    ihPen   : u32,
    offBmi  : u32,
    cbBmi   : u32,
    offBits : u32,
    cbBits  : u32,
    elp     : EXTLOGPEN32,
 };

 EMRCREATEBRUSHINDIRECT :: struct {
    emr     : EMR,
    ihBrush : u32,
    lb      : LOGBRUSH32,
 };
 PEMRCREATEBRUSHINDIRECT :: ^struct {
    emr     : EMR,
    ihBrush : u32,
    lb      : LOGBRUSH32,
 };

 EMRCREATEMONOBRUSH :: struct {
    emr     : EMR,
    ihBrush : u32,
    iUsage  : u32,
    offBmi  : u32,
    cbBmi   : u32,
    offBits : u32,
    cbBits  : u32,
 };
 PEMRCREATEMONOBRUSH :: ^struct {
    emr     : EMR,
    ihBrush : u32,
    iUsage  : u32,
    offBmi  : u32,
    cbBmi   : u32,
    offBits : u32,
    cbBits  : u32,
 };

 EMRCREATEDIBPATTERNBRUSHPT :: struct {
    emr     : EMR,
    ihBrush : u32,
    iUsage  : u32,
    offBmi  : u32,
    cbBmi   : u32,
    offBits : u32,
    cbBits  : u32,
 };
 PEMRCREATEDIBPATTERNBRUSHPT :: ^struct {
    emr     : EMR,
    ihBrush : u32,
    iUsage  : u32,
    offBmi  : u32,
    cbBmi   : u32,
    offBits : u32,
    cbBits  : u32,
 };

 EMRFORMAT :: struct {
    dSignature : u32,
    nVersion   : u32,
    cbData     : u32,
    offData    : u32,
 };
 PEMRFORMAT :: ^struct {
    dSignature : u32,
    nVersion   : u32,
    cbData     : u32,
    offData    : u32,
 };

 EMRGLSRECORD :: struct {
    emr    : EMR,
    cbData : u32,
    Data   : [1]BYTE,
 };
 PEMRGLSRECORD :: ^struct {
    emr    : EMR,
    cbData : u32,
    Data   : [1]BYTE,
 };

 EMRGLSBOUNDEDRECORD :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbData    : u32,
    Data      : [1]BYTE,
 };
 PEMRGLSBOUNDEDRECORD :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    cbData    : u32,
    Data      : [1]BYTE,
 };

 EMRPIXELFORMAT :: struct {
    emr : EMR,
    pfd : PIXELFORMATDESCRIPTOR,
 };
 PEMRPIXELFORMAT :: ^struct {
    emr : EMR,
    pfd : PIXELFORMATDESCRIPTOR,
 };

 EMRCREATECOLORSPACE :: struct {
    emr  : EMR,
    ihCS : u32,
    lcs  : LOGCOLORSPACEA,
 };
 PEMRCREATECOLORSPACE :: ^struct {
    emr  : EMR,
    ihCS : u32,
    lcs  : LOGCOLORSPACEA,
 };

 EMRSETCOLORSPACE :: struct {
    emr  : EMR,
    ihCS : u32,
 };
 PEMRSETCOLORSPACE :: ^struct {
    emr  : EMR,
    ihCS : u32,
 };
 EMRSELECTCOLORSPACE :: struct {
    emr  : EMR,
    ihCS : u32,
 };
 PEMRSELECTCOLORSPACE :: ^struct {
    emr  : EMR,
    ihCS : u32,
 };
 EMRDELETECOLORSPACE :: struct {
    emr  : EMR,
    ihCS : u32,
 };
 PEMRDELETECOLORSPACE :: ^struct {
    emr  : EMR,
    ihCS : u32,
 };

 EMREXTESCAPE :: struct {
    emr       : EMR,
    iEscape   : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
 };
 PEMREXTESCAPE :: ^struct {
    emr       : EMR,
    iEscape   : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
 };
 EMRDRAWESCAPE :: struct {
    emr       : EMR,
    iEscape   : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
 };
 PEMRDRAWESCAPE :: ^struct {
    emr       : EMR,
    iEscape   : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
 };

 EMRNAMEDESCAPE :: struct {
    emr       : EMR,
    iEscape   : INT,
    cbDriver  : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
 };
 PEMRNAMEDESCAPE :: ^struct {
    emr       : EMR,
    iEscape   : INT,
    cbDriver  : INT,
    cbEscData : INT,
    EscData   : [1]BYTE,
 };

 EMRSETICMPROFILE :: struct {
    emr     : EMR,
    dwFlags : u32,
    cbName  : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };
 PEMRSETICMPROFILE :: ^struct {
    emr     : EMR,
    dwFlags : u32,
    cbName  : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };
 EMRSETICMPROFILEA :: struct {
    emr     : EMR,
    dwFlags : u32,
    cbName  : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };
 PEMRSETICMPROFILEA :: ^struct {
    emr     : EMR,
    dwFlags : u32,
    cbName  : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };
 EMRSETICMPROFILEW :: struct {
    emr     : EMR,
    dwFlags : u32,
    cbName  : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };
 PEMRSETICMPROFILEW :: ^struct {
    emr     : EMR,
    dwFlags : u32,
    cbName  : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };

 EMRCREATECOLORSPACEW :: struct {
    emr     : EMR,
    ihCS    : u32,
    lcs     : LOGCOLORSPACEW,
    dwFlags : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };
 PEMRCREATECOLORSPACEW :: ^struct {
    emr     : EMR,
    ihCS    : u32,
    lcs     : LOGCOLORSPACEW,
    dwFlags : u32,
    cbData  : u32,
    Data    : [1]BYTE,
 };

 EMRCOLORMATCHTOTARGET :: struct {
    emr      : EMR,
    dwAction : u32,
    dwFlags  : u32,
    cbName   : u32,
    cbData   : u32,
    Data     : [1]BYTE,
 };
 PEMRCOLORMATCHTOTARGET :: ^struct {
    emr      : EMR,
    dwAction : u32,
    dwFlags  : u32,
    cbName   : u32,
    cbData   : u32,
    Data     : [1]BYTE,
 };

 EMRCOLORCORRECTPALETTE :: struct {
    emr         : EMR,
    ihPalette   : u32,
    nFirstEntry : u32,
    nPalEntries : u32,
    nReserved   : u32,
 };
 PEMRCOLORCORRECTPALETTE :: ^struct {
    emr         : EMR,
    ihPalette   : u32,
    nFirstEntry : u32,
    nPalEntries : u32,
    nReserved   : u32,
 };

 EMRALPHABLEND :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    cxSrc        : LONG,
    cySrc        : LONG,
 };
 PEMRALPHABLEND :: ^struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    cxSrc        : LONG,
    cySrc        : LONG,
 };

 EMRGRADIENTFILL :: struct {
    emr       : EMR,
    rclBounds : RECTL,
    nVer      : u32,
    nTri      : u32,
    ulMode    : ULONG,
    Ver       : [1]TRIVERTEX,
 };
 PEMRGRADIENTFILL :: ^struct {
    emr       : EMR,
    rclBounds : RECTL,
    nVer      : u32,
    nTri      : u32,
    ulMode    : ULONG,
    Ver       : [1]TRIVERTEX,
 };

 EMRTRANSPARENTBLT :: struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    cxSrc        : LONG,
    cySrc        : LONG,
 };
 PEMRTRANSPARENTBLT :: ^struct {
    emr          : EMR,
    rclBounds    : RECTL,
    xDest        : LONG,
    yDest        : LONG,
    cxDest       : LONG,
    cyDest       : LONG,
    dwRop        : u32,
    xSrc         : LONG,
    ySrc         : LONG,
    xformSrc     : XFORM,
    crBkColorSrc : COLORREF,
    iUsageSrc    : u32,
    offBmiSrc    : u32,
    cbBmiSrc     : u32,
    offBitsSrc   : u32,
    cbBitsSrc    : u32,
    cxSrc        : LONG,
    cySrc        : LONG,
 };

 POINTFLOAT :: struct {
    x : FLOAT,
    y : FLOAT,
 };
 PPOINTFLOAT :: ^struct {
    x : FLOAT,
    y : FLOAT,
 };

 GLYPHMETRICSFLOAT :: struct {
    gmfBlackBoxX     : FLOAT,
    gmfBlackBoxY     : FLOAT,
    gmfptGlyphOrigin : POINTFLOAT,
    gmfCellIncX      : FLOAT,
    gmfCellIncY      : FLOAT,
 };
 PGLYPHMETRICSFLOAT :: ^struct {
    gmfBlackBoxX     : FLOAT,
    gmfBlackBoxY     : FLOAT,
    gmfptGlyphOrigin : POINTFLOAT,
    gmfCellIncX      : FLOAT,
    gmfCellIncY      : FLOAT,
 };
 LPGLYPHMETRICSFLOAT :: ^struct {
    gmfBlackBoxX     : FLOAT,
    gmfBlackBoxY     : FLOAT,
    gmfptGlyphOrigin : POINTFLOAT,
    gmfCellIncX      : FLOAT,
    gmfCellIncY      : FLOAT,
 };

 LAYERPLANEDESCRIPTOR :: struct {
    nSize           : u16,
    nVersion        : u16,
    dwFlags         : u32,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerPlane     : BYTE,
    bReserved       : BYTE,
    crTransparent   : COLORREF,
 };
 PLAYERPLANEDESCRIPTOR :: ^struct {
    nSize           : u16,
    nVersion        : u16,
    dwFlags         : u32,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerPlane     : BYTE,
    bReserved       : BYTE,
    crTransparent   : COLORREF,
 };
 LPLAYERPLANEDESCRIPTOR :: ^struct {
    nSize           : u16,
    nVersion        : u16,
    dwFlags         : u32,
    iPixelType      : BYTE,
    cColorBits      : BYTE,
    cRedBits        : BYTE,
    cRedShift       : BYTE,
    cGreenBits      : BYTE,
    cGreenShift     : BYTE,
    cBlueBits       : BYTE,
    cBlueShift      : BYTE,
    cAlphaBits      : BYTE,
    cAlphaShift     : BYTE,
    cAccumBits      : BYTE,
    cAccumRedBits   : BYTE,
    cAccumGreenBits : BYTE,
    cAccumBlueBits  : BYTE,
    cAccumAlphaBits : BYTE,
    cDepthBits      : BYTE,
    cStencilBits    : BYTE,
    cAuxBuffers     : BYTE,
    iLayerPlane     : BYTE,
    bReserved       : BYTE,
    crTransparent   : COLORREF,
 };

 WGLSWAP :: struct {
    hdc     : HDC,
    uiFlags : UINT,
 };
 PWGLSWAP :: ^struct {
    hdc     : HDC,
    uiFlags : UINT,
 };
 LPWGLSWAP :: ^struct {
    hdc     : HDC,
    uiFlags : UINT,
 };

 HDWP :: HANDLE;

 MENUTEMPLATEA :: void;

 MENUTEMPLATEW :: void;

 MENUTEMPLATE :: MENUTEMPLATEA;

 LPMENUTEMPLATEA :: PVOID;

 LPMENUTEMPLATEW :: PVOID;

 LPMENUTEMPLATE :: LPMENUTEMPLATEA;

 WNDPROC :: (proc(HWND, UINT, WPARAM, LPARAM) -> LRESULT);

 DLGPROC :: (proc(HWND, UINT, WPARAM, LPARAM) -> INT_PTR);

 TIMERPROC :: proc(HWND, UINT, UINT_PTR, u32);

 GRAYSTRINGPROC :: (proc(HDC, LPARAM, i32) -> BOOL);

 WNDENUMPROC :: (proc(HWND, LPARAM) -> BOOL);

 HOOKPROC :: (proc(code : i32, wParam : WPARAM, lParam : LPARAM) -> LRESULT);

 SENDASYNCPROC :: proc(HWND, UINT, ULONG_PTR, LRESULT);

 PROPENUMPROCA :: (proc(HWND, LPCSTR, HANDLE) -> BOOL);

 PROPENUMPROCW :: (proc(HWND, LPCWSTR, HANDLE) -> BOOL);

 PROPENUMPROCEXA :: (proc(HWND, LPSTR, HANDLE, ULONG_PTR) -> BOOL);

 PROPENUMPROCEXW :: (proc(HWND, LPWSTR, HANDLE, ULONG_PTR) -> BOOL);

 EDITWORDBREAKPROCA :: (proc(lpch : LPSTR, ichCurrent : i32, cch : i32, code : i32) -> i32);

 EDITWORDBREAKPROCW :: (proc(lpch : LPWSTR, ichCurrent : i32, cch : i32, code : i32) -> i32);

 DRAWSTATEPROC :: (proc(hdc : HDC, lData : LPARAM, wData : WPARAM, cx : i32, cy : i32) -> BOOL);

 PROPENUMPROC :: PROPENUMPROCA;

 PROPENUMPROCEX :: PROPENUMPROCEXA;

 EDITWORDBREAKPROC :: EDITWORDBREAKPROCA;

 NAMEENUMPROCA :: (proc(LPSTR, LPARAM) -> BOOL);

 NAMEENUMPROCW :: (proc(LPWSTR, LPARAM) -> BOOL);

 WINSTAENUMPROCA :: NAMEENUMPROCA;

 DESKTOPENUMPROCA :: NAMEENUMPROCA;

 WINSTAENUMPROCW :: NAMEENUMPROCW;

 DESKTOPENUMPROCW :: NAMEENUMPROCW;

 WINSTAENUMPROC :: WINSTAENUMPROCA;

 DESKTOPENUMPROC :: DESKTOPENUMPROCA;

 CBT_CREATEWNDA :: struct {
    lpcs            : ^CREATESTRUCTA,
    hwndInsertAfter : HWND,
 };
 LPCBT_CREATEWNDA :: ^struct {
    lpcs            : ^CREATESTRUCTA,
    hwndInsertAfter : HWND,
 };

 CBT_CREATEWNDW :: struct {
    lpcs            : ^CREATESTRUCTW,
    hwndInsertAfter : HWND,
 };
 LPCBT_CREATEWNDW :: ^struct {
    lpcs            : ^CREATESTRUCTW,
    hwndInsertAfter : HWND,
 };

 CBT_CREATEWND :: CBT_CREATEWNDA;

 LPCBT_CREATEWND :: LPCBT_CREATEWNDA;

 CBTACTIVATESTRUCT :: struct {
    fMouse     : BOOL,
    hWndActive : HWND,
 };
 LPCBTACTIVATESTRUCT :: ^struct {
    fMouse     : BOOL,
    hWndActive : HWND,
 };

 WTSSESSION_NOTIFICATION :: struct {
    cbSize      : u32,
    dwSessionId : u32,
 };
 PWTSSESSION_NOTIFICATION :: ^struct {
    cbSize      : u32,
    dwSessionId : u32,
 };

 SHELLHOOKINFO :: struct {
    hwnd : HWND,
    rc   : RECT,
 };
 LPSHELLHOOKINFO :: ^struct {
    hwnd : HWND,
    rc   : RECT,
 };

 EVENTMSG :: struct {
    message : UINT,
    paramL  : UINT,
    paramH  : UINT,
    time    : u32,
    hwnd    : HWND,
 };
 PEVENTMSGMSG :: ^struct {
    message : UINT,
    paramL  : UINT,
    paramH  : UINT,
    time    : u32,
    hwnd    : HWND,
 };
 NPEVENTMSGMSG :: ^struct {
    message : UINT,
    paramL  : UINT,
    paramH  : UINT,
    time    : u32,
    hwnd    : HWND,
 };
 LPEVENTMSGMSG :: ^struct {
    message : UINT,
    paramL  : UINT,
    paramH  : UINT,
    time    : u32,
    hwnd    : HWND,
 };

 PEVENTMSG :: ^EVENTMSG;
 NPEVENTMSG :: ^EVENTMSG;
 LPEVENTMSG :: ^EVENTMSG;

 CWPSTRUCT :: struct {
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };
 PCWPSTRUCT :: ^struct {
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };
 NPCWPSTRUCT :: ^struct {
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };
 LPCWPSTRUCT :: ^struct {
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };

 CWPRETSTRUCT :: struct {
    lResult : LRESULT,
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };
 PCWPRETSTRUCT :: ^struct {
    lResult : LRESULT,
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };
 NPCWPRETSTRUCT :: ^struct {
    lResult : LRESULT,
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };
 LPCWPRETSTRUCT :: ^struct {
    lResult : LRESULT,
    lParam  : LPARAM,
    wParam  : WPARAM,
    message : UINT,
    hwnd    : HWND,
 };

 KBDLLHOOKSTRUCT :: struct {
    vkCode      : u32,
    scanCode    : u32,
    flags       : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 LPKBDLLHOOKSTRUCT :: ^struct {
    vkCode      : u32,
    scanCode    : u32,
    flags       : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 PKBDLLHOOKSTRUCT :: ^struct {
    vkCode      : u32,
    scanCode    : u32,
    flags       : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };

 MSLLHOOKSTRUCT :: struct {
    pt          : POINT,
    mouseData   : u32,
    flags       : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 LPMSLLHOOKSTRUCT :: ^struct {
    pt          : POINT,
    mouseData   : u32,
    flags       : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 PMSLLHOOKSTRUCT :: ^struct {
    pt          : POINT,
    mouseData   : u32,
    flags       : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };

 DEBUGHOOKINFO :: struct {
    idThread          : u32,
    idThreadInstaller : u32,
    lParam            : LPARAM,
    wParam            : WPARAM,
    code              : i32,
 };
 PDEBUGHOOKINFO :: ^struct {
    idThread          : u32,
    idThreadInstaller : u32,
    lParam            : LPARAM,
    wParam            : WPARAM,
    code              : i32,
 };
 NPDEBUGHOOKINFO :: ^struct {
    idThread          : u32,
    idThreadInstaller : u32,
    lParam            : LPARAM,
    wParam            : WPARAM,
    code              : i32,
 };
 LPDEBUGHOOKINFO :: ^struct {
    idThread          : u32,
    idThreadInstaller : u32,
    lParam            : LPARAM,
    wParam            : WPARAM,
    code              : i32,
 };

 MOUSEHOOKSTRUCT :: struct {
    pt           : POINT,
    hwnd         : HWND,
    wHitTestCode : UINT,
    dwExtraInfo  : ULONG_PTR,
 };
 LPMOUSEHOOKSTRUCT :: ^struct {
    pt           : POINT,
    hwnd         : HWND,
    wHitTestCode : UINT,
    dwExtraInfo  : ULONG_PTR,
 };
 PMOUSEHOOKSTRUCT :: ^struct {
    pt           : POINT,
    hwnd         : HWND,
    wHitTestCode : UINT,
    dwExtraInfo  : ULONG_PTR,
 };

 MOUSEHOOKSTRUCTEX :: struct {
    s         : MOUSEHOOKSTRUCT,
    mouseData : u32,
 };
 LPMOUSEHOOKSTRUCTEX :: ^struct {
    s         : MOUSEHOOKSTRUCT,
    mouseData : u32,
 };
 PMOUSEHOOKSTRUCTEX :: ^struct {
    s         : MOUSEHOOKSTRUCT,
    mouseData : u32,
 };

 HARDWAREHOOKSTRUCT :: struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
 };
 LPHARDWAREHOOKSTRUCT :: ^struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
 };
 PHARDWAREHOOKSTRUCT :: ^struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
 };

 MOUSEMOVEPOINT :: struct {
    x           : i32,
    y           : i32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 PMOUSEMOVEPOINT :: ^struct {
    x           : i32,
    y           : i32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 LPMOUSEMOVEPOINT :: ^struct {
    x           : i32,
    y           : i32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };

 USEROBJECTFLAGS :: struct {
    fInherit  : BOOL,
    fReserved : BOOL,
    dwFlags   : u32,
 };
 PUSEROBJECTFLAGS :: ^struct {
    fInherit  : BOOL,
    fReserved : BOOL,
    dwFlags   : u32,
 };

 WNDCLASSEXA :: struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
    hIconSm       : HICON,
 };
 PWNDCLASSEXA :: ^struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
    hIconSm       : HICON,
 };
 NPWNDCLASSEXA :: ^struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
    hIconSm       : HICON,
 };
 LPWNDCLASSEXA :: ^struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
    hIconSm       : HICON,
 };

 WNDCLASSEXW :: struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
    hIconSm       : HICON,
 };
 PWNDCLASSEXW :: ^struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
    hIconSm       : HICON,
 };
 NPWNDCLASSEXW :: ^struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
    hIconSm       : HICON,
 };
 LPWNDCLASSEXW :: ^struct {
    cbSize        : UINT,
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
    hIconSm       : HICON,
 };

 WNDCLASSEX :: WNDCLASSEXA;

 PWNDCLASSEX :: PWNDCLASSEXA;

 NPWNDCLASSEX :: NPWNDCLASSEXA;

 LPWNDCLASSEX :: LPWNDCLASSEXA;

 WNDCLASSA :: struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
 };
 PWNDCLASSA :: ^struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
 };
 NPWNDCLASSA :: ^struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
 };
 LPWNDCLASSA :: ^struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCSTR,
    lpszClassName : LPCSTR,
 };

 WNDCLASSW :: struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
 };
 PWNDCLASSW :: ^struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
 };
 NPWNDCLASSW :: ^struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
 };
 LPWNDCLASSW :: ^struct {
    style         : UINT,
    lpfnWndProc   : WNDPROC,
    cbClsExtra    : i32,
    cbWndExtra    : i32,
    hInstance     : HINSTANCE,
    hIcon         : HICON,
    hCursor       : HCURSOR,
    hbrBackground : HBRUSH,
    lpszMenuName  : LPCWSTR,
    lpszClassName : LPCWSTR,
 };

 WNDCLASS :: WNDCLASSA;

 PWNDCLASS :: PWNDCLASSA;

 NPWNDCLASS :: NPWNDCLASSA;

 LPWNDCLASS :: LPWNDCLASSA;

 MSG :: struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
    time    : u32,
    pt      : POINT,
 };
 PMSG :: ^struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
    time    : u32,
    pt      : POINT,
 };
 NPMSG :: ^struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
    time    : u32,
    pt      : POINT,
 };
 LPMSG :: ^struct {
    hwnd    : HWND,
    message : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM,
    time    : u32,
    pt      : POINT,
 };

 MINMAXINFO :: struct {
    ptReserved     : POINT,
    ptMaxSize      : POINT,
    ptMaxPosition  : POINT,
    ptMinTrackSize : POINT,
    ptMaxTrackSize : POINT,
 };
 PMINMAXINFO :: ^struct {
    ptReserved     : POINT,
    ptMaxSize      : POINT,
    ptMaxPosition  : POINT,
    ptMinTrackSize : POINT,
    ptMaxTrackSize : POINT,
 };
 LPMINMAXINFO :: ^struct {
    ptReserved     : POINT,
    ptMaxSize      : POINT,
    ptMaxPosition  : POINT,
    ptMinTrackSize : POINT,
    ptMaxTrackSize : POINT,
 };

 COPYDATASTRUCT :: struct {
    dwData : ULONG_PTR,
    cbData : u32,
    lpData : PVOID,
 };
 PCOPYDATASTRUCT :: ^struct {
    dwData : ULONG_PTR,
    cbData : u32,
    lpData : PVOID,
 };

 MDINEXTMENU :: struct {
    hmenuIn   : HMENU,
    hmenuNext : HMENU,
    hwndNext  : HWND,
 };
 PMDINEXTMENU :: ^struct {
    hmenuIn   : HMENU,
    hmenuNext : HMENU,
    hwndNext  : HWND,
 };
 LPMDINEXTMENU :: ^struct {
    hmenuIn   : HMENU,
    hmenuNext : HMENU,
    hwndNext  : HWND,
 };

 POWERBROADCAST_SETTING :: struct {
    PowerSetting : GUID,
    DataLength   : u32,
    Data         : [1]UCHAR,
 };
 PPOWERBROADCAST_SETTING :: ^struct {
    PowerSetting : GUID,
    DataLength   : u32,
    Data         : [1]UCHAR,
 };

 WINDOWPOS :: struct {
    hwnd            : HWND,
    hwndInsertAfter : HWND,
    x               : i32,
    y               : i32,
    cx              : i32,
    cy              : i32,
    flags           : UINT,
 };
 LPWINDOWPOS :: ^struct {
    hwnd            : HWND,
    hwndInsertAfter : HWND,
    x               : i32,
    y               : i32,
    cx              : i32,
    cy              : i32,
    flags           : UINT,
 };
 PWINDOWPOS :: ^struct {
    hwnd            : HWND,
    hwndInsertAfter : HWND,
    x               : i32,
    y               : i32,
    cx              : i32,
    cy              : i32,
    flags           : UINT,
 };

 NCCALCSIZE_PARAMS :: struct {
    rgrc  : [3]RECT,
    lppos : PWINDOWPOS,
 };
 LPNCCALCSIZE_PARAMS :: ^struct {
    rgrc  : [3]RECT,
    lppos : PWINDOWPOS,
 };

 TRACKMOUSEEVENT :: struct {
    cbSize      : u32,
    dwFlags     : u32,
    hwndTrack   : HWND,
    dwHoverTime : u32,
 };
 LPTRACKMOUSEEVENT :: ^struct {
    cbSize      : u32,
    dwFlags     : u32,
    hwndTrack   : HWND,
    dwHoverTime : u32,
 };

 ACCEL :: struct {
    fVirt : BYTE,
    key   : u16,
    cmd   : u16,
 };
 LPACCEL :: ^struct {
    fVirt : BYTE,
    key   : u16,
    cmd   : u16,
 };

 PAINTSTRUCT :: struct {
    hdc         : HDC,
    fErase      : BOOL,
    rcPaint     : RECT,
    fRestore    : BOOL,
    fIncUpdate  : BOOL,
    rgbReserved : [32]BYTE,
 };
 PPAINTSTRUCT :: ^struct {
    hdc         : HDC,
    fErase      : BOOL,
    rcPaint     : RECT,
    fRestore    : BOOL,
    fIncUpdate  : BOOL,
    rgbReserved : [32]BYTE,
 };
 NPPAINTSTRUCT :: ^struct {
    hdc         : HDC,
    fErase      : BOOL,
    rcPaint     : RECT,
    fRestore    : BOOL,
    fIncUpdate  : BOOL,
    rgbReserved : [32]BYTE,
 };
 LPPAINTSTRUCT :: ^struct {
    hdc         : HDC,
    fErase      : BOOL,
    rcPaint     : RECT,
    fRestore    : BOOL,
    fIncUpdate  : BOOL,
    rgbReserved : [32]BYTE,
 };

 CREATESTRUCTA :: struct {
    lpCreateParams : LPVOID,
    hInstance      : HINSTANCE,
    hMenu          : HMENU,
    hwndParent     : HWND,
    cy             : i32,
    cx             : i32,
    y              : i32,
    x              : i32,
    style          : LONG,
    lpszName       : LPCSTR,
    lpszClass      : LPCSTR,
    dwExStyle      : u32,
 };
 LPCREATESTRUCTA :: ^struct {
    lpCreateParams : LPVOID,
    hInstance      : HINSTANCE,
    hMenu          : HMENU,
    hwndParent     : HWND,
    cy             : i32,
    cx             : i32,
    y              : i32,
    x              : i32,
    style          : LONG,
    lpszName       : LPCSTR,
    lpszClass      : LPCSTR,
    dwExStyle      : u32,
 };

 CREATESTRUCTW :: struct {
    lpCreateParams : LPVOID,
    hInstance      : HINSTANCE,
    hMenu          : HMENU,
    hwndParent     : HWND,
    cy             : i32,
    cx             : i32,
    y              : i32,
    x              : i32,
    style          : LONG,
    lpszName       : LPCWSTR,
    lpszClass      : LPCWSTR,
    dwExStyle      : u32,
 };
 LPCREATESTRUCTW :: ^struct {
    lpCreateParams : LPVOID,
    hInstance      : HINSTANCE,
    hMenu          : HMENU,
    hwndParent     : HWND,
    cy             : i32,
    cx             : i32,
    y              : i32,
    x              : i32,
    style          : LONG,
    lpszName       : LPCWSTR,
    lpszClass      : LPCWSTR,
    dwExStyle      : u32,
 };

 CREATESTRUCT :: CREATESTRUCTA;

 LPCREATESTRUCT :: LPCREATESTRUCTA;

 WINDOWPLACEMENT :: struct {
    length           : UINT,
    flags            : UINT,
    showCmd          : UINT,
    ptMinPosition    : POINT,
    ptMaxPosition    : POINT,
    rcNormalPosition : RECT,
 };

 PWINDOWPLACEMENT :: ^WINDOWPLACEMENT;
 LPWINDOWPLACEMENT :: ^WINDOWPLACEMENT;

 NMHDR :: struct {
    hwndFrom : HWND,
    idFrom   : UINT_PTR,
    code     : UINT,
 };

 LPNMHDR :: ^NMHDR;

 STYLESTRUCT :: struct {
    styleOld : u32,
    styleNew : u32,
 };
 LPSTYLESTRUCT :: ^struct {
    styleOld : u32,
    styleNew : u32,
 };

 MEASUREITEMSTRUCT :: struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemWidth  : UINT,
    itemHeight : UINT,
    itemData   : ULONG_PTR,
 };
 PMEASUREITEMSTRUCT :: ^struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemWidth  : UINT,
    itemHeight : UINT,
    itemData   : ULONG_PTR,
 };
 LPMEASUREITEMSTRUCT :: ^struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemWidth  : UINT,
    itemHeight : UINT,
    itemData   : ULONG_PTR,
 };

 DRAWITEMSTRUCT :: struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemAction : UINT,
    itemState  : UINT,
    hwndItem   : HWND,
    hDC        : HDC,
    rcItem     : RECT,
    itemData   : ULONG_PTR,
 };
 PDRAWITEMSTRUCT :: ^struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemAction : UINT,
    itemState  : UINT,
    hwndItem   : HWND,
    hDC        : HDC,
    rcItem     : RECT,
    itemData   : ULONG_PTR,
 };
 LPDRAWITEMSTRUCT :: ^struct {
    CtlType    : UINT,
    CtlID      : UINT,
    itemID     : UINT,
    itemAction : UINT,
    itemState  : UINT,
    hwndItem   : HWND,
    hDC        : HDC,
    rcItem     : RECT,
    itemData   : ULONG_PTR,
 };

 DELETEITEMSTRUCT :: struct {
    CtlType  : UINT,
    CtlID    : UINT,
    itemID   : UINT,
    hwndItem : HWND,
    itemData : ULONG_PTR,
 };
 PDELETEITEMSTRUCT :: ^struct {
    CtlType  : UINT,
    CtlID    : UINT,
    itemID   : UINT,
    hwndItem : HWND,
    itemData : ULONG_PTR,
 };
 LPDELETEITEMSTRUCT :: ^struct {
    CtlType  : UINT,
    CtlID    : UINT,
    itemID   : UINT,
    hwndItem : HWND,
    itemData : ULONG_PTR,
 };

 COMPAREITEMSTRUCT :: struct {
    CtlType    : UINT,
    CtlID      : UINT,
    hwndItem   : HWND,
    itemID1    : UINT,
    itemData1  : ULONG_PTR,
    itemID2    : UINT,
    itemData2  : ULONG_PTR,
    dwLocaleId : u32,
 };
 PCOMPAREITEMSTRUCT :: ^struct {
    CtlType    : UINT,
    CtlID      : UINT,
    hwndItem   : HWND,
    itemID1    : UINT,
    itemData1  : ULONG_PTR,
    itemID2    : UINT,
    itemData2  : ULONG_PTR,
    dwLocaleId : u32,
 };
 LPCOMPAREITEMSTRUCT :: ^struct {
    CtlType    : UINT,
    CtlID      : UINT,
    hwndItem   : HWND,
    itemID1    : UINT,
    itemData1  : ULONG_PTR,
    itemID2    : UINT,
    itemData2  : ULONG_PTR,
    dwLocaleId : u32,
 };

 BSMINFO :: struct {
    cbSize : UINT,
    hdesk  : HDESK,
    hwnd   : HWND,
    luid   : LUID,
 };
 PBSMINFO :: ^struct {
    cbSize : UINT,
    hdesk  : HDESK,
    hwnd   : HWND,
    luid   : LUID,
 };

 HDEVNOTIFY :: PVOID;

 PHDEVNOTIFY :: ^HDEVNOTIFY;

 HPOWERNOTIFY :: PVOID;

 PHPOWERNOTIFY :: ^HPOWERNOTIFY;

 PREGISTERCLASSNAMEW :: (proc(LPCWSTR) -> BOOLEAN);

 UPDATELAYEREDWINDOWINFO :: struct {
    cbSize   : u32,
    hdcDst   : HDC,
    pptDst   : ^POINT,
    psize    : ^SIZE,
    hdcSrc   : HDC,
    pptSrc   : ^POINT,
    crKey    : COLORREF,
    pblend   : ^BLENDFUNCTION,
    dwFlags  : u32,
    prcDirty : ^RECT,
 };
 PUPDATELAYEREDWINDOWINFO :: ^struct {
    cbSize   : u32,
    hdcDst   : HDC,
    pptDst   : ^POINT,
    psize    : ^SIZE,
    hdcSrc   : HDC,
    pptSrc   : ^POINT,
    crKey    : COLORREF,
    pblend   : ^BLENDFUNCTION,
    dwFlags  : u32,
    prcDirty : ^RECT,
 };

 FLASHWINFO :: struct {
    cbSize    : UINT,
    hwnd      : HWND,
    dwFlags   : u32,
    uCount    : UINT,
    dwTimeout : u32,
 };
 PFLASHWINFO :: ^struct {
    cbSize    : UINT,
    hwnd      : HWND,
    dwFlags   : u32,
    uCount    : UINT,
    dwTimeout : u32,
 };

 DLGTEMPLATE :: struct {
    style           : u32,
    dwExtendedStyle : u32,
    cdit            : u16,
    x               : i16,
    y               : i16,
    cx              : i16,
    cy              : i16,
 };

 LPDLGTEMPLATEA :: ^DLGTEMPLATE;

 LPDLGTEMPLATEW :: ^DLGTEMPLATE;

 LPDLGTEMPLATE :: LPDLGTEMPLATEA;

 LPCDLGTEMPLATEA :: ^DLGTEMPLATE;

 LPCDLGTEMPLATEW :: ^DLGTEMPLATE;

 LPCDLGTEMPLATE :: LPCDLGTEMPLATEA;

 DLGITEMTEMPLATE :: struct {
    style           : u32,
    dwExtendedStyle : u32,
    x               : i16,
    y               : i16,
    cx              : i16,
    cy              : i16,
    id              : u16,
 };

 PDLGITEMTEMPLATEA :: ^DLGITEMTEMPLATE;

 PDLGITEMTEMPLATEW :: ^DLGITEMTEMPLATE;

 PDLGITEMTEMPLATE :: PDLGITEMTEMPLATEA;

 LPDLGITEMTEMPLATEA :: ^DLGITEMTEMPLATE;

 LPDLGITEMTEMPLATEW :: ^DLGITEMTEMPLATE;

 LPDLGITEMTEMPLATE :: LPDLGITEMTEMPLATEA;

 DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS :: enum {
    DCDC_DEFAULT = 0x0000,
    DCDC_DISABLE_FONT_UPDATE = 0x0001,
    DCDC_DISABLE_RELAYOUT = 0x0002,
 };

 DIALOG_DPI_CHANGE_BEHAVIORS :: enum {
    DDC_DEFAULT = 0x0000,
    DDC_DISABLE_ALL = 0x0001,
    DDC_DISABLE_RESIZE = 0x0002,
    DDC_DISABLE_CONTROL_RELAYOUT = 0x0004,
 };

 MOUSEINPUT :: struct {
    dx          : LONG,
    dy          : LONG,
    mouseData   : u32,
    dwFlags     : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 PMOUSEINPUT :: ^struct {
    dx          : LONG,
    dy          : LONG,
    mouseData   : u32,
    dwFlags     : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 LPMOUSEINPUT :: ^struct {
    dx          : LONG,
    dy          : LONG,
    mouseData   : u32,
    dwFlags     : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };

 KEYBDINPUT :: struct {
    wVk         : u16,
    wScan       : u16,
    dwFlags     : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 PKEYBDINPUT :: ^struct {
    wVk         : u16,
    wScan       : u16,
    dwFlags     : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };
 LPKEYBDINPUT :: ^struct {
    wVk         : u16,
    wScan       : u16,
    dwFlags     : u32,
    time        : u32,
    dwExtraInfo : ULONG_PTR,
 };

 HARDWAREINPUT :: struct {
    uMsg    : u32,
    wParamL : u16,
    wParamH : u16,
 };
 PHARDWAREINPUT :: ^struct {
    uMsg    : u32,
    wParamL : u16,
    wParamH : u16,
 };
 LPHARDWAREINPUT :: ^struct {
    uMsg    : u32,
    wParamL : u16,
    wParamH : u16,
 };

 INPUT :: struct {
    kind : u32,
    u : struct #raw_union {
        mi : MOUSEINPUT,
        ki : KEYBDINPUT,
        hi : HARDWAREINPUT,
    },
 };
 PINPUT :: ^struct {
    kind : u32,
    u : struct #raw_union {
        mi : MOUSEINPUT,
        ki : KEYBDINPUT,
        hi : HARDWAREINPUT,
    },
 };
 LPINPUT :: ^struct {
    kind : u32,
    u : struct #raw_union {
        mi : MOUSEINPUT,
        ki : KEYBDINPUT,
        hi : HARDWAREINPUT,
    },
 };

 HTOUCHINPUT__ :: struct {
    unused : i32,
 };

 HTOUCHINPUT :: ^HTOUCHINPUT__;

 TOUCHINPUT :: struct {
    x           : LONG,
    y           : LONG,
    hSource     : HANDLE,
    dwID        : u32,
    dwFlags     : u32,
    dwMask      : u32,
    dwTime      : u32,
    dwExtraInfo : ULONG_PTR,
    cxContact   : u32,
    cyContact   : u32,
 };
 PTOUCHINPUT :: ^struct {
    x           : LONG,
    y           : LONG,
    hSource     : HANDLE,
    dwID        : u32,
    dwFlags     : u32,
    dwMask      : u32,
    dwTime      : u32,
    dwExtraInfo : ULONG_PTR,
    cxContact   : u32,
    cyContact   : u32,
 };

 PCTOUCHINPUT :: ^TOUCHINPUT;

 tagPOINTER_INPUT_TYPE :: enum {
    PT_POINTER = 1,
    PT_TOUCH = 2,
    PT_PEN = 3,
    PT_MOUSE = 4,
    PT_TOUCHPAD = 5,
 };

 POINTER_INPUT_TYPE :: u32;

 POINTER_FLAGS :: UINT32;

 POINTER_BUTTON_CHANGE_TYPE :: enum {
    POINTER_CHANGE_NONE,
    POINTER_CHANGE_FIRSTBUTTON_DOWN,
    POINTER_CHANGE_FIRSTBUTTON_UP,
    POINTER_CHANGE_SECONDBUTTON_DOWN,
    POINTER_CHANGE_SECONDBUTTON_UP,
    POINTER_CHANGE_THIRDBUTTON_DOWN,
    POINTER_CHANGE_THIRDBUTTON_UP,
    POINTER_CHANGE_FOURTHBUTTON_DOWN,
    POINTER_CHANGE_FOURTHBUTTON_UP,
    POINTER_CHANGE_FIFTHBUTTON_DOWN,
    POINTER_CHANGE_FIFTHBUTTON_UP,
 };

 POINTER_INFO :: struct {
    pointerType           : POINTER_INPUT_TYPE,
    pointerId             : UINT32,
    frameId               : UINT32,
    pointerFlags          : POINTER_FLAGS,
    sourceDevice          : HANDLE,
    hwndTarget            : HWND,
    ptPixelLocation       : POINT,
    ptHimetricLocation    : POINT,
    ptPixelLocationRaw    : POINT,
    ptHimetricLocationRaw : POINT,
    dwTime                : u32,
    historyCount          : UINT32,
    InputData             : INT32,
    dwKeyStates           : u32,
    PerformanceCount      : UINT64,
    ButtonChangeType      : POINTER_BUTTON_CHANGE_TYPE,
 };

 TOUCH_FLAGS :: UINT32;

 TOUCH_MASK :: UINT32;

 POINTER_TOUCH_INFO :: struct {
    pointerInfo  : POINTER_INFO,
    touchFlags   : TOUCH_FLAGS,
    touchMask    : TOUCH_MASK,
    rcContact    : RECT,
    rcContactRaw : RECT,
    orientation  : UINT32,
    pressure     : UINT32,
 };

 PEN_FLAGS :: UINT32;

 PEN_MASK :: UINT32;

 POINTER_PEN_INFO :: struct {
    pointerInfo : POINTER_INFO,
    penFlags    : PEN_FLAGS,
    penMask     : PEN_MASK,
    pressure    : UINT32,
    rotation    : UINT32,
    tiltX       : INT32,
    tiltY       : INT32,
 };

 POINTER_FEEDBACK_MODE :: enum {
    POINTER_FEEDBACK_DEFAULT = 1,
    POINTER_FEEDBACK_INDIRECT = 2,
    POINTER_FEEDBACK_NONE = 3,
 };

 USAGE_PROPERTIES :: struct {
    level           : USHORT,
    page            : USHORT,
    usage           : USHORT,
    logicalMinimum  : INT32,
    logicalMaximum  : INT32,
    unit            : USHORT,
    exponent        : USHORT,
    count           : BYTE,
    physicalMinimum : INT32,
    physicalMaximum : INT32,
 };
 PUSAGE_PROPERTIES :: ^struct {
    level           : USHORT,
    page            : USHORT,
    usage           : USHORT,
    logicalMinimum  : INT32,
    logicalMaximum  : INT32,
    unit            : USHORT,
    exponent        : USHORT,
    count           : BYTE,
    physicalMinimum : INT32,
    physicalMaximum : INT32,
 };

 POINTER_TYPE_INFO :: struct {
    kind : POINTER_INPUT_TYPE,
    u : struct #raw_union {
        touchInfo : POINTER_TOUCH_INFO,
        penInfo   : POINTER_PEN_INFO,
    },
 };
 PPOINTER_TYPE_INFO :: ^struct {
    kind : POINTER_INPUT_TYPE,
    u : struct #raw_union {
        touchInfo : POINTER_TOUCH_INFO,
        penInfo   : POINTER_PEN_INFO,
    },
 };

 INPUT_INJECTION_VALUE :: struct {
    page  : USHORT,
    usage : USHORT,
    value : INT32,
    index : USHORT,
 };
 PINPUT_INJECTION_VALUE :: ^struct {
    page  : USHORT,
    usage : USHORT,
    value : INT32,
    index : USHORT,
 };

 HSYNTHETICPOINTERDEVICE__ :: struct {
    unused : i32,
 };

 HSYNTHETICPOINTERDEVICE :: ^HSYNTHETICPOINTERDEVICE__;

 TOUCH_HIT_TESTING_PROXIMITY_EVALUATION :: struct {
    score         : UINT16,
    adjustedPoint : POINT,
 };
 PTOUCH_HIT_TESTING_PROXIMITY_EVALUATION :: ^struct {
    score         : UINT16,
    adjustedPoint : POINT,
 };

 TOUCH_HIT_TESTING_INPUT :: struct {
    pointerId              : UINT32,
    point                  : POINT,
    boundingBox            : RECT,
    nonOccludedBoundingBox : RECT,
    orientation            : UINT32,
 };
 PTOUCH_HIT_TESTING_INPUT :: ^struct {
    pointerId              : UINT32,
    point                  : POINT,
    boundingBox            : RECT,
    nonOccludedBoundingBox : RECT,
    orientation            : UINT32,
 };

 FEEDBACK_TYPE :: enum {
    FEEDBACK_TOUCH_CONTACTVISUALIZATION = 1,
    FEEDBACK_PEN_BARRELVISUALIZATION = 2,
    FEEDBACK_PEN_TAP = 3,
    FEEDBACK_PEN_DOUBLETAP = 4,
    FEEDBACK_PEN_PRESSANDHOLD = 5,
    FEEDBACK_PEN_RIGHTTAP = 6,
    FEEDBACK_TOUCH_TAP = 7,
    FEEDBACK_TOUCH_DOUBLETAP = 8,
    FEEDBACK_TOUCH_PRESSANDHOLD = 9,
    FEEDBACK_TOUCH_RIGHTTAP = 10,
    FEEDBACK_GESTURE_PRESSANDTAP = 11,
    FEEDBACK_MAX = 0xFFFFFFFF,
 };

 INPUT_TRANSFORM :: struct {
    u : struct #raw_union {
        s : struct {
            _11 : f32,
            _12 : f32,
            _13 : f32,
            _14 : f32,
            _21 : f32,
            _22 : f32,
            _23 : f32,
            _24 : f32,
            _31 : f32,
            _32 : f32,
            _33 : f32,
            _34 : f32,
            _41 : f32,
            _42 : f32,
            _43 : f32,
            _44 : f32,
        },
        m : [4][4]f32,
    },
 };

 LASTINPUTINFO :: struct {
    cbSize : UINT,
    dwTime : u32,
 };
 PLASTINPUTINFO :: ^struct {
    cbSize : UINT,
    dwTime : u32,
 };

 TPMPARAMS :: struct {
    cbSize    : UINT,
    rcExclude : RECT,
 };

 LPTPMPARAMS :: ^TPMPARAMS;

 MENUINFO :: struct {
    cbSize          : u32,
    fMask           : u32,
    dwStyle         : u32,
    cyMax           : UINT,
    hbrBack         : HBRUSH,
    dwContextHelpID : u32,
    dwMenuData      : ULONG_PTR,
 };
 LPMENUINFO :: ^struct {
    cbSize          : u32,
    fMask           : u32,
    dwStyle         : u32,
    cyMax           : UINT,
    hbrBack         : HBRUSH,
    dwContextHelpID : u32,
    dwMenuData      : ULONG_PTR,
 };

 LPCMENUINFO :: ^MENUINFO;

 MENUGETOBJECTINFO :: struct {
    dwFlags : u32,
    uPos    : UINT,
    hmenu   : HMENU,
    riid    : PVOID,
    pvObj   : PVOID,
 };
 PMENUGETOBJECTINFO :: ^struct {
    dwFlags : u32,
    uPos    : UINT,
    hmenu   : HMENU,
    riid    : PVOID,
    pvObj   : PVOID,
 };

 MENUITEMINFOA :: struct {
    cbSize        : UINT,
    fMask         : UINT,
    fType         : UINT,
    fState        : UINT,
    wID           : UINT,
    hSubMenu      : HMENU,
    hbmpChecked   : HBITMAP,
    hbmpUnchecked : HBITMAP,
    dwItemData    : ULONG_PTR,
    dwTypeData    : LPSTR,
    cch           : UINT,
    hbmpItem      : HBITMAP,
 };
 LPMENUITEMINFOA :: ^struct {
    cbSize        : UINT,
    fMask         : UINT,
    fType         : UINT,
    fState        : UINT,
    wID           : UINT,
    hSubMenu      : HMENU,
    hbmpChecked   : HBITMAP,
    hbmpUnchecked : HBITMAP,
    dwItemData    : ULONG_PTR,
    dwTypeData    : LPSTR,
    cch           : UINT,
    hbmpItem      : HBITMAP,
 };

 MENUITEMINFOW :: struct {
    cbSize        : UINT,
    fMask         : UINT,
    fType         : UINT,
    fState        : UINT,
    wID           : UINT,
    hSubMenu      : HMENU,
    hbmpChecked   : HBITMAP,
    hbmpUnchecked : HBITMAP,
    dwItemData    : ULONG_PTR,
    dwTypeData    : LPWSTR,
    cch           : UINT,
    hbmpItem      : HBITMAP,
 };
 LPMENUITEMINFOW :: ^struct {
    cbSize        : UINT,
    fMask         : UINT,
    fType         : UINT,
    fState        : UINT,
    wID           : UINT,
    hSubMenu      : HMENU,
    hbmpChecked   : HBITMAP,
    hbmpUnchecked : HBITMAP,
    dwItemData    : ULONG_PTR,
    dwTypeData    : LPWSTR,
    cch           : UINT,
    hbmpItem      : HBITMAP,
 };

 MENUITEMINFO :: MENUITEMINFOA;

 LPMENUITEMINFO :: LPMENUITEMINFOA;

 LPCMENUITEMINFOA :: ^MENUITEMINFOA;

 LPCMENUITEMINFOW :: ^MENUITEMINFOW;

 LPCMENUITEMINFO :: LPCMENUITEMINFOA;

 DROPSTRUCT :: struct {
    hwndSource    : HWND,
    hwndSink      : HWND,
    wFmt          : u32,
    dwData        : ULONG_PTR,
    ptDrop        : POINT,
    dwControlData : u32,
 };
 PDROPSTRUCT :: ^struct {
    hwndSource    : HWND,
    hwndSink      : HWND,
    wFmt          : u32,
    dwData        : ULONG_PTR,
    ptDrop        : POINT,
    dwControlData : u32,
 };
 LPDROPSTRUCT :: ^struct {
    hwndSource    : HWND,
    hwndSink      : HWND,
    wFmt          : u32,
    dwData        : ULONG_PTR,
    ptDrop        : POINT,
    dwControlData : u32,
 };

 DRAWTEXTPARAMS :: struct {
    cbSize        : UINT,
    iTabLength    : i32,
    iLeftMargin   : i32,
    iRightMargin  : i32,
    uiLengthDrawn : UINT,
 };
 LPDRAWTEXTPARAMS :: ^struct {
    cbSize        : UINT,
    iTabLength    : i32,
    iLeftMargin   : i32,
    iRightMargin  : i32,
    uiLengthDrawn : UINT,
 };

 HELPINFO :: struct {
    cbSize       : UINT,
    iContextType : i32,
    iCtrlId      : i32,
    hItemHandle  : HANDLE,
    dwContextId  : DWORD_PTR,
    MousePos     : POINT,
 };
 LPHELPINFO :: ^struct {
    cbSize       : UINT,
    iContextType : i32,
    iCtrlId      : i32,
    hItemHandle  : HANDLE,
    dwContextId  : DWORD_PTR,
    MousePos     : POINT,
 };

 MSGBOXCALLBACK :: proc(lpHelpInfo : LPHELPINFO);

 MSGBOXPARAMSA :: struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCSTR,
    lpszCaption        : LPCSTR,
    dwStyle            : u32,
    lpszIcon           : LPCSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : u32,
 };
 PMSGBOXPARAMSA :: ^struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCSTR,
    lpszCaption        : LPCSTR,
    dwStyle            : u32,
    lpszIcon           : LPCSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : u32,
 };
 LPMSGBOXPARAMSA :: ^struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCSTR,
    lpszCaption        : LPCSTR,
    dwStyle            : u32,
    lpszIcon           : LPCSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : u32,
 };

 MSGBOXPARAMSW :: struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCWSTR,
    lpszCaption        : LPCWSTR,
    dwStyle            : u32,
    lpszIcon           : LPCWSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : u32,
 };
 PMSGBOXPARAMSW :: ^struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCWSTR,
    lpszCaption        : LPCWSTR,
    dwStyle            : u32,
    lpszIcon           : LPCWSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : u32,
 };
 LPMSGBOXPARAMSW :: ^struct {
    cbSize             : UINT,
    hwndOwner          : HWND,
    hInstance          : HINSTANCE,
    lpszText           : LPCWSTR,
    lpszCaption        : LPCWSTR,
    dwStyle            : u32,
    lpszIcon           : LPCWSTR,
    dwContextHelpId    : DWORD_PTR,
    lpfnMsgBoxCallback : MSGBOXCALLBACK,
    dwLanguageId       : u32,
 };

 MSGBOXPARAMS :: MSGBOXPARAMSA;

 PMSGBOXPARAMS :: PMSGBOXPARAMSA;

 LPMSGBOXPARAMS :: LPMSGBOXPARAMSA;

 MENUITEMTEMPLATEHEADER :: struct {
    versionNumber : u16,
    offset        : u16,
 };
 PMENUITEMTEMPLATEHEADER :: ^struct {
    versionNumber : u16,
    offset        : u16,
 };

 MENUITEMTEMPLATE :: struct {
    mtOption : u16,
    mtID     : u16,
    mtString : [1]WCHAR,
 };
 PMENUITEMTEMPLATE :: ^struct {
    mtOption : u16,
    mtID     : u16,
    mtString : [1]WCHAR,
 };

 ICONINFO :: struct {
    fIcon    : BOOL,
    xHotspot : u32,
    yHotspot : u32,
    hbmMask  : HBITMAP,
    hbmColor : HBITMAP,
 };

 PICONINFO :: ^ICONINFO;

 CURSORSHAPE :: struct {
    xHotSpot  : i32,
    yHotSpot  : i32,
    cx        : i32,
    cy        : i32,
    cbWidth   : i32,
    Planes    : BYTE,
    BitsPixel : BYTE,
 };
 LPCURSORSHAPE :: ^struct {
    xHotSpot  : i32,
    yHotSpot  : i32,
    cx        : i32,
    cy        : i32,
    cbWidth   : i32,
    Planes    : BYTE,
    BitsPixel : BYTE,
 };

 ICONINFOEXA :: struct {
    cbSize    : u32,
    fIcon     : BOOL,
    xHotspot  : u32,
    yHotspot  : u32,
    hbmMask   : HBITMAP,
    hbmColor  : HBITMAP,
    wResID    : u16,
    szModName : [260]CHAR,
    szResName : [260]CHAR,
 };
 PICONINFOEXA :: ^struct {
    cbSize    : u32,
    fIcon     : BOOL,
    xHotspot  : u32,
    yHotspot  : u32,
    hbmMask   : HBITMAP,
    hbmColor  : HBITMAP,
    wResID    : u16,
    szModName : [260]CHAR,
    szResName : [260]CHAR,
 };

 ICONINFOEXW :: struct {
    cbSize    : u32,
    fIcon     : BOOL,
    xHotspot  : u32,
    yHotspot  : u32,
    hbmMask   : HBITMAP,
    hbmColor  : HBITMAP,
    wResID    : u16,
    szModName : [260]WCHAR,
    szResName : [260]WCHAR,
 };
 PICONINFOEXW :: ^struct {
    cbSize    : u32,
    fIcon     : BOOL,
    xHotspot  : u32,
    yHotspot  : u32,
    hbmMask   : HBITMAP,
    hbmColor  : HBITMAP,
    wResID    : u16,
    szModName : [260]WCHAR,
    szResName : [260]WCHAR,
 };

 ICONINFOEX :: ICONINFOEXA;

 PICONINFOEX :: PICONINFOEXA;

 EDIT_CONTROL_FEATURE :: enum {
    EDIT_CONTROL_FEATURE_ENTERPRISE_DATA_PROTECTION_PASTE_SUPPORT = 0,
    EDIT_CONTROL_FEATURE_PASTE_NOTIFICATIONS = 1,
 };

 SCROLLINFO :: struct {
    cbSize    : UINT,
    fMask     : UINT,
    nMin      : i32,
    nMax      : i32,
    nPage     : UINT,
    nPos      : i32,
    nTrackPos : i32,
 };
 LPSCROLLINFO :: ^struct {
    cbSize    : UINT,
    fMask     : UINT,
    nMin      : i32,
    nMax      : i32,
    nPage     : UINT,
    nPos      : i32,
    nTrackPos : i32,
 };

 LPCSCROLLINFO :: ^SCROLLINFO;

 MDICREATESTRUCTA :: struct {
    szClass : LPCSTR,
    szTitle : LPCSTR,
    hOwner  : HANDLE,
    x       : i32,
    y       : i32,
    cx      : i32,
    cy      : i32,
    style   : u32,
    lParam  : LPARAM,
 };
 LPMDICREATESTRUCTA :: ^struct {
    szClass : LPCSTR,
    szTitle : LPCSTR,
    hOwner  : HANDLE,
    x       : i32,
    y       : i32,
    cx      : i32,
    cy      : i32,
    style   : u32,
    lParam  : LPARAM,
 };

 MDICREATESTRUCTW :: struct {
    szClass : LPCWSTR,
    szTitle : LPCWSTR,
    hOwner  : HANDLE,
    x       : i32,
    y       : i32,
    cx      : i32,
    cy      : i32,
    style   : u32,
    lParam  : LPARAM,
 };
 LPMDICREATESTRUCTW :: ^struct {
    szClass : LPCWSTR,
    szTitle : LPCWSTR,
    hOwner  : HANDLE,
    x       : i32,
    y       : i32,
    cx      : i32,
    cy      : i32,
    style   : u32,
    lParam  : LPARAM,
 };

 MDICREATESTRUCT :: MDICREATESTRUCTA;

 LPMDICREATESTRUCT :: LPMDICREATESTRUCTA;

 CLIENTCREATESTRUCT :: struct {
    hWindowMenu  : HANDLE,
    idFirstChild : UINT,
 };
 LPCLIENTCREATESTRUCT :: ^struct {
    hWindowMenu  : HANDLE,
    idFirstChild : UINT,
 };

 HELPPOLY :: u32;

 MULTIKEYHELPA :: struct {
    mkSize      : u32,
    mkKeylist   : CHAR,
    szKeyphrase : [1]CHAR,
 };
 PMULTIKEYHELPA :: ^struct {
    mkSize      : u32,
    mkKeylist   : CHAR,
    szKeyphrase : [1]CHAR,
 };
 LPMULTIKEYHELPA :: ^struct {
    mkSize      : u32,
    mkKeylist   : CHAR,
    szKeyphrase : [1]CHAR,
 };

 MULTIKEYHELPW :: struct {
    mkSize      : u32,
    mkKeylist   : WCHAR,
    szKeyphrase : [1]WCHAR,
 };
 PMULTIKEYHELPW :: ^struct {
    mkSize      : u32,
    mkKeylist   : WCHAR,
    szKeyphrase : [1]WCHAR,
 };
 LPMULTIKEYHELPW :: ^struct {
    mkSize      : u32,
    mkKeylist   : WCHAR,
    szKeyphrase : [1]WCHAR,
 };

 MULTIKEYHELP :: MULTIKEYHELPA;

 PMULTIKEYHELP :: PMULTIKEYHELPA;

 LPMULTIKEYHELP :: LPMULTIKEYHELPA;

 HELPWININFOA :: struct {
    wStructSize : i32,
    x           : i32,
    y           : i32,
    dx          : i32,
    dy          : i32,
    wMax        : i32,
    rgchMember  : [2]CHAR,
 };
 PHELPWININFOA :: ^struct {
    wStructSize : i32,
    x           : i32,
    y           : i32,
    dx          : i32,
    dy          : i32,
    wMax        : i32,
    rgchMember  : [2]CHAR,
 };
 LPHELPWININFOA :: ^struct {
    wStructSize : i32,
    x           : i32,
    y           : i32,
    dx          : i32,
    dy          : i32,
    wMax        : i32,
    rgchMember  : [2]CHAR,
 };

 HELPWININFOW :: struct {
    wStructSize : i32,
    x           : i32,
    y           : i32,
    dx          : i32,
    dy          : i32,
    wMax        : i32,
    rgchMember  : [2]WCHAR,
 };
 PHELPWININFOW :: ^struct {
    wStructSize : i32,
    x           : i32,
    y           : i32,
    dx          : i32,
    dy          : i32,
    wMax        : i32,
    rgchMember  : [2]WCHAR,
 };
 LPHELPWININFOW :: ^struct {
    wStructSize : i32,
    x           : i32,
    y           : i32,
    dx          : i32,
    dy          : i32,
    wMax        : i32,
    rgchMember  : [2]WCHAR,
 };

 HELPWININFO :: HELPWININFOA;

 PHELPWININFO :: PHELPWININFOA;

 LPHELPWININFO :: LPHELPWININFOA;

 TOUCHPREDICTIONPARAMETERS :: struct {
    cbSize          : UINT,
    dwLatency       : UINT,
    dwSampleTime    : UINT,
    bUseHWTimeStamp : UINT,
 };
 PTOUCHPREDICTIONPARAMETERS :: ^struct {
    cbSize          : UINT,
    dwLatency       : UINT,
    dwSampleTime    : UINT,
    bUseHWTimeStamp : UINT,
 };

 HANDEDNESS :: enum {
    HANDEDNESS_LEFT = 0,
    HANDEDNESS_RIGHT,
 };
 PHANDEDNESS :: ^enum {
    HANDEDNESS_LEFT = 0,
    HANDEDNESS_RIGHT,
 };

 NONCLIENTMETRICSA :: struct {
    cbSize             : UINT,
    iBorderWidth       : i32,
    iScrollWidth       : i32,
    iScrollHeight      : i32,
    iCaptionWidth      : i32,
    iCaptionHeight     : i32,
    lfCaptionFont      : LOGFONTA,
    iSmCaptionWidth    : i32,
    iSmCaptionHeight   : i32,
    lfSmCaptionFont    : LOGFONTA,
    iMenuWidth         : i32,
    iMenuHeight        : i32,
    lfMenuFont         : LOGFONTA,
    lfStatusFont       : LOGFONTA,
    lfMessageFont      : LOGFONTA,
    iPaddedBorderWidth : i32,
 };
 PNONCLIENTMETRICSA :: ^struct {
    cbSize             : UINT,
    iBorderWidth       : i32,
    iScrollWidth       : i32,
    iScrollHeight      : i32,
    iCaptionWidth      : i32,
    iCaptionHeight     : i32,
    lfCaptionFont      : LOGFONTA,
    iSmCaptionWidth    : i32,
    iSmCaptionHeight   : i32,
    lfSmCaptionFont    : LOGFONTA,
    iMenuWidth         : i32,
    iMenuHeight        : i32,
    lfMenuFont         : LOGFONTA,
    lfStatusFont       : LOGFONTA,
    lfMessageFont      : LOGFONTA,
    iPaddedBorderWidth : i32,
 };
 LPNONCLIENTMETRICSA :: ^struct {
    cbSize             : UINT,
    iBorderWidth       : i32,
    iScrollWidth       : i32,
    iScrollHeight      : i32,
    iCaptionWidth      : i32,
    iCaptionHeight     : i32,
    lfCaptionFont      : LOGFONTA,
    iSmCaptionWidth    : i32,
    iSmCaptionHeight   : i32,
    lfSmCaptionFont    : LOGFONTA,
    iMenuWidth         : i32,
    iMenuHeight        : i32,
    lfMenuFont         : LOGFONTA,
    lfStatusFont       : LOGFONTA,
    lfMessageFont      : LOGFONTA,
    iPaddedBorderWidth : i32,
 };

 NONCLIENTMETRICSW :: struct {
    cbSize             : UINT,
    iBorderWidth       : i32,
    iScrollWidth       : i32,
    iScrollHeight      : i32,
    iCaptionWidth      : i32,
    iCaptionHeight     : i32,
    lfCaptionFont      : LOGFONTW,
    iSmCaptionWidth    : i32,
    iSmCaptionHeight   : i32,
    lfSmCaptionFont    : LOGFONTW,
    iMenuWidth         : i32,
    iMenuHeight        : i32,
    lfMenuFont         : LOGFONTW,
    lfStatusFont       : LOGFONTW,
    lfMessageFont      : LOGFONTW,
    iPaddedBorderWidth : i32,
 };
 PNONCLIENTMETRICSW :: ^struct {
    cbSize             : UINT,
    iBorderWidth       : i32,
    iScrollWidth       : i32,
    iScrollHeight      : i32,
    iCaptionWidth      : i32,
    iCaptionHeight     : i32,
    lfCaptionFont      : LOGFONTW,
    iSmCaptionWidth    : i32,
    iSmCaptionHeight   : i32,
    lfSmCaptionFont    : LOGFONTW,
    iMenuWidth         : i32,
    iMenuHeight        : i32,
    lfMenuFont         : LOGFONTW,
    lfStatusFont       : LOGFONTW,
    lfMessageFont      : LOGFONTW,
    iPaddedBorderWidth : i32,
 };
 LPNONCLIENTMETRICSW :: ^struct {
    cbSize             : UINT,
    iBorderWidth       : i32,
    iScrollWidth       : i32,
    iScrollHeight      : i32,
    iCaptionWidth      : i32,
    iCaptionHeight     : i32,
    lfCaptionFont      : LOGFONTW,
    iSmCaptionWidth    : i32,
    iSmCaptionHeight   : i32,
    lfSmCaptionFont    : LOGFONTW,
    iMenuWidth         : i32,
    iMenuHeight        : i32,
    lfMenuFont         : LOGFONTW,
    lfStatusFont       : LOGFONTW,
    lfMessageFont      : LOGFONTW,
    iPaddedBorderWidth : i32,
 };

 NONCLIENTMETRICS :: NONCLIENTMETRICSA;

 PNONCLIENTMETRICS :: PNONCLIENTMETRICSA;

 LPNONCLIENTMETRICS :: LPNONCLIENTMETRICSA;

 MINIMIZEDMETRICS :: struct {
    cbSize   : UINT,
    iWidth   : i32,
    iHorzGap : i32,
    iVertGap : i32,
    iArrange : i32,
 };
 PMINIMIZEDMETRICS :: ^struct {
    cbSize   : UINT,
    iWidth   : i32,
    iHorzGap : i32,
    iVertGap : i32,
    iArrange : i32,
 };
 LPMINIMIZEDMETRICS :: ^struct {
    cbSize   : UINT,
    iWidth   : i32,
    iHorzGap : i32,
    iVertGap : i32,
    iArrange : i32,
 };

 ICONMETRICSA :: struct {
    cbSize       : UINT,
    iHorzSpacing : i32,
    iVertSpacing : i32,
    iTitleWrap   : i32,
    lfFont       : LOGFONTA,
 };
 PICONMETRICSA :: ^struct {
    cbSize       : UINT,
    iHorzSpacing : i32,
    iVertSpacing : i32,
    iTitleWrap   : i32,
    lfFont       : LOGFONTA,
 };
 LPICONMETRICSA :: ^struct {
    cbSize       : UINT,
    iHorzSpacing : i32,
    iVertSpacing : i32,
    iTitleWrap   : i32,
    lfFont       : LOGFONTA,
 };

 ICONMETRICSW :: struct {
    cbSize       : UINT,
    iHorzSpacing : i32,
    iVertSpacing : i32,
    iTitleWrap   : i32,
    lfFont       : LOGFONTW,
 };
 PICONMETRICSW :: ^struct {
    cbSize       : UINT,
    iHorzSpacing : i32,
    iVertSpacing : i32,
    iTitleWrap   : i32,
    lfFont       : LOGFONTW,
 };
 LPICONMETRICSW :: ^struct {
    cbSize       : UINT,
    iHorzSpacing : i32,
    iVertSpacing : i32,
    iTitleWrap   : i32,
    lfFont       : LOGFONTW,
 };

 ICONMETRICS :: ICONMETRICSA;

 PICONMETRICS :: PICONMETRICSA;

 LPICONMETRICS :: LPICONMETRICSA;

 ANIMATIONINFO :: struct {
    cbSize      : UINT,
    iMinAnimate : i32,
 };
 LPANIMATIONINFO :: ^struct {
    cbSize      : UINT,
    iMinAnimate : i32,
 };

 SERIALKEYSA :: struct {
    cbSize         : UINT,
    dwFlags        : u32,
    lpszActivePort : LPSTR,
    lpszPort       : LPSTR,
    iBaudRate      : UINT,
    iPortState     : UINT,
    iActive        : UINT,
 };
 LPSERIALKEYSA :: ^struct {
    cbSize         : UINT,
    dwFlags        : u32,
    lpszActivePort : LPSTR,
    lpszPort       : LPSTR,
    iBaudRate      : UINT,
    iPortState     : UINT,
    iActive        : UINT,
 };

 SERIALKEYSW :: struct {
    cbSize         : UINT,
    dwFlags        : u32,
    lpszActivePort : LPWSTR,
    lpszPort       : LPWSTR,
    iBaudRate      : UINT,
    iPortState     : UINT,
    iActive        : UINT,
 };
 LPSERIALKEYSW :: ^struct {
    cbSize         : UINT,
    dwFlags        : u32,
    lpszActivePort : LPWSTR,
    lpszPort       : LPWSTR,
    iBaudRate      : UINT,
    iPortState     : UINT,
    iActive        : UINT,
 };

 SERIALKEYS :: SERIALKEYSA;

 LPSERIALKEYS :: LPSERIALKEYSA;

 HIGHCONTRASTA :: struct {
    cbSize            : UINT,
    dwFlags           : u32,
    lpszDefaultScheme : LPSTR,
 };
 LPHIGHCONTRASTA :: ^struct {
    cbSize            : UINT,
    dwFlags           : u32,
    lpszDefaultScheme : LPSTR,
 };

 HIGHCONTRASTW :: struct {
    cbSize            : UINT,
    dwFlags           : u32,
    lpszDefaultScheme : LPWSTR,
 };
 LPHIGHCONTRASTW :: ^struct {
    cbSize            : UINT,
    dwFlags           : u32,
    lpszDefaultScheme : LPWSTR,
 };

 HIGHCONTRAST :: HIGHCONTRASTA;

 LPHIGHCONTRAST :: LPHIGHCONTRASTA;

 VIDEOPARAMETERS :: struct {
    Guid                  : GUID,
    dwOffset              : ULONG,
    dwCommand             : ULONG,
    dwFlags               : ULONG,
    dwMode                : ULONG,
    dwTVStandard          : ULONG,
    dwAvailableModes      : ULONG,
    dwAvailableTVStandard : ULONG,
    dwFlickerFilter       : ULONG,
    dwOverScanX           : ULONG,
    dwOverScanY           : ULONG,
    dwMaxUnscaledX        : ULONG,
    dwMaxUnscaledY        : ULONG,
    dwPositionX           : ULONG,
    dwPositionY           : ULONG,
    dwBrightness          : ULONG,
    dwContrast            : ULONG,
    dwCPType              : ULONG,
    dwCPCommand           : ULONG,
    dwCPStandard          : ULONG,
    dwCPKey               : ULONG,
    bCP_APSTriggerBits    : ULONG,
    bOEMCopyProtection    : [256]UCHAR,
 };
 PVIDEOPARAMETERS :: ^struct {
    Guid                  : GUID,
    dwOffset              : ULONG,
    dwCommand             : ULONG,
    dwFlags               : ULONG,
    dwMode                : ULONG,
    dwTVStandard          : ULONG,
    dwAvailableModes      : ULONG,
    dwAvailableTVStandard : ULONG,
    dwFlickerFilter       : ULONG,
    dwOverScanX           : ULONG,
    dwOverScanY           : ULONG,
    dwMaxUnscaledX        : ULONG,
    dwMaxUnscaledY        : ULONG,
    dwPositionX           : ULONG,
    dwPositionY           : ULONG,
    dwBrightness          : ULONG,
    dwContrast            : ULONG,
    dwCPType              : ULONG,
    dwCPCommand           : ULONG,
    dwCPStandard          : ULONG,
    dwCPKey               : ULONG,
    bCP_APSTriggerBits    : ULONG,
    bOEMCopyProtection    : [256]UCHAR,
 };
 LPVIDEOPARAMETERS :: ^struct {
    Guid                  : GUID,
    dwOffset              : ULONG,
    dwCommand             : ULONG,
    dwFlags               : ULONG,
    dwMode                : ULONG,
    dwTVStandard          : ULONG,
    dwAvailableModes      : ULONG,
    dwAvailableTVStandard : ULONG,
    dwFlickerFilter       : ULONG,
    dwOverScanX           : ULONG,
    dwOverScanY           : ULONG,
    dwMaxUnscaledX        : ULONG,
    dwMaxUnscaledY        : ULONG,
    dwPositionX           : ULONG,
    dwPositionY           : ULONG,
    dwBrightness          : ULONG,
    dwContrast            : ULONG,
    dwCPType              : ULONG,
    dwCPCommand           : ULONG,
    dwCPStandard          : ULONG,
    dwCPKey               : ULONG,
    bCP_APSTriggerBits    : ULONG,
    bOEMCopyProtection    : [256]UCHAR,
 };

 FILTERKEYS :: struct {
    cbSize      : UINT,
    dwFlags     : u32,
    iWaitMSec   : u32,
    iDelayMSec  : u32,
    iRepeatMSec : u32,
    iBounceMSec : u32,
 };
 LPFILTERKEYS :: ^struct {
    cbSize      : UINT,
    dwFlags     : u32,
    iWaitMSec   : u32,
    iDelayMSec  : u32,
    iRepeatMSec : u32,
    iBounceMSec : u32,
 };

 STICKYKEYS :: struct {
    cbSize  : UINT,
    dwFlags : u32,
 };
 LPSTICKYKEYS :: ^struct {
    cbSize  : UINT,
    dwFlags : u32,
 };

 MOUSEKEYS :: struct {
    cbSize          : UINT,
    dwFlags         : u32,
    iMaxSpeed       : u32,
    iTimeToMaxSpeed : u32,
    iCtrlSpeed      : u32,
    dwReserved1     : u32,
    dwReserved2     : u32,
 };
 LPMOUSEKEYS :: ^struct {
    cbSize          : UINT,
    dwFlags         : u32,
    iMaxSpeed       : u32,
    iTimeToMaxSpeed : u32,
    iCtrlSpeed      : u32,
    dwReserved1     : u32,
    dwReserved2     : u32,
 };

 ACCESSTIMEOUT :: struct {
    cbSize       : UINT,
    dwFlags      : u32,
    iTimeOutMSec : u32,
 };
 LPACCESSTIMEOUT :: ^struct {
    cbSize       : UINT,
    dwFlags      : u32,
    iTimeOutMSec : u32,
 };

 SOUNDSENTRYA :: struct {
    cbSize                 : UINT,
    dwFlags                : u32,
    iFSTextEffect          : u32,
    iFSTextEffectMSec      : u32,
    iFSTextEffectColorBits : u32,
    iFSGrafEffect          : u32,
    iFSGrafEffectMSec      : u32,
    iFSGrafEffectColor     : u32,
    iWindowsEffect         : u32,
    iWindowsEffectMSec     : u32,
    lpszWindowsEffectDLL   : LPSTR,
    iWindowsEffectOrdinal  : u32,
 };
 LPSOUNDSENTRYA :: ^struct {
    cbSize                 : UINT,
    dwFlags                : u32,
    iFSTextEffect          : u32,
    iFSTextEffectMSec      : u32,
    iFSTextEffectColorBits : u32,
    iFSGrafEffect          : u32,
    iFSGrafEffectMSec      : u32,
    iFSGrafEffectColor     : u32,
    iWindowsEffect         : u32,
    iWindowsEffectMSec     : u32,
    lpszWindowsEffectDLL   : LPSTR,
    iWindowsEffectOrdinal  : u32,
 };

 SOUNDSENTRYW :: struct {
    cbSize                 : UINT,
    dwFlags                : u32,
    iFSTextEffect          : u32,
    iFSTextEffectMSec      : u32,
    iFSTextEffectColorBits : u32,
    iFSGrafEffect          : u32,
    iFSGrafEffectMSec      : u32,
    iFSGrafEffectColor     : u32,
    iWindowsEffect         : u32,
    iWindowsEffectMSec     : u32,
    lpszWindowsEffectDLL   : LPWSTR,
    iWindowsEffectOrdinal  : u32,
 };
 LPSOUNDSENTRYW :: ^struct {
    cbSize                 : UINT,
    dwFlags                : u32,
    iFSTextEffect          : u32,
    iFSTextEffectMSec      : u32,
    iFSTextEffectColorBits : u32,
    iFSGrafEffect          : u32,
    iFSGrafEffectMSec      : u32,
    iFSGrafEffectColor     : u32,
    iWindowsEffect         : u32,
    iWindowsEffectMSec     : u32,
    lpszWindowsEffectDLL   : LPWSTR,
    iWindowsEffectOrdinal  : u32,
 };

 SOUNDSENTRY :: SOUNDSENTRYA;

 LPSOUNDSENTRY :: LPSOUNDSENTRYA;

 TOGGLEKEYS :: struct {
    cbSize  : UINT,
    dwFlags : u32,
 };
 LPTOGGLEKEYS :: ^struct {
    cbSize  : UINT,
    dwFlags : u32,
 };

 AUDIODESCRIPTION :: struct {
    cbSize  : UINT,
    Enabled : BOOL,
    Locale  : LCID,
 };
 LPAUDIODESCRIPTION :: ^struct {
    cbSize  : UINT,
    Enabled : BOOL,
    Locale  : LCID,
 };

 MONITORINFO :: struct {
    cbSize    : u32,
    rcMonitor : RECT,
    rcWork    : RECT,
    dwFlags   : u32,
 };
 LPMONITORINFO :: ^struct {
    cbSize    : u32,
    rcMonitor : RECT,
    rcWork    : RECT,
    dwFlags   : u32,
 };

 MONITORINFOEXA :: struct {
    s        : MONITORINFO,
    szDevice : [32]CHAR,
 };
 LPMONITORINFOEXA :: ^struct {
    s        : MONITORINFO,
    szDevice : [32]CHAR,
 };

 MONITORINFOEXW :: struct {
    s        : MONITORINFO,
    szDevice : [32]WCHAR,
 };
 LPMONITORINFOEXW :: ^struct {
    s        : MONITORINFO,
    szDevice : [32]WCHAR,
 };

 MONITORINFOEX :: MONITORINFOEXA;

 LPMONITORINFOEX :: LPMONITORINFOEXA;

 MONITORENUMPROC :: (proc(HMONITOR, HDC, LPRECT, LPARAM) -> BOOL);

 WINEVENTPROC :: proc(hWinEventHook : HWINEVENTHOOK, event : u32, hwnd : HWND, idObject : LONG, idChild : LONG, idEventThread : u32, dwmsEventTime : u32);

 GUITHREADINFO :: struct {
    cbSize        : u32,
    flags         : u32,
    hwndActive    : HWND,
    hwndFocus     : HWND,
    hwndCapture   : HWND,
    hwndMenuOwner : HWND,
    hwndMoveSize  : HWND,
    hwndCaret     : HWND,
    rcCaret       : RECT,
 };
 PGUITHREADINFO :: ^struct {
    cbSize        : u32,
    flags         : u32,
    hwndActive    : HWND,
    hwndFocus     : HWND,
    hwndCapture   : HWND,
    hwndMenuOwner : HWND,
    hwndMoveSize  : HWND,
    hwndCaret     : HWND,
    rcCaret       : RECT,
 };
 LPGUITHREADINFO :: ^struct {
    cbSize        : u32,
    flags         : u32,
    hwndActive    : HWND,
    hwndFocus     : HWND,
    hwndCapture   : HWND,
    hwndMenuOwner : HWND,
    hwndMoveSize  : HWND,
    hwndCaret     : HWND,
    rcCaret       : RECT,
 };

 CURSORINFO :: struct {
    cbSize      : u32,
    flags       : u32,
    hCursor     : HCURSOR,
    ptScreenPos : POINT,
 };
 PCURSORINFO :: ^struct {
    cbSize      : u32,
    flags       : u32,
    hCursor     : HCURSOR,
    ptScreenPos : POINT,
 };
 LPCURSORINFO :: ^struct {
    cbSize      : u32,
    flags       : u32,
    hCursor     : HCURSOR,
    ptScreenPos : POINT,
 };

 WINDOWINFO :: struct {
    cbSize          : u32,
    rcWindow        : RECT,
    rcClient        : RECT,
    dwStyle         : u32,
    dwExStyle       : u32,
    dwWindowStatus  : u32,
    cxWindowBorders : UINT,
    cyWindowBorders : UINT,
    atomWindowType  : ATOM,
    wCreatorVersion : u16,
 };
 PWINDOWINFO :: ^struct {
    cbSize          : u32,
    rcWindow        : RECT,
    rcClient        : RECT,
    dwStyle         : u32,
    dwExStyle       : u32,
    dwWindowStatus  : u32,
    cxWindowBorders : UINT,
    cyWindowBorders : UINT,
    atomWindowType  : ATOM,
    wCreatorVersion : u16,
 };
 LPWINDOWINFO :: ^struct {
    cbSize          : u32,
    rcWindow        : RECT,
    rcClient        : RECT,
    dwStyle         : u32,
    dwExStyle       : u32,
    dwWindowStatus  : u32,
    cxWindowBorders : UINT,
    cyWindowBorders : UINT,
    atomWindowType  : ATOM,
    wCreatorVersion : u16,
 };

 TITLEBARINFO :: struct {
    cbSize     : u32,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]u32,
 };
 PTITLEBARINFO :: ^struct {
    cbSize     : u32,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]u32,
 };
 LPTITLEBARINFO :: ^struct {
    cbSize     : u32,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]u32,
 };

 TITLEBARINFOEX :: struct {
    cbSize     : u32,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]u32,
    rgrect     : [5 + 1]RECT,
 };
 PTITLEBARINFOEX :: ^struct {
    cbSize     : u32,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]u32,
    rgrect     : [5 + 1]RECT,
 };
 LPTITLEBARINFOEX :: ^struct {
    cbSize     : u32,
    rcTitleBar : RECT,
    rgstate    : [5 + 1]u32,
    rgrect     : [5 + 1]RECT,
 };

 MENUBARINFO :: struct {
    cbSize      : u32,
    rcBar       : RECT,
    hMenu       : HMENU,
    hwndMenu    : HWND,
    fBarFocused : ,
    fFocused    : ,
 };
 PMENUBARINFO :: ^struct {
    cbSize      : u32,
    rcBar       : RECT,
    hMenu       : HMENU,
    hwndMenu    : HWND,
    fBarFocused : ,
    fFocused    : ,
 };
 LPMENUBARINFO :: ^struct {
    cbSize      : u32,
    rcBar       : RECT,
    hMenu       : HMENU,
    hwndMenu    : HWND,
    fBarFocused : ,
    fFocused    : ,
 };

 SCROLLBARINFO :: struct {
    cbSize        : u32,
    rcScrollBar   : RECT,
    dxyLineButton : i32,
    xyThumbTop    : i32,
    xyThumbBottom : i32,
    reserved      : i32,
    rgstate       : [5 + 1]u32,
 };
 PSCROLLBARINFO :: ^struct {
    cbSize        : u32,
    rcScrollBar   : RECT,
    dxyLineButton : i32,
    xyThumbTop    : i32,
    xyThumbBottom : i32,
    reserved      : i32,
    rgstate       : [5 + 1]u32,
 };
 LPSCROLLBARINFO :: ^struct {
    cbSize        : u32,
    rcScrollBar   : RECT,
    dxyLineButton : i32,
    xyThumbTop    : i32,
    xyThumbBottom : i32,
    reserved      : i32,
    rgstate       : [5 + 1]u32,
 };

 COMBOBOXINFO :: struct {
    cbSize      : u32,
    rcItem      : RECT,
    rcButton    : RECT,
    stateButton : u32,
    hwndCombo   : HWND,
    hwndItem    : HWND,
    hwndList    : HWND,
 };
 PCOMBOBOXINFO :: ^struct {
    cbSize      : u32,
    rcItem      : RECT,
    rcButton    : RECT,
    stateButton : u32,
    hwndCombo   : HWND,
    hwndItem    : HWND,
    hwndList    : HWND,
 };
 LPCOMBOBOXINFO :: ^struct {
    cbSize      : u32,
    rcItem      : RECT,
    rcButton    : RECT,
    stateButton : u32,
    hwndCombo   : HWND,
    hwndItem    : HWND,
    hwndList    : HWND,
 };

 ALTTABINFO :: struct {
    cbSize    : u32,
    cItems    : i32,
    cColumns  : i32,
    cRows     : i32,
    iColFocus : i32,
    iRowFocus : i32,
    cxItem    : i32,
    cyItem    : i32,
    ptStart   : POINT,
 };
 PALTTABINFO :: ^struct {
    cbSize    : u32,
    cItems    : i32,
    cColumns  : i32,
    cRows     : i32,
    iColFocus : i32,
    iRowFocus : i32,
    cxItem    : i32,
    cyItem    : i32,
    ptStart   : POINT,
 };
 LPALTTABINFO :: ^struct {
    cbSize    : u32,
    cItems    : i32,
    cColumns  : i32,
    cRows     : i32,
    iColFocus : i32,
    iRowFocus : i32,
    cxItem    : i32,
    cyItem    : i32,
    ptStart   : POINT,
 };

 HRAWINPUT__ :: struct {
    unused : i32,
 };

 HRAWINPUT :: ^HRAWINPUT__;

 RAWINPUTHEADER :: struct {
    dwType  : u32,
    dwSize  : u32,
    hDevice : HANDLE,
    wParam  : WPARAM,
 };
 PRAWINPUTHEADER :: ^struct {
    dwType  : u32,
    dwSize  : u32,
    hDevice : HANDLE,
    wParam  : WPARAM,
 };
 LPRAWINPUTHEADER :: ^struct {
    dwType  : u32,
    dwSize  : u32,
    hDevice : HANDLE,
    wParam  : WPARAM,
 };

 RAWMOUSE :: struct {
    usFlags            : USHORT,
    u : struct #raw_union {
        ulButtons : ULONG,
        s : struct {
            usButtonFlags : USHORT,
            usButtonData  : USHORT,
        },
    },
    ulRawButtons       : ULONG,
    lLastX             : LONG,
    lLastY             : LONG,
    ulExtraInformation : ULONG,
 };
 PRAWMOUSE :: ^struct {
    usFlags            : USHORT,
    u : struct #raw_union {
        ulButtons : ULONG,
        s : struct {
            usButtonFlags : USHORT,
            usButtonData  : USHORT,
        },
    },
    ulRawButtons       : ULONG,
    lLastX             : LONG,
    lLastY             : LONG,
    ulExtraInformation : ULONG,
 };
 LPRAWMOUSE :: ^struct {
    usFlags            : USHORT,
    u : struct #raw_union {
        ulButtons : ULONG,
        s : struct {
            usButtonFlags : USHORT,
            usButtonData  : USHORT,
        },
    },
    ulRawButtons       : ULONG,
    lLastX             : LONG,
    lLastY             : LONG,
    ulExtraInformation : ULONG,
 };

 RAWKEYBOARD :: struct {
    MakeCode         : USHORT,
    Flags            : USHORT,
    Reserved         : USHORT,
    VKey             : USHORT,
    Message          : UINT,
    ExtraInformation : ULONG,
 };
 PRAWKEYBOARD :: ^struct {
    MakeCode         : USHORT,
    Flags            : USHORT,
    Reserved         : USHORT,
    VKey             : USHORT,
    Message          : UINT,
    ExtraInformation : ULONG,
 };
 LPRAWKEYBOARD :: ^struct {
    MakeCode         : USHORT,
    Flags            : USHORT,
    Reserved         : USHORT,
    VKey             : USHORT,
    Message          : UINT,
    ExtraInformation : ULONG,
 };

 RAWHID :: struct {
    dwSizeHid : u32,
    dwCount   : u32,
    bRawData  : [1]BYTE,
 };
 PRAWHID :: ^struct {
    dwSizeHid : u32,
    dwCount   : u32,
    bRawData  : [1]BYTE,
 };
 LPRAWHID :: ^struct {
    dwSizeHid : u32,
    dwCount   : u32,
    bRawData  : [1]BYTE,
 };

 RAWINPUT :: struct {
    header : RAWINPUTHEADER,
    data : struct #raw_union {
        mouse    : RAWMOUSE,
        keyboard : RAWKEYBOARD,
        hid      : RAWHID,
    },
 };
 PRAWINPUT :: ^struct {
    header : RAWINPUTHEADER,
    data : struct #raw_union {
        mouse    : RAWMOUSE,
        keyboard : RAWKEYBOARD,
        hid      : RAWHID,
    },
 };
 LPRAWINPUT :: ^struct {
    header : RAWINPUTHEADER,
    data : struct #raw_union {
        mouse    : RAWMOUSE,
        keyboard : RAWKEYBOARD,
        hid      : RAWHID,
    },
 };

 RID_DEVICE_INFO_MOUSE :: struct {
    dwId                : u32,
    dwNumberOfButtons   : u32,
    dwSampleRate        : u32,
    fHasHorizontalWheel : BOOL,
 };
 PRID_DEVICE_INFO_MOUSE :: ^struct {
    dwId                : u32,
    dwNumberOfButtons   : u32,
    dwSampleRate        : u32,
    fHasHorizontalWheel : BOOL,
 };

 RID_DEVICE_INFO_KEYBOARD :: struct {
    dwType                 : u32,
    dwSubType              : u32,
    dwKeyboardMode         : u32,
    dwNumberOfFunctionKeys : u32,
    dwNumberOfIndicators   : u32,
    dwNumberOfKeysTotal    : u32,
 };
 PRID_DEVICE_INFO_KEYBOARD :: ^struct {
    dwType                 : u32,
    dwSubType              : u32,
    dwKeyboardMode         : u32,
    dwNumberOfFunctionKeys : u32,
    dwNumberOfIndicators   : u32,
    dwNumberOfKeysTotal    : u32,
 };

 RID_DEVICE_INFO_HID :: struct {
    dwVendorId      : u32,
    dwProductId     : u32,
    dwVersionNumber : u32,
    usUsagePage     : USHORT,
    usUsage         : USHORT,
 };
 PRID_DEVICE_INFO_HID :: ^struct {
    dwVendorId      : u32,
    dwProductId     : u32,
    dwVersionNumber : u32,
    usUsagePage     : USHORT,
    usUsage         : USHORT,
 };

 RID_DEVICE_INFO :: struct {
    cbSize : u32,
    dwType : u32,
    u : struct #raw_union {
        mouse    : RID_DEVICE_INFO_MOUSE,
        keyboard : RID_DEVICE_INFO_KEYBOARD,
        hid      : RID_DEVICE_INFO_HID,
    },
 };
 PRID_DEVICE_INFO :: ^struct {
    cbSize : u32,
    dwType : u32,
    u : struct #raw_union {
        mouse    : RID_DEVICE_INFO_MOUSE,
        keyboard : RID_DEVICE_INFO_KEYBOARD,
        hid      : RID_DEVICE_INFO_HID,
    },
 };
 LPRID_DEVICE_INFO :: ^struct {
    cbSize : u32,
    dwType : u32,
    u : struct #raw_union {
        mouse    : RID_DEVICE_INFO_MOUSE,
        keyboard : RID_DEVICE_INFO_KEYBOARD,
        hid      : RID_DEVICE_INFO_HID,
    },
 };

 RAWINPUTDEVICE :: struct {
    usUsagePage : USHORT,
    usUsage     : USHORT,
    dwFlags     : u32,
    hwndTarget  : HWND,
 };
 PRAWINPUTDEVICE :: ^struct {
    usUsagePage : USHORT,
    usUsage     : USHORT,
    dwFlags     : u32,
    hwndTarget  : HWND,
 };
 LPRAWINPUTDEVICE :: ^struct {
    usUsagePage : USHORT,
    usUsage     : USHORT,
    dwFlags     : u32,
    hwndTarget  : HWND,
 };

 PCRAWINPUTDEVICE :: ^RAWINPUTDEVICE;

 RAWINPUTDEVICELIST :: struct {
    hDevice : HANDLE,
    dwType  : u32,
 };
 PRAWINPUTDEVICELIST :: ^struct {
    hDevice : HANDLE,
    dwType  : u32,
 };

 POINTER_DEVICE_TYPE :: enum {
    POINTER_DEVICE_TYPE_INTEGRATED_PEN = 0x00000001,
    POINTER_DEVICE_TYPE_EXTERNAL_PEN = 0x00000002,
    POINTER_DEVICE_TYPE_TOUCH = 0x00000003,
    POINTER_DEVICE_TYPE_TOUCH_PAD = 0x00000004,
    POINTER_DEVICE_TYPE_MAX = 0xFFFFFFFF,
 };

 POINTER_DEVICE_INFO :: struct {
    displayOrientation : u32,
    device             : HANDLE,
    pointerDeviceType  : POINTER_DEVICE_TYPE,
    monitor            : HMONITOR,
    startingCursorId   : ULONG,
    maxActiveContacts  : USHORT,
    productString      : [520]WCHAR,
 };

 POINTER_DEVICE_PROPERTY :: struct {
    logicalMin   : INT32,
    logicalMax   : INT32,
    physicalMin  : INT32,
    physicalMax  : INT32,
    unit         : UINT32,
    unitExponent : UINT32,
    usagePageId  : USHORT,
    usageId      : USHORT,
 };

 POINTER_DEVICE_CURSOR_TYPE :: enum {
    POINTER_DEVICE_CURSOR_TYPE_UNKNOWN = 0x00000000,
    POINTER_DEVICE_CURSOR_TYPE_TIP = 0x00000001,
    POINTER_DEVICE_CURSOR_TYPE_ERASER = 0x00000002,
    POINTER_DEVICE_CURSOR_TYPE_MAX = 0xFFFFFFFF,
 };

 POINTER_DEVICE_CURSOR_INFO :: struct {
    cursorId : UINT32,
    cursor   : POINTER_DEVICE_CURSOR_TYPE,
 };

 CHANGEFILTERSTRUCT :: struct {
    cbSize    : u32,
    ExtStatus : u32,
 };
 PCHANGEFILTERSTRUCT :: ^struct {
    cbSize    : u32,
    ExtStatus : u32,
 };

 HGESTUREINFO__ :: struct {
    unused : i32,
 };

 HGESTUREINFO :: ^HGESTUREINFO__;

 GESTUREINFO :: struct {
    cbSize       : UINT,
    dwFlags      : u32,
    dwID         : u32,
    hwndTarget   : HWND,
    ptsLocation  : POINTS,
    dwInstanceID : u32,
    dwSequenceID : u32,
    ullArguments : ULONGLONG,
    cbExtraArgs  : UINT,
 };
 PGESTUREINFO :: ^struct {
    cbSize       : UINT,
    dwFlags      : u32,
    dwID         : u32,
    hwndTarget   : HWND,
    ptsLocation  : POINTS,
    dwInstanceID : u32,
    dwSequenceID : u32,
    ullArguments : ULONGLONG,
    cbExtraArgs  : UINT,
 };

 PCGESTUREINFO :: ^GESTUREINFO;

 GESTURENOTIFYSTRUCT :: struct {
    cbSize       : UINT,
    dwFlags      : u32,
    hwndTarget   : HWND,
    ptsLocation  : POINTS,
    dwInstanceID : u32,
 };
 PGESTURENOTIFYSTRUCT :: ^struct {
    cbSize       : UINT,
    dwFlags      : u32,
    hwndTarget   : HWND,
    ptsLocation  : POINTS,
    dwInstanceID : u32,
 };

 GESTURECONFIG :: struct {
    dwID    : u32,
    dwWant  : u32,
    dwBlock : u32,
 };
 PGESTURECONFIG :: ^struct {
    dwID    : u32,
    dwWant  : u32,
    dwBlock : u32,
 };

 INPUT_MESSAGE_DEVICE_TYPE :: enum {
    IMDT_UNAVAILABLE = 0x00000000,
    IMDT_KEYBOARD = 0x00000001,
    IMDT_MOUSE = 0x00000002,
    IMDT_TOUCH = 0x00000004,
    IMDT_PEN = 0x00000008,
    IMDT_TOUCHPAD = 0x00000010,
 };

 INPUT_MESSAGE_ORIGIN_ID :: enum {
    IMO_UNAVAILABLE = 0x00000000,
    IMO_HARDWARE = 0x00000001,
    IMO_INJECTED = 0x00000002,
    IMO_SYSTEM = 0x00000004,
 };

 INPUT_MESSAGE_SOURCE :: struct {
    deviceType : INPUT_MESSAGE_DEVICE_TYPE,
    originId   : INPUT_MESSAGE_ORIGIN_ID,
 };

 AR_STATE :: enum {
    AR_ENABLED = 0x0,
    AR_DISABLED = 0x1,
    AR_SUPPRESSED = 0x2,
    AR_REMOTESESSION = 0x4,
    AR_MULTIMON = 0x8,
    AR_NOSENSOR = 0x10,
    AR_NOT_SUPPORTED = 0x20,
    AR_DOCKED = 0x40,
    AR_LAPTOP = 0x80,
 };
 PAR_STATE :: ^enum {
    AR_ENABLED = 0x0,
    AR_DISABLED = 0x1,
    AR_SUPPRESSED = 0x2,
    AR_REMOTESESSION = 0x4,
    AR_MULTIMON = 0x8,
    AR_NOSENSOR = 0x10,
    AR_NOT_SUPPORTED = 0x20,
    AR_DOCKED = 0x40,
    AR_LAPTOP = 0x80,
 };

 ORIENTATION_PREFERENCE :: enum {
    ORIENTATION_PREFERENCE_NONE = 0x0,
    ORIENTATION_PREFERENCE_LANDSCAPE = 0x1,
    ORIENTATION_PREFERENCE_PORTRAIT = 0x2,
    ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED = 0x4,
    ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED = 0x8,
 };

 LGRPID :: u32;

 LCTYPE :: u32;

 CALTYPE :: u32;

 CALID :: u32;

 CPINFO :: struct {
    MaxCharSize : UINT,
    DefaultChar : [2]BYTE,
    LeadByte    : [12]BYTE,
 };
 LPCPINFO :: ^struct {
    MaxCharSize : UINT,
    DefaultChar : [2]BYTE,
    LeadByte    : [12]BYTE,
 };

 GEOTYPE :: u32;

 GEOCLASS :: u32;

 GEOID :: LONG;

 CPINFOEXA :: struct {
    MaxCharSize        : UINT,
    DefaultChar        : [2]BYTE,
    LeadByte           : [12]BYTE,
    UnicodeDefaultChar : WCHAR,
    CodePage           : UINT,
    CodePageName       : [260]CHAR,
 };
 LPCPINFOEXA :: ^struct {
    MaxCharSize        : UINT,
    DefaultChar        : [2]BYTE,
    LeadByte           : [12]BYTE,
    UnicodeDefaultChar : WCHAR,
    CodePage           : UINT,
    CodePageName       : [260]CHAR,
 };

 CPINFOEXW :: struct {
    MaxCharSize        : UINT,
    DefaultChar        : [2]BYTE,
    LeadByte           : [12]BYTE,
    UnicodeDefaultChar : WCHAR,
    CodePage           : UINT,
    CodePageName       : [260]WCHAR,
 };
 LPCPINFOEXW :: ^struct {
    MaxCharSize        : UINT,
    DefaultChar        : [2]BYTE,
    LeadByte           : [12]BYTE,
    UnicodeDefaultChar : WCHAR,
    CodePage           : UINT,
    CodePageName       : [260]WCHAR,
 };

 CPINFOEX :: CPINFOEXA;

 LPCPINFOEX :: LPCPINFOEXA;

 NUMBERFMTA :: struct {
    NumDigits     : UINT,
    LeadingZero   : UINT,
    Grouping      : UINT,
    lpDecimalSep  : LPSTR,
    lpThousandSep : LPSTR,
    NegativeOrder : UINT,
 };
 LPNUMBERFMTA :: ^struct {
    NumDigits     : UINT,
    LeadingZero   : UINT,
    Grouping      : UINT,
    lpDecimalSep  : LPSTR,
    lpThousandSep : LPSTR,
    NegativeOrder : UINT,
 };

 NUMBERFMTW :: struct {
    NumDigits     : UINT,
    LeadingZero   : UINT,
    Grouping      : UINT,
    lpDecimalSep  : LPWSTR,
    lpThousandSep : LPWSTR,
    NegativeOrder : UINT,
 };
 LPNUMBERFMTW :: ^struct {
    NumDigits     : UINT,
    LeadingZero   : UINT,
    Grouping      : UINT,
    lpDecimalSep  : LPWSTR,
    lpThousandSep : LPWSTR,
    NegativeOrder : UINT,
 };

 NUMBERFMT :: NUMBERFMTA;

 LPNUMBERFMT :: LPNUMBERFMTA;

 CURRENCYFMTA :: struct {
    NumDigits        : UINT,
    LeadingZero      : UINT,
    Grouping         : UINT,
    lpDecimalSep     : LPSTR,
    lpThousandSep    : LPSTR,
    NegativeOrder    : UINT,
    PositiveOrder    : UINT,
    lpCurrencySymbol : LPSTR,
 };
 LPCURRENCYFMTA :: ^struct {
    NumDigits        : UINT,
    LeadingZero      : UINT,
    Grouping         : UINT,
    lpDecimalSep     : LPSTR,
    lpThousandSep    : LPSTR,
    NegativeOrder    : UINT,
    PositiveOrder    : UINT,
    lpCurrencySymbol : LPSTR,
 };

 CURRENCYFMTW :: struct {
    NumDigits        : UINT,
    LeadingZero      : UINT,
    Grouping         : UINT,
    lpDecimalSep     : LPWSTR,
    lpThousandSep    : LPWSTR,
    NegativeOrder    : UINT,
    PositiveOrder    : UINT,
    lpCurrencySymbol : LPWSTR,
 };
 LPCURRENCYFMTW :: ^struct {
    NumDigits        : UINT,
    LeadingZero      : UINT,
    Grouping         : UINT,
    lpDecimalSep     : LPWSTR,
    lpThousandSep    : LPWSTR,
    NegativeOrder    : UINT,
    PositiveOrder    : UINT,
    lpCurrencySymbol : LPWSTR,
 };

 CURRENCYFMT :: CURRENCYFMTA;

 LPCURRENCYFMT :: LPCURRENCYFMTA;

 SYSNLS_FUNCTION :: enum {
    COMPARE_STRING = 0x0001,
 };

 NLS_FUNCTION :: u32;

 NLSVERSIONINFO :: struct {
    dwNLSVersionInfoSize : u32,
    dwNLSVersion         : u32,
    dwDefinedVersion     : u32,
    dwEffectiveId        : u32,
    guidCustomVersion    : GUID,
 };
 LPNLSVERSIONINFO :: ^struct {
    dwNLSVersionInfoSize : u32,
    dwNLSVersion         : u32,
    dwDefinedVersion     : u32,
    dwEffectiveId        : u32,
    guidCustomVersion    : GUID,
 };

 NLSVERSIONINFOEX :: struct {
    dwNLSVersionInfoSize : u32,
    dwNLSVersion         : u32,
    dwDefinedVersion     : u32,
    dwEffectiveId        : u32,
    guidCustomVersion    : GUID,
 };
 LPNLSVERSIONINFOEX :: ^struct {
    dwNLSVersionInfoSize : u32,
    dwNLSVersion         : u32,
    dwDefinedVersion     : u32,
    dwEffectiveId        : u32,
    guidCustomVersion    : GUID,
 };

 SYSGEOTYPE :: enum {
    GEO_NATION = 0x0001,
    GEO_LATITUDE = 0x0002,
    GEO_LONGITUDE = 0x0003,
    GEO_ISO2 = 0x0004,
    GEO_ISO3 = 0x0005,
    GEO_RFC1766 = 0x0006,
    GEO_LCID = 0x0007,
    GEO_FRIENDLYNAME = 0x0008,
    GEO_OFFICIALNAME = 0x0009,
    GEO_TIMEZONES = 0x000A,
    GEO_OFFICIALLANGUAGES = 0x000B,
    GEO_ISO_UN_NUMBER = 0x000C,
    GEO_PARENT = 0x000D,
    GEO_DIALINGCODE = 0x000E,
    GEO_CURRENCYCODE = 0x000F,
    GEO_CURRENCYSYMBOL = 0x0010,
    GEO_NAME = 0x0011,
    GEO_ID = 0x0012,
 };

 SYSGEOCLASS :: enum {
    GEOCLASS_NATION = 16,
    GEOCLASS_REGION = 14,
    GEOCLASS_ALL = 0,
 };

 NORM_FORM :: enum {
    NormalizationOther = 0,
    NormalizationC = 0x1,
    NormalizationD = 0x2,
    NormalizationKC = 0x5,
    NormalizationKD = 0x6,
 };

 LANGUAGEGROUP_ENUMPROCA :: (proc(LGRPID, LPSTR, LPSTR, u32, LONG_PTR) -> BOOL);

 LANGGROUPLOCALE_ENUMPROCA :: (proc(LGRPID, LCID, LPSTR, LONG_PTR) -> BOOL);

 UILANGUAGE_ENUMPROCA :: (proc(LPSTR, LONG_PTR) -> BOOL);

 CODEPAGE_ENUMPROCA :: (proc(LPSTR) -> BOOL);

 DATEFMT_ENUMPROCA :: (proc(LPSTR) -> BOOL);

 DATEFMT_ENUMPROCEXA :: (proc(LPSTR, CALID) -> BOOL);

 TIMEFMT_ENUMPROCA :: (proc(LPSTR) -> BOOL);

 CALINFO_ENUMPROCA :: (proc(LPSTR) -> BOOL);

 CALINFO_ENUMPROCEXA :: (proc(LPSTR, CALID) -> BOOL);

 LOCALE_ENUMPROCA :: (proc(LPSTR) -> BOOL);

 LOCALE_ENUMPROCW :: (proc(LPWSTR) -> BOOL);

 LANGUAGEGROUP_ENUMPROCW :: (proc(LGRPID, LPWSTR, LPWSTR, u32, LONG_PTR) -> BOOL);

 LANGGROUPLOCALE_ENUMPROCW :: (proc(LGRPID, LCID, LPWSTR, LONG_PTR) -> BOOL);

 UILANGUAGE_ENUMPROCW :: (proc(LPWSTR, LONG_PTR) -> BOOL);

 CODEPAGE_ENUMPROCW :: (proc(LPWSTR) -> BOOL);

 DATEFMT_ENUMPROCW :: (proc(LPWSTR) -> BOOL);

 DATEFMT_ENUMPROCEXW :: (proc(LPWSTR, CALID) -> BOOL);

 TIMEFMT_ENUMPROCW :: (proc(LPWSTR) -> BOOL);

 CALINFO_ENUMPROCW :: (proc(LPWSTR) -> BOOL);

 CALINFO_ENUMPROCEXW :: (proc(LPWSTR, CALID) -> BOOL);

 GEO_ENUMPROC :: (proc(GEOID) -> BOOL);

 GEO_ENUMNAMEPROC :: (proc(PWSTR, LPARAM) -> BOOL);

 FILEMUIINFO :: struct {
    dwSize               : u32,
    dwVersion            : u32,
    dwFileType           : u32,
    pChecksum            : [16]BYTE,
    pServiceChecksum     : [16]BYTE,
    dwLanguageNameOffset : u32,
    dwTypeIDMainSize     : u32,
    dwTypeIDMainOffset   : u32,
    dwTypeNameMainOffset : u32,
    dwTypeIDMUISize      : u32,
    dwTypeIDMUIOffset    : u32,
    dwTypeNameMUIOffset  : u32,
    abBuffer             : [8]BYTE,
 };
 PFILEMUIINFO :: ^struct {
    dwSize               : u32,
    dwVersion            : u32,
    dwFileType           : u32,
    pChecksum            : [16]BYTE,
    pServiceChecksum     : [16]BYTE,
    dwLanguageNameOffset : u32,
    dwTypeIDMainSize     : u32,
    dwTypeIDMainOffset   : u32,
    dwTypeNameMainOffset : u32,
    dwTypeIDMUISize      : u32,
    dwTypeIDMUIOffset    : u32,
    dwTypeNameMUIOffset  : u32,
    abBuffer             : [8]BYTE,
 };

 CALINFO_ENUMPROCEXEX :: (proc(LPWSTR, CALID, LPWSTR, LPARAM) -> BOOL);

 DATEFMT_ENUMPROCEXEX :: (proc(LPWSTR, CALID, LPARAM) -> BOOL);

 TIMEFMT_ENUMPROCEX :: (proc(LPWSTR, LPARAM) -> BOOL);

 LOCALE_ENUMPROCEX :: (proc(LPWSTR, u32, LPARAM) -> BOOL);

 COORD :: struct {
    X : SHORT,
    Y : SHORT,
 };
 PCOORD :: ^struct {
    X : SHORT,
    Y : SHORT,
 };

 SMALL_RECT :: struct {
    Left   : SHORT,
    Top    : SHORT,
    Right  : SHORT,
    Bottom : SHORT,
 };
 PSMALL_RECT :: ^struct {
    Left   : SHORT,
    Top    : SHORT,
    Right  : SHORT,
    Bottom : SHORT,
 };

 KEY_EVENT_RECORD :: struct {
    bKeyDown          : BOOL,
    wRepeatCount      : u16,
    wVirtualKeyCode   : u16,
    wVirtualScanCode  : u16,
    uChar : struct #raw_union {
        UnicodeChar : WCHAR,
        AsciiChar   : CHAR,
    },
    dwControlKeyState : u32,
 };
 PKEY_EVENT_RECORD :: ^struct {
    bKeyDown          : BOOL,
    wRepeatCount      : u16,
    wVirtualKeyCode   : u16,
    wVirtualScanCode  : u16,
    uChar : struct #raw_union {
        UnicodeChar : WCHAR,
        AsciiChar   : CHAR,
    },
    dwControlKeyState : u32,
 };

 MOUSE_EVENT_RECORD :: struct {
    dwMousePosition   : COORD,
    dwButtonState     : u32,
    dwControlKeyState : u32,
    dwEventFlags      : u32,
 };
 PMOUSE_EVENT_RECORD :: ^struct {
    dwMousePosition   : COORD,
    dwButtonState     : u32,
    dwControlKeyState : u32,
    dwEventFlags      : u32,
 };

 WINDOW_BUFFER_SIZE_RECORD :: struct {
    dwSize : COORD,
 };
 PWINDOW_BUFFER_SIZE_RECORD :: ^struct {
    dwSize : COORD,
 };

 MENU_EVENT_RECORD :: struct {
    dwCommandId : UINT,
 };
 PMENU_EVENT_RECORD :: ^struct {
    dwCommandId : UINT,
 };

 FOCUS_EVENT_RECORD :: struct {
    bSetFocus : BOOL,
 };
 PFOCUS_EVENT_RECORD :: ^struct {
    bSetFocus : BOOL,
 };

 INPUT_RECORD :: struct {
    EventType : u16,
    Event : struct #raw_union {
        KeyEvent              : KEY_EVENT_RECORD,
        MouseEvent            : MOUSE_EVENT_RECORD,
        WindowBufferSizeEvent : WINDOW_BUFFER_SIZE_RECORD,
        MenuEvent             : MENU_EVENT_RECORD,
        FocusEvent            : FOCUS_EVENT_RECORD,
    },
 };
 PINPUT_RECORD :: ^struct {
    EventType : u16,
    Event : struct #raw_union {
        KeyEvent              : KEY_EVENT_RECORD,
        MouseEvent            : MOUSE_EVENT_RECORD,
        WindowBufferSizeEvent : WINDOW_BUFFER_SIZE_RECORD,
        MenuEvent             : MENU_EVENT_RECORD,
        FocusEvent            : FOCUS_EVENT_RECORD,
    },
 };

 CHAR_INFO :: struct {
    Char : struct #raw_union {
        UnicodeChar : WCHAR,
        AsciiChar   : CHAR,
    },
    Attributes : u16,
 };
 PCHAR_INFO :: ^struct {
    Char : struct #raw_union {
        UnicodeChar : WCHAR,
        AsciiChar   : CHAR,
    },
    Attributes : u16,
 };

 CONSOLE_FONT_INFO :: struct {
    nFont      : u32,
    dwFontSize : COORD,
 };
 PCONSOLE_FONT_INFO :: ^struct {
    nFont      : u32,
    dwFontSize : COORD,
 };

 HPCON :: rawptr;

 CONSOLE_READCONSOLE_CONTROL :: struct {
    nLength           : ULONG,
    nInitialChars     : ULONG,
    dwCtrlWakeupMask  : ULONG,
    dwControlKeyState : ULONG,
 };
 PCONSOLE_READCONSOLE_CONTROL :: ^struct {
    nLength           : ULONG,
    nInitialChars     : ULONG,
    dwCtrlWakeupMask  : ULONG,
    dwControlKeyState : ULONG,
 };

 PHANDLER_ROUTINE :: (proc(CtrlType : u32) -> BOOL);

 CONSOLE_CURSOR_INFO :: struct {
    dwSize   : u32,
    bVisible : BOOL,
 };
 PCONSOLE_CURSOR_INFO :: ^struct {
    dwSize   : u32,
    bVisible : BOOL,
 };

 CONSOLE_SCREEN_BUFFER_INFO :: struct {
    dwSize              : COORD,
    dwCursorPosition    : COORD,
    wAttributes         : u16,
    srWindow            : SMALL_RECT,
    dwMaximumWindowSize : COORD,
 };
 PCONSOLE_SCREEN_BUFFER_INFO :: ^struct {
    dwSize              : COORD,
    dwCursorPosition    : COORD,
    wAttributes         : u16,
    srWindow            : SMALL_RECT,
    dwMaximumWindowSize : COORD,
 };

 CONSOLE_SCREEN_BUFFER_INFOEX :: struct {
    cbSize               : ULONG,
    dwSize               : COORD,
    dwCursorPosition     : COORD,
    wAttributes          : u16,
    srWindow             : SMALL_RECT,
    dwMaximumWindowSize  : COORD,
    wPopupAttributes     : u16,
    bFullscreenSupported : BOOL,
    ColorTable           : [16]COLORREF,
 };
 PCONSOLE_SCREEN_BUFFER_INFOEX :: ^struct {
    cbSize               : ULONG,
    dwSize               : COORD,
    dwCursorPosition     : COORD,
    wAttributes          : u16,
    srWindow             : SMALL_RECT,
    dwMaximumWindowSize  : COORD,
    wPopupAttributes     : u16,
    bFullscreenSupported : BOOL,
    ColorTable           : [16]COLORREF,
 };

 CONSOLE_FONT_INFOEX :: struct {
    cbSize     : ULONG,
    nFont      : u32,
    dwFontSize : COORD,
    FontFamily : UINT,
    FontWeight : UINT,
    FaceName   : [32]WCHAR,
 };
 PCONSOLE_FONT_INFOEX :: ^struct {
    cbSize     : ULONG,
    nFont      : u32,
    dwFontSize : COORD,
    FontFamily : UINT,
    FontWeight : UINT,
    FaceName   : [32]WCHAR,
 };

 CONSOLE_SELECTION_INFO :: struct {
    dwFlags           : u32,
    dwSelectionAnchor : COORD,
    srSelection       : SMALL_RECT,
 };
 PCONSOLE_SELECTION_INFO :: ^struct {
    dwFlags           : u32,
    dwSelectionAnchor : COORD,
    srSelection       : SMALL_RECT,
 };

 CONSOLE_HISTORY_INFO :: struct {
    cbSize                 : UINT,
    HistoryBufferSize      : UINT,
    NumberOfHistoryBuffers : UINT,
    dwFlags                : u32,
 };
 PCONSOLE_HISTORY_INFO :: ^struct {
    cbSize                 : UINT,
    HistoryBufferSize      : UINT,
    NumberOfHistoryBuffers : UINT,
    dwFlags                : u32,
 };

 VS_FIXEDFILEINFO :: struct {
    dwSignature        : u32,
    dwStrucVersion     : u32,
    dwFileVersionMS    : u32,
    dwFileVersionLS    : u32,
    dwProductVersionMS : u32,
    dwProductVersionLS : u32,
    dwFileFlagsMask    : u32,
    dwFileFlags        : u32,
    dwFileOS           : u32,
    dwFileType         : u32,
    dwFileSubtype      : u32,
    dwFileDateMS       : u32,
    dwFileDateLS       : u32,
 };

 LSTATUS :: LONG;

 REGSAM :: ACCESS_MASK;

 val_context :: struct {
    valuelen      : i32,
    value_context : LPVOID,
    val_buff_ptr  : LPVOID,
 };

 PVALCONTEXT :: ^val_context;

 PVALUEA :: struct {
    pv_valuename     : LPSTR,
    pv_valuelen      : i32,
    pv_value_context : LPVOID,
    pv_type          : u32,
 };
 PPVALUEA :: ^struct {
    pv_valuename     : LPSTR,
    pv_valuelen      : i32,
    pv_value_context : LPVOID,
    pv_type          : u32,
 };

 PVALUEW :: struct {
    pv_valuename     : LPWSTR,
    pv_valuelen      : i32,
    pv_value_context : LPVOID,
    pv_type          : u32,
 };
 PPVALUEW :: ^struct {
    pv_valuename     : LPWSTR,
    pv_valuelen      : i32,
    pv_value_context : LPVOID,
    pv_type          : u32,
 };

 PVALUE :: PVALUEA;

 PPVALUE :: PPVALUEA;

 QUERYHANDLER :: #type (proc(keycontext : LPVOID, val_list : PVALCONTEXT, num_vals : u32, outputbuffer : LPVOID, total_outlen : ^u32, input_blen : u32) -> u32);

 PQUERYHANDLER :: ^QUERYHANDLER;

 REG_PROVIDER :: struct {
    pi_R0_1val     : PQUERYHANDLER,
    pi_R0_allvals  : PQUERYHANDLER,
    pi_R3_1val     : PQUERYHANDLER,
    pi_R3_allvals  : PQUERYHANDLER,
    pi_flags       : u32,
    pi_key_context : LPVOID,
 };

 PPROVIDER :: ^REG_PROVIDER;

 VALENTA :: struct {
    ve_valuename : LPSTR,
    ve_valuelen  : u32,
    ve_valueptr  : DWORD_PTR,
    ve_type      : u32,
 };
 PVALENTA :: ^struct {
    ve_valuename : LPSTR,
    ve_valuelen  : u32,
    ve_valueptr  : DWORD_PTR,
    ve_type      : u32,
 };

 VALENTW :: struct {
    ve_valuename : LPWSTR,
    ve_valuelen  : u32,
    ve_valueptr  : DWORD_PTR,
    ve_type      : u32,
 };
 PVALENTW :: ^struct {
    ve_valuename : LPWSTR,
    ve_valuelen  : u32,
    ve_valueptr  : DWORD_PTR,
    ve_type      : u32,
 };

 VALENT :: VALENTA;

 PVALENT :: PVALENTA;

 NETRESOURCEA :: struct {
    dwScope       : u32,
    dwType        : u32,
    dwDisplayType : u32,
    dwUsage       : u32,
    lpLocalName   : LPSTR,
    lpRemoteName  : LPSTR,
    lpComment     : LPSTR,
    lpProvider    : LPSTR,
 };
 LPNETRESOURCEA :: ^struct {
    dwScope       : u32,
    dwType        : u32,
    dwDisplayType : u32,
    dwUsage       : u32,
    lpLocalName   : LPSTR,
    lpRemoteName  : LPSTR,
    lpComment     : LPSTR,
    lpProvider    : LPSTR,
 };

 NETRESOURCEW :: struct {
    dwScope       : u32,
    dwType        : u32,
    dwDisplayType : u32,
    dwUsage       : u32,
    lpLocalName   : LPWSTR,
    lpRemoteName  : LPWSTR,
    lpComment     : LPWSTR,
    lpProvider    : LPWSTR,
 };
 LPNETRESOURCEW :: ^struct {
    dwScope       : u32,
    dwType        : u32,
    dwDisplayType : u32,
    dwUsage       : u32,
    lpLocalName   : LPWSTR,
    lpRemoteName  : LPWSTR,
    lpComment     : LPWSTR,
    lpProvider    : LPWSTR,
 };

 NETRESOURCE :: NETRESOURCEA;

 LPNETRESOURCE :: LPNETRESOURCEA;

 CONNECTDLGSTRUCTA :: struct {
    cbStructure : u32,
    hwndOwner   : HWND,
    lpConnRes   : LPNETRESOURCEA,
    dwFlags     : u32,
    dwDevNum    : u32,
 };
 LPCONNECTDLGSTRUCTA :: ^struct {
    cbStructure : u32,
    hwndOwner   : HWND,
    lpConnRes   : LPNETRESOURCEA,
    dwFlags     : u32,
    dwDevNum    : u32,
 };

 CONNECTDLGSTRUCTW :: struct {
    cbStructure : u32,
    hwndOwner   : HWND,
    lpConnRes   : LPNETRESOURCEW,
    dwFlags     : u32,
    dwDevNum    : u32,
 };
 LPCONNECTDLGSTRUCTW :: ^struct {
    cbStructure : u32,
    hwndOwner   : HWND,
    lpConnRes   : LPNETRESOURCEW,
    dwFlags     : u32,
    dwDevNum    : u32,
 };

 CONNECTDLGSTRUCT :: CONNECTDLGSTRUCTA;

 LPCONNECTDLGSTRUCT :: LPCONNECTDLGSTRUCTA;

 DISCDLGSTRUCTA :: struct {
    cbStructure  : u32,
    hwndOwner    : HWND,
    lpLocalName  : LPSTR,
    lpRemoteName : LPSTR,
    dwFlags      : u32,
 };
 LPDISCDLGSTRUCTA :: ^struct {
    cbStructure  : u32,
    hwndOwner    : HWND,
    lpLocalName  : LPSTR,
    lpRemoteName : LPSTR,
    dwFlags      : u32,
 };

 DISCDLGSTRUCTW :: struct {
    cbStructure  : u32,
    hwndOwner    : HWND,
    lpLocalName  : LPWSTR,
    lpRemoteName : LPWSTR,
    dwFlags      : u32,
 };
 LPDISCDLGSTRUCTW :: ^struct {
    cbStructure  : u32,
    hwndOwner    : HWND,
    lpLocalName  : LPWSTR,
    lpRemoteName : LPWSTR,
    dwFlags      : u32,
 };

 DISCDLGSTRUCT :: DISCDLGSTRUCTA;

 LPDISCDLGSTRUCT :: LPDISCDLGSTRUCTA;

 UNIVERSAL_NAME_INFOA :: struct {
    lpUniversalName : LPSTR,
 };
 LPUNIVERSAL_NAME_INFOA :: ^struct {
    lpUniversalName : LPSTR,
 };

 UNIVERSAL_NAME_INFOW :: struct {
    lpUniversalName : LPWSTR,
 };
 LPUNIVERSAL_NAME_INFOW :: ^struct {
    lpUniversalName : LPWSTR,
 };

 UNIVERSAL_NAME_INFO :: UNIVERSAL_NAME_INFOA;

 LPUNIVERSAL_NAME_INFO :: LPUNIVERSAL_NAME_INFOA;

 REMOTE_NAME_INFOA :: struct {
    lpUniversalName  : LPSTR,
    lpConnectionName : LPSTR,
    lpRemainingPath  : LPSTR,
 };
 LPREMOTE_NAME_INFOA :: ^struct {
    lpUniversalName  : LPSTR,
    lpConnectionName : LPSTR,
    lpRemainingPath  : LPSTR,
 };

 REMOTE_NAME_INFOW :: struct {
    lpUniversalName  : LPWSTR,
    lpConnectionName : LPWSTR,
    lpRemainingPath  : LPWSTR,
 };
 LPREMOTE_NAME_INFOW :: ^struct {
    lpUniversalName  : LPWSTR,
    lpConnectionName : LPWSTR,
    lpRemainingPath  : LPWSTR,
 };

 REMOTE_NAME_INFO :: REMOTE_NAME_INFOA;

 LPREMOTE_NAME_INFO :: LPREMOTE_NAME_INFOA;

 NETINFOSTRUCT :: struct {
    cbStructure       : u32,
    dwProviderVersion : u32,
    dwStatus          : u32,
    dwCharacteristics : u32,
    dwHandle          : ULONG_PTR,
    wNetType          : u16,
    dwPrinters        : u32,
    dwDrives          : u32,
 };
 LPNETINFOSTRUCT :: ^struct {
    cbStructure       : u32,
    dwProviderVersion : u32,
    dwStatus          : u32,
    dwCharacteristics : u32,
    dwHandle          : ULONG_PTR,
    wNetType          : u16,
    dwPrinters        : u32,
    dwDrives          : u32,
 };

 NETCONNECTINFOSTRUCT :: struct {
    cbStructure   : u32,
    dwFlags       : u32,
    dwSpeed       : u32,
    dwDelay       : u32,
    dwOptDataSize : u32,
 };
 LPNETCONNECTINFOSTRUCT :: ^struct {
    cbStructure   : u32,
    dwFlags       : u32,
    dwSpeed       : u32,
    dwDelay       : u32,
    dwOptDataSize : u32,
 };

 DDEACK :: struct {
    bAppReturnCode : ,
    reserved       : ,
    fBusy          : ,
    fAck           : ,
 };

 DDEADVISE :: struct {
    reserved  : ,
    fDeferUpd : ,
    fAckReq   : ,
    cfFormat  : i16,
 };

 DDEDATA :: struct {
    unused    : ,
    fResponse : ,
    fRelease  : ,
    reserved  : ,
    fAckReq   : ,
    cfFormat  : i16,
    Value     : [1]BYTE,
 };

 DDEPOKE :: struct {
    unused    : ,
    fRelease  : ,
    fReserved : ,
    cfFormat  : i16,
    Value     : [1]BYTE,
 };

 DDELN :: struct {
    unused    : ,
    fRelease  : ,
    fDeferUpd : ,
    fAckReq   : ,
    cfFormat  : i16,
 };

 DDEUP :: struct {
    unused    : ,
    fAck      : ,
    fRelease  : ,
    fReserved : ,
    fAckReq   : ,
    cfFormat  : i16,
    rgb       : [1]BYTE,
 };

 HCONVLIST__ :: struct {
    unused : i32,
 };

 HCONVLIST :: ^HCONVLIST__;

 HCONV__ :: struct {
    unused : i32,
 };

 HCONV :: ^HCONV__;

 HSZ__ :: struct {
    unused : i32,
 };

 HSZ :: ^HSZ__;

 HDDEDATA__ :: struct {
    unused : i32,
 };

 HDDEDATA :: ^HDDEDATA__;

 HSZPAIR :: struct {
    hszSvc   : HSZ,
    hszTopic : HSZ,
 };
 PHSZPAIR :: ^struct {
    hszSvc   : HSZ,
    hszTopic : HSZ,
 };

 CONVCONTEXT :: struct {
    cb         : UINT,
    wFlags     : UINT,
    wCountryID : UINT,
    iCodePage  : i32,
    dwLangID   : u32,
    dwSecurity : u32,
    qos        : SECURITY_QUALITY_OF_SERVICE,
 };
 PCONVCONTEXT :: ^struct {
    cb         : UINT,
    wFlags     : UINT,
    wCountryID : UINT,
    iCodePage  : i32,
    dwLangID   : u32,
    dwSecurity : u32,
    qos        : SECURITY_QUALITY_OF_SERVICE,
 };

 CONVINFO :: struct {
    cb            : u32,
    hUser         : DWORD_PTR,
    hConvPartner  : HCONV,
    hszSvcPartner : HSZ,
    hszServiceReq : HSZ,
    hszTopic      : HSZ,
    hszItem       : HSZ,
    wFmt          : UINT,
    wType         : UINT,
    wStatus       : UINT,
    wConvst       : UINT,
    wLastError    : UINT,
    hConvList     : HCONVLIST,
    ConvCtxt      : CONVCONTEXT,
    hwnd          : HWND,
    hwndPartner   : HWND,
 };
 PCONVINFO :: ^struct {
    cb            : u32,
    hUser         : DWORD_PTR,
    hConvPartner  : HCONV,
    hszSvcPartner : HSZ,
    hszServiceReq : HSZ,
    hszTopic      : HSZ,
    hszItem       : HSZ,
    wFmt          : UINT,
    wType         : UINT,
    wStatus       : UINT,
    wConvst       : UINT,
    wLastError    : UINT,
    hConvList     : HCONVLIST,
    ConvCtxt      : CONVCONTEXT,
    hwnd          : HWND,
    hwndPartner   : HWND,
 };

 FNCALLBACK :: #type (proc(wType : UINT, wFmt : UINT, hConv : HCONV, hsz1 : HSZ, hsz2 : HSZ, hData : HDDEDATA, dwData1 : ULONG_PTR, dwData2 : ULONG_PTR) -> HDDEDATA);

 PFNCALLBACK :: (proc(wType : UINT, wFmt : UINT, hConv : HCONV, hsz1 : HSZ, hsz2 : HSZ, hData : HDDEDATA, dwData1 : ULONG_PTR, dwData2 : ULONG_PTR) -> HDDEDATA);

 DDEML_MSG_HOOK_DATA :: struct {
    uiLo   : UINT_PTR,
    uiHi   : UINT_PTR,
    cbData : u32,
    Data   : [8]u32,
 };
 PDDEML_MSG_HOOK_DATA :: ^struct {
    uiLo   : UINT_PTR,
    uiHi   : UINT_PTR,
    cbData : u32,
    Data   : [8]u32,
 };

 MONMSGSTRUCT :: struct {
    cb     : UINT,
    hwndTo : HWND,
    dwTime : u32,
    hTask  : HANDLE,
    wMsg   : UINT,
    wParam : WPARAM,
    lParam : LPARAM,
    dmhd   : DDEML_MSG_HOOK_DATA,
 };
 PMONMSGSTRUCT :: ^struct {
    cb     : UINT,
    hwndTo : HWND,
    dwTime : u32,
    hTask  : HANDLE,
    wMsg   : UINT,
    wParam : WPARAM,
    lParam : LPARAM,
    dmhd   : DDEML_MSG_HOOK_DATA,
 };

 MONCBSTRUCT :: struct {
    cb      : UINT,
    dwTime  : u32,
    hTask   : HANDLE,
    dwRet   : u32,
    wType   : UINT,
    wFmt    : UINT,
    hConv   : HCONV,
    hsz1    : HSZ,
    hsz2    : HSZ,
    hData   : HDDEDATA,
    dwData1 : ULONG_PTR,
    dwData2 : ULONG_PTR,
    cc      : CONVCONTEXT,
    cbData  : u32,
    Data    : [8]u32,
 };
 PMONCBSTRUCT :: ^struct {
    cb      : UINT,
    dwTime  : u32,
    hTask   : HANDLE,
    dwRet   : u32,
    wType   : UINT,
    wFmt    : UINT,
    hConv   : HCONV,
    hsz1    : HSZ,
    hsz2    : HSZ,
    hData   : HDDEDATA,
    dwData1 : ULONG_PTR,
    dwData2 : ULONG_PTR,
    cc      : CONVCONTEXT,
    cbData  : u32,
    Data    : [8]u32,
 };

 MONHSZSTRUCTA :: struct {
    cb       : UINT,
    fsAction : BOOL,
    dwTime   : u32,
    hsz      : HSZ,
    hTask    : HANDLE,
    str      : [1]CHAR,
 };
 PMONHSZSTRUCTA :: ^struct {
    cb       : UINT,
    fsAction : BOOL,
    dwTime   : u32,
    hsz      : HSZ,
    hTask    : HANDLE,
    str      : [1]CHAR,
 };

 MONHSZSTRUCTW :: struct {
    cb       : UINT,
    fsAction : BOOL,
    dwTime   : u32,
    hsz      : HSZ,
    hTask    : HANDLE,
    str      : [1]WCHAR,
 };
 PMONHSZSTRUCTW :: ^struct {
    cb       : UINT,
    fsAction : BOOL,
    dwTime   : u32,
    hsz      : HSZ,
    hTask    : HANDLE,
    str      : [1]WCHAR,
 };

 MONHSZSTRUCT :: MONHSZSTRUCTA;

 PMONHSZSTRUCT :: PMONHSZSTRUCTA;

 MONERRSTRUCT :: struct {
    cb         : UINT,
    wLastError : UINT,
    dwTime     : u32,
    hTask      : HANDLE,
 };
 PMONERRSTRUCT :: ^struct {
    cb         : UINT,
    wLastError : UINT,
    dwTime     : u32,
    hTask      : HANDLE,
 };

 MONLINKSTRUCT :: struct {
    cb           : UINT,
    dwTime       : u32,
    hTask        : HANDLE,
    fEstablished : BOOL,
    fNoData      : BOOL,
    hszSvc       : HSZ,
    hszTopic     : HSZ,
    hszItem      : HSZ,
    wFmt         : UINT,
    fServer      : BOOL,
    hConvServer  : HCONV,
    hConvClient  : HCONV,
 };
 PMONLINKSTRUCT :: ^struct {
    cb           : UINT,
    dwTime       : u32,
    hTask        : HANDLE,
    fEstablished : BOOL,
    fNoData      : BOOL,
    hszSvc       : HSZ,
    hszTopic     : HSZ,
    hszItem      : HSZ,
    wFmt         : UINT,
    fServer      : BOOL,
    hConvServer  : HCONV,
    hConvClient  : HCONV,
 };

 MONCONVSTRUCT :: struct {
    cb          : UINT,
    fConnect    : BOOL,
    dwTime      : u32,
    hTask       : HANDLE,
    hszSvc      : HSZ,
    hszTopic    : HSZ,
    hConvClient : HCONV,
    hConvServer : HCONV,
 };
 PMONCONVSTRUCT :: ^struct {
    cb          : UINT,
    fConnect    : BOOL,
    dwTime      : u32,
    hTask       : HANDLE,
    hszSvc      : HSZ,
    hszTopic    : HSZ,
    hConvClient : HCONV,
    hConvServer : HCONV,
 };

 CRGB :: struct {
    bRed   : BYTE,
    bGreen : BYTE,
    bBlue  : BYTE,
    bExtra : BYTE,
 };

 MMVERSION :: UINT;

 MMRESULT :: UINT;

 LPUINT :: ^UINT;

 MMTIME :: struct {
    wType : UINT,
    u : struct #raw_union {
        ms     : u32,
        sample : u32,
        cb     : u32,
        ticks  : u32,
        smpte : struct {
            hour  : BYTE,
            min   : BYTE,
            sec   : BYTE,
            frame : BYTE,
            fps   : BYTE,
            dummy : BYTE,
            pad   : [2]BYTE,
        },
        midi : struct {
            songptrpos : u32,
        },
    },
 };
 PMMTIME :: ^struct {
    wType : UINT,
    u : struct #raw_union {
        ms     : u32,
        sample : u32,
        cb     : u32,
        ticks  : u32,
        smpte : struct {
            hour  : BYTE,
            min   : BYTE,
            sec   : BYTE,
            frame : BYTE,
            fps   : BYTE,
            dummy : BYTE,
            pad   : [2]BYTE,
        },
        midi : struct {
            songptrpos : u32,
        },
    },
 };
 NPMMTIME :: ^struct {
    wType : UINT,
    u : struct #raw_union {
        ms     : u32,
        sample : u32,
        cb     : u32,
        ticks  : u32,
        smpte : struct {
            hour  : BYTE,
            min   : BYTE,
            sec   : BYTE,
            frame : BYTE,
            fps   : BYTE,
            dummy : BYTE,
            pad   : [2]BYTE,
        },
        midi : struct {
            songptrpos : u32,
        },
    },
 };
 LPMMTIME :: ^struct {
    wType : UINT,
    u : struct #raw_union {
        ms     : u32,
        sample : u32,
        cb     : u32,
        ticks  : u32,
        smpte : struct {
            hour  : BYTE,
            min   : BYTE,
            sec   : BYTE,
            frame : BYTE,
            fps   : BYTE,
            dummy : BYTE,
            pad   : [2]BYTE,
        },
        midi : struct {
            songptrpos : u32,
        },
    },
 };

 HDRVR__ :: struct {
    unused : i32,
 };

 HDRVR :: ^HDRVR__;

 DRVCALLBACK :: #type proc(hdrvr : HDRVR, uMsg : UINT, dwUser : DWORD_PTR, dw1 : DWORD_PTR, dw2 : DWORD_PTR);

 LPDRVCALLBACK :: ^DRVCALLBACK;

 PDRVCALLBACK :: ^DRVCALLBACK;

 MCIERROR :: u32;

 MCIDEVICEID :: UINT;

 YIELDPROC :: (proc(mciId : MCIDEVICEID, dwYieldData : u32) -> UINT);

 MCI_GENERIC_PARMS :: struct {
    dwCallback : DWORD_PTR,
 };
 PMCI_GENERIC_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
 };
 LPMCI_GENERIC_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
 };

 MCI_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
 };
 PMCI_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
 };
 LPMCI_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
 };

 MCI_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
 };
 PMCI_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
 };
 LPMCI_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
 };

 MCI_OPEN_PARMS :: MCI_OPEN_PARMSA;

 PMCI_OPEN_PARMS :: PMCI_OPEN_PARMSA;

 LPMCI_OPEN_PARMS :: LPMCI_OPEN_PARMSA;

 MCI_PLAY_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };
 PMCI_PLAY_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };
 LPMCI_PLAY_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };

 MCI_SEEK_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwTo       : u32,
 };
 PMCI_SEEK_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwTo       : u32,
 };
 LPMCI_SEEK_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwTo       : u32,
 };

 MCI_STATUS_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwReturn   : DWORD_PTR,
    dwItem     : u32,
    dwTrack    : u32,
 };
 PMCI_STATUS_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwReturn   : DWORD_PTR,
    dwItem     : u32,
    dwTrack    : u32,
 };
 LPMCI_STATUS_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwReturn   : DWORD_PTR,
    dwItem     : u32,
    dwTrack    : u32,
 };

 MCI_INFO_PARMSA :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPSTR,
    dwRetSize   : u32,
 };
 LPMCI_INFO_PARMSA :: ^struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPSTR,
    dwRetSize   : u32,
 };

 MCI_INFO_PARMSW :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPWSTR,
    dwRetSize   : u32,
 };
 LPMCI_INFO_PARMSW :: ^struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPWSTR,
    dwRetSize   : u32,
 };

 MCI_INFO_PARMS :: MCI_INFO_PARMSA;

 LPMCI_INFO_PARMS :: LPMCI_INFO_PARMSA;

 MCI_GETDEVCAPS_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwReturn   : u32,
    dwItem     : u32,
 };
 PMCI_GETDEVCAPS_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwReturn   : u32,
    dwItem     : u32,
 };
 LPMCI_GETDEVCAPS_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwReturn   : u32,
    dwItem     : u32,
 };

 MCI_SYSINFO_PARMSA :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPSTR,
    dwRetSize   : u32,
    dwNumber    : u32,
    wDeviceType : UINT,
 };
 PMCI_SYSINFO_PARMSA :: ^struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPSTR,
    dwRetSize   : u32,
    dwNumber    : u32,
    wDeviceType : UINT,
 };
 LPMCI_SYSINFO_PARMSA :: ^struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPSTR,
    dwRetSize   : u32,
    dwNumber    : u32,
    wDeviceType : UINT,
 };

 MCI_SYSINFO_PARMSW :: struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPWSTR,
    dwRetSize   : u32,
    dwNumber    : u32,
    wDeviceType : UINT,
 };
 PMCI_SYSINFO_PARMSW :: ^struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPWSTR,
    dwRetSize   : u32,
    dwNumber    : u32,
    wDeviceType : UINT,
 };
 LPMCI_SYSINFO_PARMSW :: ^struct {
    dwCallback  : DWORD_PTR,
    lpstrReturn : LPWSTR,
    dwRetSize   : u32,
    dwNumber    : u32,
    wDeviceType : UINT,
 };

 MCI_SYSINFO_PARMS :: MCI_SYSINFO_PARMSA;

 PMCI_SYSINFO_PARMS :: PMCI_SYSINFO_PARMSA;

 LPMCI_SYSINFO_PARMS :: LPMCI_SYSINFO_PARMSA;

 MCI_SET_PARMS :: struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : u32,
    dwAudio      : u32,
 };
 PMCI_SET_PARMS :: ^struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : u32,
    dwAudio      : u32,
 };
 LPMCI_SET_PARMS :: ^struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : u32,
    dwAudio      : u32,
 };

 MCI_BREAK_PARMS :: struct {
    dwCallback : DWORD_PTR,
    nVirtKey   : i32,
    hwndBreak  : HWND,
 };
 PMCI_BREAK_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    nVirtKey   : i32,
    hwndBreak  : HWND,
 };
 LPMCI_BREAK_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    nVirtKey   : i32,
    hwndBreak  : HWND,
 };

 MCI_SAVE_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
 };
 PMCI_SAVE_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
 };
 LPMCI_SAVE_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
 };

 MCI_SAVE_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
 };
 PMCI_SAVE_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
 };
 LPMCI_SAVE_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
 };

 MCI_SAVE_PARMS :: MCI_SAVE_PARMSA;

 PMCI_SAVE_PARMS :: PMCI_SAVE_PARMSA;

 LPMCI_SAVE_PARMS :: LPMCI_SAVE_PARMSA;

 MCI_LOAD_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
 };
 PMCI_LOAD_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
 };
 LPMCI_LOAD_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
 };

 MCI_LOAD_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
 };
 PMCI_LOAD_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
 };
 LPMCI_LOAD_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
 };

 MCI_LOAD_PARMS :: MCI_LOAD_PARMSA;

 PMCI_LOAD_PARMS :: PMCI_LOAD_PARMSA;

 LPMCI_LOAD_PARMS :: LPMCI_LOAD_PARMSA;

 MCI_RECORD_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };
 LPMCI_RECORD_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };

 MCI_VD_PLAY_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
    dwSpeed    : u32,
 };
 PMCI_VD_PLAY_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
    dwSpeed    : u32,
 };
 LPMCI_VD_PLAY_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
    dwSpeed    : u32,
 };

 MCI_VD_STEP_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrames   : u32,
 };
 PMCI_VD_STEP_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrames   : u32,
 };
 LPMCI_VD_STEP_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrames   : u32,
 };

 MCI_VD_ESCAPE_PARMSA :: struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCSTR,
 };
 PMCI_VD_ESCAPE_PARMSA :: ^struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCSTR,
 };
 LPMCI_VD_ESCAPE_PARMSA :: ^struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCSTR,
 };

 MCI_VD_ESCAPE_PARMSW :: struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCWSTR,
 };
 PMCI_VD_ESCAPE_PARMSW :: ^struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCWSTR,
 };
 LPMCI_VD_ESCAPE_PARMSW :: ^struct {
    dwCallback   : DWORD_PTR,
    lpstrCommand : LPCWSTR,
 };

 MCI_VD_ESCAPE_PARMS :: MCI_VD_ESCAPE_PARMSA;

 PMCI_VD_ESCAPE_PARMS :: PMCI_VD_ESCAPE_PARMSA;

 LPMCI_VD_ESCAPE_PARMS :: LPMCI_VD_ESCAPE_PARMSA;

 MCI_WAVE_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwBufferSeconds  : u32,
 };
 PMCI_WAVE_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwBufferSeconds  : u32,
 };
 LPMCI_WAVE_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwBufferSeconds  : u32,
 };

 MCI_WAVE_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwBufferSeconds  : u32,
 };
 PMCI_WAVE_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwBufferSeconds  : u32,
 };
 LPMCI_WAVE_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwBufferSeconds  : u32,
 };

 MCI_WAVE_OPEN_PARMS :: MCI_WAVE_OPEN_PARMSA;

 PMCI_WAVE_OPEN_PARMS :: PMCI_WAVE_OPEN_PARMSA;

 LPMCI_WAVE_OPEN_PARMS :: LPMCI_WAVE_OPEN_PARMSA;

 MCI_WAVE_DELETE_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };
 PMCI_WAVE_DELETE_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };
 LPMCI_WAVE_DELETE_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
 };

 MCI_WAVE_SET_PARMS :: struct {
    dwCallback      : DWORD_PTR,
    dwTimeFormat    : u32,
    dwAudio         : u32,
    wInput          : UINT,
    wOutput         : UINT,
    wFormatTag      : u16,
    wReserved2      : u16,
    nChannels       : u16,
    wReserved3      : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
    wReserved4      : u16,
    wBitsPerSample  : u16,
    wReserved5      : u16,
 };
 PMCI_WAVE_SET_PARMS :: ^struct {
    dwCallback      : DWORD_PTR,
    dwTimeFormat    : u32,
    dwAudio         : u32,
    wInput          : UINT,
    wOutput         : UINT,
    wFormatTag      : u16,
    wReserved2      : u16,
    nChannels       : u16,
    wReserved3      : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
    wReserved4      : u16,
    wBitsPerSample  : u16,
    wReserved5      : u16,
 };
 LPMCI_WAVE_SET_PARMS :: ^struct {
    dwCallback      : DWORD_PTR,
    dwTimeFormat    : u32,
    dwAudio         : u32,
    wInput          : UINT,
    wOutput         : UINT,
    wFormatTag      : u16,
    wReserved2      : u16,
    nChannels       : u16,
    wReserved3      : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
    wReserved4      : u16,
    wBitsPerSample  : u16,
    wReserved5      : u16,
 };

 MCI_SEQ_SET_PARMS :: struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : u32,
    dwAudio      : u32,
    dwTempo      : u32,
    dwPort       : u32,
    dwSlave      : u32,
    dwMaster     : u32,
    dwOffset     : u32,
 };
 PMCI_SEQ_SET_PARMS :: ^struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : u32,
    dwAudio      : u32,
    dwTempo      : u32,
    dwPort       : u32,
    dwSlave      : u32,
    dwMaster     : u32,
    dwOffset     : u32,
 };
 LPMCI_SEQ_SET_PARMS :: ^struct {
    dwCallback   : DWORD_PTR,
    dwTimeFormat : u32,
    dwAudio      : u32,
    dwTempo      : u32,
    dwPort       : u32,
    dwSlave      : u32,
    dwMaster     : u32,
    dwOffset     : u32,
 };

 MCI_ANIM_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 PMCI_ANIM_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 LPMCI_ANIM_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };

 MCI_ANIM_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 PMCI_ANIM_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 LPMCI_ANIM_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };

 MCI_ANIM_OPEN_PARMS :: MCI_ANIM_OPEN_PARMSA;

 PMCI_ANIM_OPEN_PARMS :: PMCI_ANIM_OPEN_PARMSA;

 LPMCI_ANIM_OPEN_PARMS :: LPMCI_ANIM_OPEN_PARMSA;

 MCI_ANIM_PLAY_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
    dwSpeed    : u32,
 };
 PMCI_ANIM_PLAY_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
    dwSpeed    : u32,
 };
 LPMCI_ANIM_PLAY_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrom     : u32,
    dwTo       : u32,
    dwSpeed    : u32,
 };

 MCI_ANIM_STEP_PARMS :: struct {
    dwCallback : DWORD_PTR,
    dwFrames   : u32,
 };
 PMCI_ANIM_STEP_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrames   : u32,
 };
 LPMCI_ANIM_STEP_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    dwFrames   : u32,
 };

 MCI_ANIM_WINDOW_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
 };
 PMCI_ANIM_WINDOW_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
 };
 LPMCI_ANIM_WINDOW_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
 };

 MCI_ANIM_WINDOW_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
 };
 PMCI_ANIM_WINDOW_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
 };
 LPMCI_ANIM_WINDOW_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
 };

 MCI_ANIM_WINDOW_PARMS :: MCI_ANIM_WINDOW_PARMSA;

 PMCI_ANIM_WINDOW_PARMS :: PMCI_ANIM_WINDOW_PARMSA;

 LPMCI_ANIM_WINDOW_PARMS :: LPMCI_ANIM_WINDOW_PARMSA;

 MCI_ANIM_RECT_PARMS :: struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
 };

 PMCI_ANIM_RECT_PARMS :: ^MCI_ANIM_RECT_PARMS;

 LPMCI_ANIM_RECT_PARMS :: ^MCI_ANIM_RECT_PARMS;

 MCI_ANIM_UPDATE_PARMS :: struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
    hDC        : HDC,
 };
 PMCI_ANIM_UPDATE_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
    hDC        : HDC,
 };
 LPMCI_ANIM_UPDATE_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
    hDC        : HDC,
 };

 MCI_OVLY_OPEN_PARMSA :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 PMCI_OVLY_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 LPMCI_OVLY_OPEN_PARMSA :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCSTR,
    lpstrElementName : LPCSTR,
    lpstrAlias       : LPCSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };

 MCI_OVLY_OPEN_PARMSW :: struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 PMCI_OVLY_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };
 LPMCI_OVLY_OPEN_PARMSW :: ^struct {
    dwCallback       : DWORD_PTR,
    wDeviceID        : MCIDEVICEID,
    lpstrDeviceType  : LPCWSTR,
    lpstrElementName : LPCWSTR,
    lpstrAlias       : LPCWSTR,
    dwStyle          : u32,
    hWndParent       : HWND,
 };

 MCI_OVLY_OPEN_PARMS :: MCI_OVLY_OPEN_PARMSA;

 PMCI_OVLY_OPEN_PARMS :: PMCI_OVLY_OPEN_PARMSA;

 LPMCI_OVLY_OPEN_PARMS :: LPMCI_OVLY_OPEN_PARMSA;

 MCI_OVLY_WINDOW_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
 };
 PMCI_OVLY_WINDOW_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
 };
 LPMCI_OVLY_WINDOW_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCSTR,
 };

 MCI_OVLY_WINDOW_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
 };
 PMCI_OVLY_WINDOW_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
 };
 LPMCI_OVLY_WINDOW_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    hWnd       : HWND,
    nCmdShow   : UINT,
    lpstrText  : LPCWSTR,
 };

 MCI_OVLY_WINDOW_PARMS :: MCI_OVLY_WINDOW_PARMSA;

 PMCI_OVLY_WINDOW_PARMS :: PMCI_OVLY_WINDOW_PARMSA;

 LPMCI_OVLY_WINDOW_PARMS :: LPMCI_OVLY_WINDOW_PARMSA;

 MCI_OVLY_RECT_PARMS :: struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
 };
 PMCI_OVLY_RECT_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
 };
 LPMCI_OVLY_RECT_PARMS :: ^struct {
    dwCallback : DWORD_PTR,
    rc         : RECT,
 };

 MCI_OVLY_SAVE_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
 };
 PMCI_OVLY_SAVE_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
 };
 LPMCI_OVLY_SAVE_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
 };

 MCI_OVLY_SAVE_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
 };
 PMCI_OVLY_SAVE_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
 };
 LPMCI_OVLY_SAVE_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
 };

 MCI_OVLY_SAVE_PARMS :: MCI_OVLY_SAVE_PARMSA;

 PMCI_OVLY_SAVE_PARMS :: PMCI_OVLY_SAVE_PARMSA;

 LPMCI_OVLY_SAVE_PARMS :: LPMCI_OVLY_SAVE_PARMSA;

 MCI_OVLY_LOAD_PARMSA :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
 };
 PMCI_OVLY_LOAD_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
 };
 LPMCI_OVLY_LOAD_PARMSA :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCSTR,
    rc         : RECT,
 };

 MCI_OVLY_LOAD_PARMSW :: struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
 };
 PMCI_OVLY_LOAD_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
 };
 LPMCI_OVLY_LOAD_PARMSW :: ^struct {
    dwCallback : DWORD_PTR,
    lpfilename : LPCWSTR,
    rc         : RECT,
 };

 MCI_OVLY_LOAD_PARMS :: MCI_OVLY_LOAD_PARMSA;

 PMCI_OVLY_LOAD_PARMS :: PMCI_OVLY_LOAD_PARMSA;

 LPMCI_OVLY_LOAD_PARMS :: LPMCI_OVLY_LOAD_PARMSA;

 DRVCONFIGINFOEX :: struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
    dnDevNode          : u32,
 };
 PDRVCONFIGINFOEX :: ^struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
    dnDevNode          : u32,
 };
 NPDRVCONFIGINFOEX :: ^struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
    dnDevNode          : u32,
 };
 LPDRVCONFIGINFOEX :: ^struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
    dnDevNode          : u32,
 };

 DRVCONFIGINFO :: struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
 };
 PDRVCONFIGINFO :: ^struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
 };
 NPDRVCONFIGINFO :: ^struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
 };
 LPDRVCONFIGINFO :: ^struct {
    dwDCISize          : u32,
    lpszDCISectionName : LPCWSTR,
    lpszDCIAliasName   : LPCWSTR,
 };

 DRIVERPROC :: (proc(DWORD_PTR, HDRVR, UINT, LPARAM, LPARAM) -> LRESULT);

 DRIVERMSGPROC :: (proc(u32, u32, DWORD_PTR, DWORD_PTR, DWORD_PTR) -> u32);

 FOURCC :: u32;

 HPSTR :: cstring;

 HMMIO__ :: struct {
    unused : i32,
 };

 HMMIO :: ^HMMIO__;

 MMIOPROC :: #type (proc(lpmmioinfo : LPSTR, uMsg : UINT, lParam1 : LPARAM, lParam2 : LPARAM) -> LRESULT);

 LPMMIOPROC :: ^MMIOPROC;

 MMIOINFO :: struct {
    dwFlags     : u32,
    fccIOProc   : FOURCC,
    pIOProc     : LPMMIOPROC,
    wErrorRet   : UINT,
    htask       : HTASK,
    cchBuffer   : LONG,
    pchBuffer   : HPSTR,
    pchNext     : HPSTR,
    pchEndRead  : HPSTR,
    pchEndWrite : HPSTR,
    lBufOffset  : LONG,
    lDiskOffset : LONG,
    adwInfo     : [3]u32,
    dwReserved1 : u32,
    dwReserved2 : u32,
    hmmio       : HMMIO,
 };
 PMMIOINFO :: ^struct {
    dwFlags     : u32,
    fccIOProc   : FOURCC,
    pIOProc     : LPMMIOPROC,
    wErrorRet   : UINT,
    htask       : HTASK,
    cchBuffer   : LONG,
    pchBuffer   : HPSTR,
    pchNext     : HPSTR,
    pchEndRead  : HPSTR,
    pchEndWrite : HPSTR,
    lBufOffset  : LONG,
    lDiskOffset : LONG,
    adwInfo     : [3]u32,
    dwReserved1 : u32,
    dwReserved2 : u32,
    hmmio       : HMMIO,
 };
 NPMMIOINFO :: ^struct {
    dwFlags     : u32,
    fccIOProc   : FOURCC,
    pIOProc     : LPMMIOPROC,
    wErrorRet   : UINT,
    htask       : HTASK,
    cchBuffer   : LONG,
    pchBuffer   : HPSTR,
    pchNext     : HPSTR,
    pchEndRead  : HPSTR,
    pchEndWrite : HPSTR,
    lBufOffset  : LONG,
    lDiskOffset : LONG,
    adwInfo     : [3]u32,
    dwReserved1 : u32,
    dwReserved2 : u32,
    hmmio       : HMMIO,
 };
 LPMMIOINFO :: ^struct {
    dwFlags     : u32,
    fccIOProc   : FOURCC,
    pIOProc     : LPMMIOPROC,
    wErrorRet   : UINT,
    htask       : HTASK,
    cchBuffer   : LONG,
    pchBuffer   : HPSTR,
    pchNext     : HPSTR,
    pchEndRead  : HPSTR,
    pchEndWrite : HPSTR,
    lBufOffset  : LONG,
    lDiskOffset : LONG,
    adwInfo     : [3]u32,
    dwReserved1 : u32,
    dwReserved2 : u32,
    hmmio       : HMMIO,
 };

 LPCMMIOINFO :: ^MMIOINFO;

 MMCKINFO :: struct {
    ckid         : FOURCC,
    cksize       : u32,
    fccType      : FOURCC,
    dwDataOffset : u32,
    dwFlags      : u32,
 };
 PMMCKINFO :: ^struct {
    ckid         : FOURCC,
    cksize       : u32,
    fccType      : FOURCC,
    dwDataOffset : u32,
    dwFlags      : u32,
 };
 NPMMCKINFO :: ^struct {
    ckid         : FOURCC,
    cksize       : u32,
    fccType      : FOURCC,
    dwDataOffset : u32,
    dwFlags      : u32,
 };
 LPMMCKINFO :: ^struct {
    ckid         : FOURCC,
    cksize       : u32,
    fccType      : FOURCC,
    dwDataOffset : u32,
    dwFlags      : u32,
 };

 LPCMMCKINFO :: ^MMCKINFO;

 TIMECALLBACK :: #type proc(uTimerID : UINT, uMsg : UINT, dwUser : DWORD_PTR, dw1 : DWORD_PTR, dw2 : DWORD_PTR);

 LPTIMECALLBACK :: ^TIMECALLBACK;

 HWAVE__ :: struct {
    unused : i32,
 };

 HWAVE :: ^HWAVE__;

 HWAVEIN__ :: struct {
    unused : i32,
 };

 HWAVEIN :: ^HWAVEIN__;

 HWAVEOUT__ :: struct {
    unused : i32,
 };

 HWAVEOUT :: ^HWAVEOUT__;

 LPHWAVEIN :: ^HWAVEIN;

 LPHWAVEOUT :: ^HWAVEOUT;

 WAVECALLBACK :: DRVCALLBACK;

 LPWAVECALLBACK :: ^WAVECALLBACK;

 WAVEHDR :: struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    dwLoops         : u32,
    lpNext          : ^WAVEHDR,
    reserved        : DWORD_PTR,
 };
 PWAVEHDR :: ^struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    dwLoops         : u32,
    lpNext          : ^WAVEHDR,
    reserved        : DWORD_PTR,
 };
 NPWAVEHDR :: ^struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    dwLoops         : u32,
    lpNext          : ^WAVEHDR,
    reserved        : DWORD_PTR,
 };
 LPWAVEHDR :: ^struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    dwLoops         : u32,
    lpNext          : ^WAVEHDR,
    reserved        : DWORD_PTR,
 };

 WAVEOUTCAPSA :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 PWAVEOUTCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 NPWAVEOUTCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 LPWAVEOUTCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };

 WAVEOUTCAPSW :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 PWAVEOUTCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 NPWAVEOUTCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 LPWAVEOUTCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };

 WAVEOUTCAPS :: WAVEOUTCAPSA;

 PWAVEOUTCAPS :: PWAVEOUTCAPSA;

 NPWAVEOUTCAPS :: NPWAVEOUTCAPSA;

 LPWAVEOUTCAPS :: LPWAVEOUTCAPSA;

 WAVEOUTCAPS2A :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PWAVEOUTCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPWAVEOUTCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPWAVEOUTCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 WAVEOUTCAPS2W :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PWAVEOUTCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPWAVEOUTCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPWAVEOUTCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 WAVEOUTCAPS2 :: WAVEOUTCAPS2A;

 PWAVEOUTCAPS2 :: PWAVEOUTCAPS2A;

 NPWAVEOUTCAPS2 :: NPWAVEOUTCAPS2A;

 LPWAVEOUTCAPS2 :: LPWAVEOUTCAPS2A;

 WAVEINCAPSA :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };
 PWAVEINCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };
 NPWAVEINCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };
 LPWAVEINCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };

 WAVEINCAPSW :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };
 PWAVEINCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };
 NPWAVEINCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };
 LPWAVEINCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwFormats      : u32,
    wChannels      : u16,
    wReserved1     : u16,
 };

 WAVEINCAPS :: WAVEINCAPSA;

 PWAVEINCAPS :: PWAVEINCAPSA;

 NPWAVEINCAPS :: NPWAVEINCAPSA;

 LPWAVEINCAPS :: LPWAVEINCAPSA;

 WAVEINCAPS2A :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PWAVEINCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPWAVEINCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPWAVEINCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 WAVEINCAPS2W :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PWAVEINCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPWAVEINCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPWAVEINCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwFormats        : u32,
    wChannels        : u16,
    wReserved1       : u16,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 WAVEINCAPS2 :: WAVEINCAPS2A;

 PWAVEINCAPS2 :: PWAVEINCAPS2A;

 NPWAVEINCAPS2 :: NPWAVEINCAPS2A;

 LPWAVEINCAPS2 :: LPWAVEINCAPS2A;

 WAVEFORMAT :: struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
 };
 PWAVEFORMAT :: ^struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
 };
 NPWAVEFORMAT :: ^struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
 };
 LPWAVEFORMAT :: ^struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
 };

 PCMWAVEFORMAT :: struct {
    wf             : WAVEFORMAT,
    wBitsPerSample : u16,
 };
 PPCMWAVEFORMAT :: ^struct {
    wf             : WAVEFORMAT,
    wBitsPerSample : u16,
 };
 NPPCMWAVEFORMAT :: ^struct {
    wf             : WAVEFORMAT,
    wBitsPerSample : u16,
 };
 LPPCMWAVEFORMAT :: ^struct {
    wf             : WAVEFORMAT,
    wBitsPerSample : u16,
 };

 WAVEFORMATEX :: struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
    wBitsPerSample  : u16,
    cbSize          : u16,
 };
 PWAVEFORMATEX :: ^struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
    wBitsPerSample  : u16,
    cbSize          : u16,
 };
 NPWAVEFORMATEX :: ^struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
    wBitsPerSample  : u16,
    cbSize          : u16,
 };
 LPWAVEFORMATEX :: ^struct {
    wFormatTag      : u16,
    nChannels       : u16,
    nSamplesPerSec  : u32,
    nAvgBytesPerSec : u32,
    nBlockAlign     : u16,
    wBitsPerSample  : u16,
    cbSize          : u16,
 };

 LPCWAVEFORMATEX :: ^WAVEFORMATEX;

 HMIDI__ :: struct {
    unused : i32,
 };

 HMIDI :: ^HMIDI__;

 HMIDIIN__ :: struct {
    unused : i32,
 };

 HMIDIIN :: ^HMIDIIN__;

 HMIDIOUT__ :: struct {
    unused : i32,
 };

 HMIDIOUT :: ^HMIDIOUT__;

 HMIDISTRM__ :: struct {
    unused : i32,
 };

 HMIDISTRM :: ^HMIDISTRM__;

 LPHMIDI :: ^HMIDI;

 LPHMIDIIN :: ^HMIDIIN;

 LPHMIDIOUT :: ^HMIDIOUT;

 LPHMIDISTRM :: ^HMIDISTRM;

 MIDICALLBACK :: DRVCALLBACK;

 LPMIDICALLBACK :: ^MIDICALLBACK;

 PATCHARRAY :: [128]u16;

 LPPATCHARRAY :: ^u16;

 KEYARRAY :: [128]u16;

 LPKEYARRAY :: ^u16;

 MIDIOUTCAPSA :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };
 PMIDIOUTCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };
 NPMIDIOUTCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };
 LPMIDIOUTCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };

 MIDIOUTCAPSW :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };
 PMIDIOUTCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };
 NPMIDIOUTCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };
 LPMIDIOUTCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wVoices        : u16,
    wNotes         : u16,
    wChannelMask   : u16,
    dwSupport      : u32,
 };

 MIDIOUTCAPS :: MIDIOUTCAPSA;

 PMIDIOUTCAPS :: PMIDIOUTCAPSA;

 NPMIDIOUTCAPS :: NPMIDIOUTCAPSA;

 LPMIDIOUTCAPS :: LPMIDIOUTCAPSA;

 MIDIOUTCAPS2A :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PMIDIOUTCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPMIDIOUTCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPMIDIOUTCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 MIDIOUTCAPS2W :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PMIDIOUTCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPMIDIOUTCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPMIDIOUTCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wVoices          : u16,
    wNotes           : u16,
    wChannelMask     : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 MIDIOUTCAPS2 :: MIDIOUTCAPS2A;

 PMIDIOUTCAPS2 :: PMIDIOUTCAPS2A;

 NPMIDIOUTCAPS2 :: NPMIDIOUTCAPS2A;

 LPMIDIOUTCAPS2 :: LPMIDIOUTCAPS2A;

 MIDIINCAPSA :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwSupport      : u32,
 };
 PMIDIINCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwSupport      : u32,
 };
 NPMIDIINCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwSupport      : u32,
 };
 LPMIDIINCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    dwSupport      : u32,
 };

 MIDIINCAPSW :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwSupport      : u32,
 };
 PMIDIINCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwSupport      : u32,
 };
 NPMIDIINCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwSupport      : u32,
 };
 LPMIDIINCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    dwSupport      : u32,
 };

 MIDIINCAPS :: MIDIINCAPSA;

 PMIDIINCAPS :: PMIDIINCAPSA;

 NPMIDIINCAPS :: NPMIDIINCAPSA;

 LPMIDIINCAPS :: LPMIDIINCAPSA;

 MIDIINCAPS2A :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PMIDIINCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPMIDIINCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPMIDIINCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 MIDIINCAPS2W :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PMIDIINCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPMIDIINCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPMIDIINCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 MIDIINCAPS2 :: MIDIINCAPS2A;

 PMIDIINCAPS2 :: PMIDIINCAPS2A;

 NPMIDIINCAPS2 :: NPMIDIINCAPS2A;

 LPMIDIINCAPS2 :: LPMIDIINCAPS2A;

 MIDIHDR :: struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    lpNext          : ^MIDIHDR,
    reserved        : DWORD_PTR,
    dwOffset        : u32,
    dwReserved      : [8]DWORD_PTR,
 };
 PMIDIHDR :: ^struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    lpNext          : ^MIDIHDR,
    reserved        : DWORD_PTR,
    dwOffset        : u32,
    dwReserved      : [8]DWORD_PTR,
 };
 NPMIDIHDR :: ^struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    lpNext          : ^MIDIHDR,
    reserved        : DWORD_PTR,
    dwOffset        : u32,
    dwReserved      : [8]DWORD_PTR,
 };
 LPMIDIHDR :: ^struct {
    lpData          : LPSTR,
    dwBufferLength  : u32,
    dwBytesRecorded : u32,
    dwUser          : DWORD_PTR,
    dwFlags         : u32,
    lpNext          : ^MIDIHDR,
    reserved        : DWORD_PTR,
    dwOffset        : u32,
    dwReserved      : [8]DWORD_PTR,
 };

 MIDIEVENT :: struct {
    dwDeltaTime : u32,
    dwStreamID  : u32,
    dwEvent     : u32,
    dwParms     : [1]u32,
 };

 MIDISTRMBUFFVER :: struct {
    dwVersion    : u32,
    dwMid        : u32,
    dwOEMVersion : u32,
 };

 MIDIPROPTIMEDIV :: struct {
    cbStruct  : u32,
    dwTimeDiv : u32,
 };
 LPMIDIPROPTIMEDIV :: ^struct {
    cbStruct  : u32,
    dwTimeDiv : u32,
 };

 MIDIPROPTEMPO :: struct {
    cbStruct : u32,
    dwTempo  : u32,
 };
 LPMIDIPROPTEMPO :: ^struct {
    cbStruct : u32,
    dwTempo  : u32,
 };

 AUXCAPSA :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 PAUXCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 NPAUXCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 LPAUXCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };

 AUXCAPSW :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 PAUXCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 NPAUXCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };
 LPAUXCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    wTechnology    : u16,
    wReserved1     : u16,
    dwSupport      : u32,
 };

 AUXCAPS :: AUXCAPSA;

 PAUXCAPS :: PAUXCAPSA;

 NPAUXCAPS :: NPAUXCAPSA;

 LPAUXCAPS :: LPAUXCAPSA;

 AUXCAPS2A :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PAUXCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPAUXCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPAUXCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 AUXCAPS2W :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PAUXCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPAUXCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPAUXCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    wTechnology      : u16,
    wReserved1       : u16,
    dwSupport        : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 AUXCAPS2 :: AUXCAPS2A;

 PAUXCAPS2 :: PAUXCAPS2A;

 NPAUXCAPS2 :: NPAUXCAPS2A;

 LPAUXCAPS2 :: LPAUXCAPS2A;

 HMIXEROBJ__ :: struct {
    unused : i32,
 };

 HMIXEROBJ :: ^HMIXEROBJ__;

 LPHMIXEROBJ :: ^HMIXEROBJ;

 HMIXER__ :: struct {
    unused : i32,
 };

 HMIXER :: ^HMIXER__;

 LPHMIXER :: ^HMIXER;

 MIXERCAPSA :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    fdwSupport     : u32,
    cDestinations  : u32,
 };
 PMIXERCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    fdwSupport     : u32,
    cDestinations  : u32,
 };
 LPMIXERCAPSA :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]CHAR,
    fdwSupport     : u32,
    cDestinations  : u32,
 };

 MIXERCAPSW :: struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    fdwSupport     : u32,
    cDestinations  : u32,
 };
 PMIXERCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    fdwSupport     : u32,
    cDestinations  : u32,
 };
 LPMIXERCAPSW :: ^struct {
    wMid           : u16,
    wPid           : u16,
    vDriverVersion : MMVERSION,
    szPname        : [32]WCHAR,
    fdwSupport     : u32,
    cDestinations  : u32,
 };

 MIXERCAPS :: MIXERCAPSA;

 PMIXERCAPS :: PMIXERCAPSA;

 LPMIXERCAPS :: LPMIXERCAPSA;

 MIXERCAPS2A :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    fdwSupport       : u32,
    cDestinations    : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PMIXERCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    fdwSupport       : u32,
    cDestinations    : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPMIXERCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]CHAR,
    fdwSupport       : u32,
    cDestinations    : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 MIXERCAPS2W :: struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    fdwSupport       : u32,
    cDestinations    : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PMIXERCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    fdwSupport       : u32,
    cDestinations    : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPMIXERCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    vDriverVersion   : MMVERSION,
    szPname          : [32]WCHAR,
    fdwSupport       : u32,
    cDestinations    : u32,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 MIXERCAPS2 :: MIXERCAPS2A;

 PMIXERCAPS2 :: PMIXERCAPS2A;

 LPMIXERCAPS2 :: LPMIXERCAPS2A;

 MIXERLINEA :: struct {
    cbStruct        : u32,
    dwDestination   : u32,
    dwSource        : u32,
    dwLineID        : u32,
    fdwLine         : u32,
    dwUser          : DWORD_PTR,
    dwComponentType : u32,
    cChannels       : u32,
    cConnections    : u32,
    cControls       : u32,
    szShortName     : [16]CHAR,
    szName          : [64]CHAR,
    Target : struct {
        dwType         : u32,
        dwDeviceID     : u32,
        wMid           : u16,
        wPid           : u16,
        vDriverVersion : MMVERSION,
        szPname        : [32]CHAR,
    },
 };
 PMIXERLINEA :: ^struct {
    cbStruct        : u32,
    dwDestination   : u32,
    dwSource        : u32,
    dwLineID        : u32,
    fdwLine         : u32,
    dwUser          : DWORD_PTR,
    dwComponentType : u32,
    cChannels       : u32,
    cConnections    : u32,
    cControls       : u32,
    szShortName     : [16]CHAR,
    szName          : [64]CHAR,
    Target : struct {
        dwType         : u32,
        dwDeviceID     : u32,
        wMid           : u16,
        wPid           : u16,
        vDriverVersion : MMVERSION,
        szPname        : [32]CHAR,
    },
 };
 LPMIXERLINEA :: ^struct {
    cbStruct        : u32,
    dwDestination   : u32,
    dwSource        : u32,
    dwLineID        : u32,
    fdwLine         : u32,
    dwUser          : DWORD_PTR,
    dwComponentType : u32,
    cChannels       : u32,
    cConnections    : u32,
    cControls       : u32,
    szShortName     : [16]CHAR,
    szName          : [64]CHAR,
    Target : struct {
        dwType         : u32,
        dwDeviceID     : u32,
        wMid           : u16,
        wPid           : u16,
        vDriverVersion : MMVERSION,
        szPname        : [32]CHAR,
    },
 };

 MIXERLINEW :: struct {
    cbStruct        : u32,
    dwDestination   : u32,
    dwSource        : u32,
    dwLineID        : u32,
    fdwLine         : u32,
    dwUser          : DWORD_PTR,
    dwComponentType : u32,
    cChannels       : u32,
    cConnections    : u32,
    cControls       : u32,
    szShortName     : [16]WCHAR,
    szName          : [64]WCHAR,
    Target : struct {
        dwType         : u32,
        dwDeviceID     : u32,
        wMid           : u16,
        wPid           : u16,
        vDriverVersion : MMVERSION,
        szPname        : [32]WCHAR,
    },
 };
 PMIXERLINEW :: ^struct {
    cbStruct        : u32,
    dwDestination   : u32,
    dwSource        : u32,
    dwLineID        : u32,
    fdwLine         : u32,
    dwUser          : DWORD_PTR,
    dwComponentType : u32,
    cChannels       : u32,
    cConnections    : u32,
    cControls       : u32,
    szShortName     : [16]WCHAR,
    szName          : [64]WCHAR,
    Target : struct {
        dwType         : u32,
        dwDeviceID     : u32,
        wMid           : u16,
        wPid           : u16,
        vDriverVersion : MMVERSION,
        szPname        : [32]WCHAR,
    },
 };
 LPMIXERLINEW :: ^struct {
    cbStruct        : u32,
    dwDestination   : u32,
    dwSource        : u32,
    dwLineID        : u32,
    fdwLine         : u32,
    dwUser          : DWORD_PTR,
    dwComponentType : u32,
    cChannels       : u32,
    cConnections    : u32,
    cControls       : u32,
    szShortName     : [16]WCHAR,
    szName          : [64]WCHAR,
    Target : struct {
        dwType         : u32,
        dwDeviceID     : u32,
        wMid           : u16,
        wPid           : u16,
        vDriverVersion : MMVERSION,
        szPname        : [32]WCHAR,
    },
 };

 MIXERLINE :: MIXERLINEA;

 PMIXERLINE :: PMIXERLINEA;

 LPMIXERLINE :: LPMIXERLINEA;

 MIXERCONTROLA :: struct {
    cbStruct       : u32,
    dwControlID    : u32,
    dwControlType  : u32,
    fdwControl     : u32,
    cMultipleItems : u32,
    szShortName    : [16]CHAR,
    szName         : [64]CHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : u32,
            dwMaximum : u32,
        },
        dwReserved : [6]u32,
    },
    Metrics : struct #raw_union {
        cSteps       : u32,
        cbCustomData : u32,
        dwReserved   : [6]u32,
    },
 };
 PMIXERCONTROLA :: ^struct {
    cbStruct       : u32,
    dwControlID    : u32,
    dwControlType  : u32,
    fdwControl     : u32,
    cMultipleItems : u32,
    szShortName    : [16]CHAR,
    szName         : [64]CHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : u32,
            dwMaximum : u32,
        },
        dwReserved : [6]u32,
    },
    Metrics : struct #raw_union {
        cSteps       : u32,
        cbCustomData : u32,
        dwReserved   : [6]u32,
    },
 };
 LPMIXERCONTROLA :: ^struct {
    cbStruct       : u32,
    dwControlID    : u32,
    dwControlType  : u32,
    fdwControl     : u32,
    cMultipleItems : u32,
    szShortName    : [16]CHAR,
    szName         : [64]CHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : u32,
            dwMaximum : u32,
        },
        dwReserved : [6]u32,
    },
    Metrics : struct #raw_union {
        cSteps       : u32,
        cbCustomData : u32,
        dwReserved   : [6]u32,
    },
 };

 MIXERCONTROLW :: struct {
    cbStruct       : u32,
    dwControlID    : u32,
    dwControlType  : u32,
    fdwControl     : u32,
    cMultipleItems : u32,
    szShortName    : [16]WCHAR,
    szName         : [64]WCHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : u32,
            dwMaximum : u32,
        },
        dwReserved : [6]u32,
    },
    Metrics : struct #raw_union {
        cSteps       : u32,
        cbCustomData : u32,
        dwReserved   : [6]u32,
    },
 };
 PMIXERCONTROLW :: ^struct {
    cbStruct       : u32,
    dwControlID    : u32,
    dwControlType  : u32,
    fdwControl     : u32,
    cMultipleItems : u32,
    szShortName    : [16]WCHAR,
    szName         : [64]WCHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : u32,
            dwMaximum : u32,
        },
        dwReserved : [6]u32,
    },
    Metrics : struct #raw_union {
        cSteps       : u32,
        cbCustomData : u32,
        dwReserved   : [6]u32,
    },
 };
 LPMIXERCONTROLW :: ^struct {
    cbStruct       : u32,
    dwControlID    : u32,
    dwControlType  : u32,
    fdwControl     : u32,
    cMultipleItems : u32,
    szShortName    : [16]WCHAR,
    szName         : [64]WCHAR,
    Bounds : struct #raw_union {
        s : struct {
            lMinimum : LONG,
            lMaximum : LONG,
        },
        s2 : struct {
            dwMinimum : u32,
            dwMaximum : u32,
        },
        dwReserved : [6]u32,
    },
    Metrics : struct #raw_union {
        cSteps       : u32,
        cbCustomData : u32,
        dwReserved   : [6]u32,
    },
 };

 MIXERCONTROL :: MIXERCONTROLA;

 PMIXERCONTROL :: PMIXERCONTROLA;

 LPMIXERCONTROL :: LPMIXERCONTROLA;

 MIXERLINECONTROLSA :: struct {
    cbStruct  : u32,
    dwLineID  : u32,
    u : struct #raw_union {
        dwControlID   : u32,
        dwControlType : u32,
    },
    cControls : u32,
    cbmxctrl  : u32,
    pamxctrl  : LPMIXERCONTROLA,
 };
 PMIXERLINECONTROLSA :: ^struct {
    cbStruct  : u32,
    dwLineID  : u32,
    u : struct #raw_union {
        dwControlID   : u32,
        dwControlType : u32,
    },
    cControls : u32,
    cbmxctrl  : u32,
    pamxctrl  : LPMIXERCONTROLA,
 };
 LPMIXERLINECONTROLSA :: ^struct {
    cbStruct  : u32,
    dwLineID  : u32,
    u : struct #raw_union {
        dwControlID   : u32,
        dwControlType : u32,
    },
    cControls : u32,
    cbmxctrl  : u32,
    pamxctrl  : LPMIXERCONTROLA,
 };

 MIXERLINECONTROLSW :: struct {
    cbStruct  : u32,
    dwLineID  : u32,
    u : struct #raw_union {
        dwControlID   : u32,
        dwControlType : u32,
    },
    cControls : u32,
    cbmxctrl  : u32,
    pamxctrl  : LPMIXERCONTROLW,
 };
 PMIXERLINECONTROLSW :: ^struct {
    cbStruct  : u32,
    dwLineID  : u32,
    u : struct #raw_union {
        dwControlID   : u32,
        dwControlType : u32,
    },
    cControls : u32,
    cbmxctrl  : u32,
    pamxctrl  : LPMIXERCONTROLW,
 };
 LPMIXERLINECONTROLSW :: ^struct {
    cbStruct  : u32,
    dwLineID  : u32,
    u : struct #raw_union {
        dwControlID   : u32,
        dwControlType : u32,
    },
    cControls : u32,
    cbmxctrl  : u32,
    pamxctrl  : LPMIXERCONTROLW,
 };

 MIXERLINECONTROLS :: MIXERLINECONTROLSA;

 PMIXERLINECONTROLS :: PMIXERLINECONTROLSA;

 LPMIXERLINECONTROLS :: LPMIXERLINECONTROLSA;

 MIXERCONTROLDETAILS :: struct {
    cbStruct    : u32,
    dwControlID : u32,
    cChannels   : u32,
    u : struct #raw_union {
        hwndOwner      : HWND,
        cMultipleItems : u32,
    },
    cbDetails   : u32,
    paDetails   : LPVOID,
 };
 PMIXERCONTROLDETAILS :: ^struct {
    cbStruct    : u32,
    dwControlID : u32,
    cChannels   : u32,
    u : struct #raw_union {
        hwndOwner      : HWND,
        cMultipleItems : u32,
    },
    cbDetails   : u32,
    paDetails   : LPVOID,
 };
 LPMIXERCONTROLDETAILS :: ^struct {
    cbStruct    : u32,
    dwControlID : u32,
    cChannels   : u32,
    u : struct #raw_union {
        hwndOwner      : HWND,
        cMultipleItems : u32,
    },
    cbDetails   : u32,
    paDetails   : LPVOID,
 };

 MIXERCONTROLDETAILS_LISTTEXTA :: struct {
    dwParam1 : u32,
    dwParam2 : u32,
    szName   : [64]CHAR,
 };
 PMIXERCONTROLDETAILS_LISTTEXTA :: ^struct {
    dwParam1 : u32,
    dwParam2 : u32,
    szName   : [64]CHAR,
 };
 LPMIXERCONTROLDETAILS_LISTTEXTA :: ^struct {
    dwParam1 : u32,
    dwParam2 : u32,
    szName   : [64]CHAR,
 };

 MIXERCONTROLDETAILS_LISTTEXTW :: struct {
    dwParam1 : u32,
    dwParam2 : u32,
    szName   : [64]WCHAR,
 };
 PMIXERCONTROLDETAILS_LISTTEXTW :: ^struct {
    dwParam1 : u32,
    dwParam2 : u32,
    szName   : [64]WCHAR,
 };
 LPMIXERCONTROLDETAILS_LISTTEXTW :: ^struct {
    dwParam1 : u32,
    dwParam2 : u32,
    szName   : [64]WCHAR,
 };

 MIXERCONTROLDETAILS_LISTTEXT :: MIXERCONTROLDETAILS_LISTTEXTA;

 PMIXERCONTROLDETAILS_LISTTEXT :: PMIXERCONTROLDETAILS_LISTTEXTA;

 LPMIXERCONTROLDETAILS_LISTTEXT :: LPMIXERCONTROLDETAILS_LISTTEXTA;

 MIXERCONTROLDETAILS_BOOLEAN :: struct {
    fValue : LONG,
 };
 PMIXERCONTROLDETAILS_BOOLEAN :: ^struct {
    fValue : LONG,
 };
 LPMIXERCONTROLDETAILS_BOOLEAN :: ^struct {
    fValue : LONG,
 };

 MIXERCONTROLDETAILS_SIGNED :: struct {
    lValue : LONG,
 };
 PMIXERCONTROLDETAILS_SIGNED :: ^struct {
    lValue : LONG,
 };
 LPMIXERCONTROLDETAILS_SIGNED :: ^struct {
    lValue : LONG,
 };

 MIXERCONTROLDETAILS_UNSIGNED :: struct {
    dwValue : u32,
 };
 PMIXERCONTROLDETAILS_UNSIGNED :: ^struct {
    dwValue : u32,
 };
 LPMIXERCONTROLDETAILS_UNSIGNED :: ^struct {
    dwValue : u32,
 };

 TIMECAPS :: struct {
    wPeriodMin : UINT,
    wPeriodMax : UINT,
 };
 PTIMECAPS :: ^struct {
    wPeriodMin : UINT,
    wPeriodMax : UINT,
 };
 NPTIMECAPS :: ^struct {
    wPeriodMin : UINT,
    wPeriodMax : UINT,
 };
 LPTIMECAPS :: ^struct {
    wPeriodMin : UINT,
    wPeriodMax : UINT,
 };

 JOYCAPSA :: struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]CHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]CHAR,
    szOEMVxD    : [260]CHAR,
 };
 PJOYCAPSA :: ^struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]CHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]CHAR,
    szOEMVxD    : [260]CHAR,
 };
 NPJOYCAPSA :: ^struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]CHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]CHAR,
    szOEMVxD    : [260]CHAR,
 };
 LPJOYCAPSA :: ^struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]CHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]CHAR,
    szOEMVxD    : [260]CHAR,
 };

 JOYCAPSW :: struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]WCHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]WCHAR,
    szOEMVxD    : [260]WCHAR,
 };
 PJOYCAPSW :: ^struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]WCHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]WCHAR,
    szOEMVxD    : [260]WCHAR,
 };
 NPJOYCAPSW :: ^struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]WCHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]WCHAR,
    szOEMVxD    : [260]WCHAR,
 };
 LPJOYCAPSW :: ^struct {
    wMid        : u16,
    wPid        : u16,
    szPname     : [32]WCHAR,
    wXmin       : UINT,
    wXmax       : UINT,
    wYmin       : UINT,
    wYmax       : UINT,
    wZmin       : UINT,
    wZmax       : UINT,
    wNumButtons : UINT,
    wPeriodMin  : UINT,
    wPeriodMax  : UINT,
    wRmin       : UINT,
    wRmax       : UINT,
    wUmin       : UINT,
    wUmax       : UINT,
    wVmin       : UINT,
    wVmax       : UINT,
    wCaps       : UINT,
    wMaxAxes    : UINT,
    wNumAxes    : UINT,
    wMaxButtons : UINT,
    szRegKey    : [32]WCHAR,
    szOEMVxD    : [260]WCHAR,
 };

 JOYCAPS :: JOYCAPSA;

 PJOYCAPS :: PJOYCAPSA;

 NPJOYCAPS :: NPJOYCAPSA;

 LPJOYCAPS :: LPJOYCAPSA;

 JOYCAPS2A :: struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]CHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]CHAR,
    szOEMVxD         : [260]CHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PJOYCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]CHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]CHAR,
    szOEMVxD         : [260]CHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPJOYCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]CHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]CHAR,
    szOEMVxD         : [260]CHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPJOYCAPS2A :: ^struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]CHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]CHAR,
    szOEMVxD         : [260]CHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 JOYCAPS2W :: struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]WCHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]WCHAR,
    szOEMVxD         : [260]WCHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 PJOYCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]WCHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]WCHAR,
    szOEMVxD         : [260]WCHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 NPJOYCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]WCHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]WCHAR,
    szOEMVxD         : [260]WCHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };
 LPJOYCAPS2W :: ^struct {
    wMid             : u16,
    wPid             : u16,
    szPname          : [32]WCHAR,
    wXmin            : UINT,
    wXmax            : UINT,
    wYmin            : UINT,
    wYmax            : UINT,
    wZmin            : UINT,
    wZmax            : UINT,
    wNumButtons      : UINT,
    wPeriodMin       : UINT,
    wPeriodMax       : UINT,
    wRmin            : UINT,
    wRmax            : UINT,
    wUmin            : UINT,
    wUmax            : UINT,
    wVmin            : UINT,
    wVmax            : UINT,
    wCaps            : UINT,
    wMaxAxes         : UINT,
    wNumAxes         : UINT,
    wMaxButtons      : UINT,
    szRegKey         : [32]WCHAR,
    szOEMVxD         : [260]WCHAR,
    ManufacturerGuid : GUID,
    ProductGuid      : GUID,
    NameGuid         : GUID,
 };

 JOYCAPS2 :: JOYCAPS2A;

 PJOYCAPS2 :: PJOYCAPS2A;

 NPJOYCAPS2 :: NPJOYCAPS2A;

 LPJOYCAPS2 :: LPJOYCAPS2A;

 JOYINFO :: struct {
    wXpos    : UINT,
    wYpos    : UINT,
    wZpos    : UINT,
    wButtons : UINT,
 };
 PJOYINFO :: ^struct {
    wXpos    : UINT,
    wYpos    : UINT,
    wZpos    : UINT,
    wButtons : UINT,
 };
 NPJOYINFO :: ^struct {
    wXpos    : UINT,
    wYpos    : UINT,
    wZpos    : UINT,
    wButtons : UINT,
 };
 LPJOYINFO :: ^struct {
    wXpos    : UINT,
    wYpos    : UINT,
    wZpos    : UINT,
    wButtons : UINT,
 };

 JOYINFOEX :: struct {
    dwSize         : u32,
    dwFlags        : u32,
    dwXpos         : u32,
    dwYpos         : u32,
    dwZpos         : u32,
    dwRpos         : u32,
    dwUpos         : u32,
    dwVpos         : u32,
    dwButtons      : u32,
    dwButtonNumber : u32,
    dwPOV          : u32,
    dwReserved1    : u32,
    dwReserved2    : u32,
 };
 PJOYINFOEX :: ^struct {
    dwSize         : u32,
    dwFlags        : u32,
    dwXpos         : u32,
    dwYpos         : u32,
    dwZpos         : u32,
    dwRpos         : u32,
    dwUpos         : u32,
    dwVpos         : u32,
    dwButtons      : u32,
    dwButtonNumber : u32,
    dwPOV          : u32,
    dwReserved1    : u32,
    dwReserved2    : u32,
 };
 NPJOYINFOEX :: ^struct {
    dwSize         : u32,
    dwFlags        : u32,
    dwXpos         : u32,
    dwYpos         : u32,
    dwZpos         : u32,
    dwRpos         : u32,
    dwUpos         : u32,
    dwVpos         : u32,
    dwButtons      : u32,
    dwButtonNumber : u32,
    dwPOV          : u32,
    dwReserved1    : u32,
    dwReserved2    : u32,
 };
 LPJOYINFOEX :: ^struct {
    dwSize         : u32,
    dwFlags        : u32,
    dwXpos         : u32,
    dwYpos         : u32,
    dwZpos         : u32,
    dwRpos         : u32,
    dwUpos         : u32,
    dwVpos         : u32,
    dwButtons      : u32,
    dwButtonNumber : u32,
    dwPOV          : u32,
    dwReserved1    : u32,
    dwReserved2    : u32,
 };

 NCB :: struct {
    ncb_command  : UCHAR,
    ncb_retcode  : UCHAR,
    ncb_lsn      : UCHAR,
    ncb_num      : UCHAR,
    ncb_buffer   : PUCHAR,
    ncb_length   : u16,
    ncb_callname : [16]UCHAR,
    ncb_name     : [16]UCHAR,
    ncb_rto      : UCHAR,
    ncb_sto      : UCHAR,
    ncb_post     : proc(^NCB),
    ncb_lana_num : UCHAR,
    ncb_cmd_cplt : UCHAR,
    ncb_reserve  : [10]UCHAR,
    ncb_event    : HANDLE,
 };
 PNCB :: ^struct {
    ncb_command  : UCHAR,
    ncb_retcode  : UCHAR,
    ncb_lsn      : UCHAR,
    ncb_num      : UCHAR,
    ncb_buffer   : PUCHAR,
    ncb_length   : u16,
    ncb_callname : [16]UCHAR,
    ncb_name     : [16]UCHAR,
    ncb_rto      : UCHAR,
    ncb_sto      : UCHAR,
    ncb_post     : proc(^NCB),
    ncb_lana_num : UCHAR,
    ncb_cmd_cplt : UCHAR,
    ncb_reserve  : [10]UCHAR,
    ncb_event    : HANDLE,
 };

 ADAPTER_STATUS :: struct {
    adapter_address   : [6]UCHAR,
    rev_major         : UCHAR,
    reserved0         : UCHAR,
    adapter_type      : UCHAR,
    rev_minor         : UCHAR,
    duration          : u16,
    frmr_recv         : u16,
    frmr_xmit         : u16,
    iframe_recv_err   : u16,
    xmit_aborts       : u16,
    xmit_success      : u32,
    recv_success      : u32,
    iframe_xmit_err   : u16,
    recv_buff_unavail : u16,
    t1_timeouts       : u16,
    ti_timeouts       : u16,
    reserved1         : u32,
    free_ncbs         : u16,
    max_cfg_ncbs      : u16,
    max_ncbs          : u16,
    xmit_buf_unavail  : u16,
    max_dgram_size    : u16,
    pending_sess      : u16,
    max_cfg_sess      : u16,
    max_sess          : u16,
    max_sess_pkt_size : u16,
    name_count        : u16,
 };
 PADAPTER_STATUS :: ^struct {
    adapter_address   : [6]UCHAR,
    rev_major         : UCHAR,
    reserved0         : UCHAR,
    adapter_type      : UCHAR,
    rev_minor         : UCHAR,
    duration          : u16,
    frmr_recv         : u16,
    frmr_xmit         : u16,
    iframe_recv_err   : u16,
    xmit_aborts       : u16,
    xmit_success      : u32,
    recv_success      : u32,
    iframe_xmit_err   : u16,
    recv_buff_unavail : u16,
    t1_timeouts       : u16,
    ti_timeouts       : u16,
    reserved1         : u32,
    free_ncbs         : u16,
    max_cfg_ncbs      : u16,
    max_ncbs          : u16,
    xmit_buf_unavail  : u16,
    max_dgram_size    : u16,
    pending_sess      : u16,
    max_cfg_sess      : u16,
    max_sess          : u16,
    max_sess_pkt_size : u16,
    name_count        : u16,
 };

 NAME_BUFFER :: struct {
    name       : [16]UCHAR,
    name_num   : UCHAR,
    name_flags : UCHAR,
 };
 PNAME_BUFFER :: ^struct {
    name       : [16]UCHAR,
    name_num   : UCHAR,
    name_flags : UCHAR,
 };

 SESSION_HEADER :: struct {
    sess_name           : UCHAR,
    num_sess            : UCHAR,
    rcv_dg_outstanding  : UCHAR,
    rcv_any_outstanding : UCHAR,
 };
 PSESSION_HEADER :: ^struct {
    sess_name           : UCHAR,
    num_sess            : UCHAR,
    rcv_dg_outstanding  : UCHAR,
    rcv_any_outstanding : UCHAR,
 };

 SESSION_BUFFER :: struct {
    lsn               : UCHAR,
    state             : UCHAR,
    local_name        : [16]UCHAR,
    remote_name       : [16]UCHAR,
    rcvs_outstanding  : UCHAR,
    sends_outstanding : UCHAR,
 };
 PSESSION_BUFFER :: ^struct {
    lsn               : UCHAR,
    state             : UCHAR,
    local_name        : [16]UCHAR,
    remote_name       : [16]UCHAR,
    rcvs_outstanding  : UCHAR,
    sends_outstanding : UCHAR,
 };

 LANA_ENUM :: struct {
    length : UCHAR,
    lana   : [254 + 1]UCHAR,
 };
 PLANA_ENUM :: ^struct {
    length : UCHAR,
    lana   : [254 + 1]UCHAR,
 };

 FIND_NAME_HEADER :: struct {
    node_count   : u16,
    reserved     : UCHAR,
    unique_group : UCHAR,
 };
 PFIND_NAME_HEADER :: ^struct {
    node_count   : u16,
    reserved     : UCHAR,
    unique_group : UCHAR,
 };

 FIND_NAME_BUFFER :: struct {
    length           : UCHAR,
    access_control   : UCHAR,
    frame_control    : UCHAR,
    destination_addr : [6]UCHAR,
    source_addr      : [6]UCHAR,
    routing_info     : [18]UCHAR,
 };
 PFIND_NAME_BUFFER :: ^struct {
    length           : UCHAR,
    access_control   : UCHAR,
    frame_control    : UCHAR,
    destination_addr : [6]UCHAR,
    source_addr      : [6]UCHAR,
    routing_info     : [18]UCHAR,
 };

 ACTION_HEADER :: struct {
    transport_id : ULONG,
    action_code  : USHORT,
    reserved     : USHORT,
 };
 PACTION_HEADER :: ^struct {
    transport_id : ULONG,
    action_code  : USHORT,
    reserved     : USHORT,
 };

 I_RPC_HANDLE :: rawptr;

 RPC_STATUS :: i64;

 RPC_CSTR :: cstring;

 RPC_WSTR :: ^u16;

 RPC_CWSTR :: ^u16;

 RPC_BINDING_HANDLE :: I_RPC_HANDLE;

 handle_t :: RPC_BINDING_HANDLE;

 UUID :: GUID;

 RPC_BINDING_VECTOR :: struct {
    Count    : u64,
    BindingH : [1]RPC_BINDING_HANDLE,
 };

 UUID_VECTOR :: struct {
    Count : u64,
    Uuid  : [1]^UUID,
 };

 RPC_IF_HANDLE :: rawptr;

 RPC_IF_ID :: struct {
    Uuid      : UUID,
    VersMajor : u16,
    VersMinor : u16,
 };

 RPC_PROTSEQ_VECTORA :: struct {
    Count   : u32,
    Protseq : [1]cstring,
 };

 RPC_PROTSEQ_VECTORW :: struct {
    Count   : u32,
    Protseq : [1]^u16,
 };

 RPC_POLICY :: struct {
    Length        : u32,
    EndpointFlags : u64,
    NICFlags      : u64,
 };
 PRPC_POLICY :: ^struct {
    Length        : u32,
    EndpointFlags : u64,
    NICFlags      : u64,
 };

 RPC_OBJECT_INQ_FN :: #type proc(ObjectUuid : ^UUID, TypeUuid : ^UUID, Status : ^RPC_STATUS);

 RPC_IF_CALLBACK_FN :: #type (proc(InterfaceUuid : RPC_IF_HANDLE, Context : rawptr) -> RPC_STATUS);

 RPC_SECURITY_CALLBACK_FN :: #type proc(Context : rawptr);

 RPC_STATS_VECTOR :: struct {
    Count : u32,
    Stats : [1]u64,
 };

 RPC_IF_ID_VECTOR :: struct {
    Count : u64,
    IfId  : [1]^RPC_IF_ID,
 };

 RPC_AUTH_IDENTITY_HANDLE :: rawptr;

 RPC_AUTHZ_HANDLE :: rawptr;

 RPC_SECURITY_QOS :: struct {
    Version           : u64,
    Capabilities      : u64,
    IdentityTracking  : u64,
    ImpersonationType : u64,
 };
 PRPC_SECURITY_QOS :: ^struct {
    Version           : u64,
    Capabilities      : u64,
    IdentityTracking  : u64,
    ImpersonationType : u64,
 };

 SEC_WINNT_AUTH_IDENTITY_W :: struct {
    User           : ^u16,
    UserLength     : u64,
    Domain         : ^u16,
    DomainLength   : u64,
    Password       : ^u16,
    PasswordLength : u64,
    Flags          : u64,
 };
 PSEC_WINNT_AUTH_IDENTITY_W :: ^struct {
    User           : ^u16,
    UserLength     : u64,
    Domain         : ^u16,
    DomainLength   : u64,
    Password       : ^u16,
    PasswordLength : u64,
    Flags          : u64,
 };

 SEC_WINNT_AUTH_IDENTITY_A :: struct {
    User           : cstring,
    UserLength     : u64,
    Domain         : cstring,
    DomainLength   : u64,
    Password       : cstring,
    PasswordLength : u64,
    Flags          : u64,
 };
 PSEC_WINNT_AUTH_IDENTITY_A :: ^struct {
    User           : cstring,
    UserLength     : u64,
    Domain         : cstring,
    DomainLength   : u64,
    Password       : cstring,
    PasswordLength : u64,
    Flags          : u64,
 };

 RPC_HTTP_TRANSPORT_CREDENTIALS_W :: struct {
    TransportCredentials     : ^SEC_WINNT_AUTH_IDENTITY_W,
    Flags                    : u64,
    AuthenticationTarget     : u64,
    NumberOfAuthnSchemes     : u64,
    AuthnSchemes             : ^u64,
    ServerCertificateSubject : ^u16,
 };
 PRPC_HTTP_TRANSPORT_CREDENTIALS_W :: ^struct {
    TransportCredentials     : ^SEC_WINNT_AUTH_IDENTITY_W,
    Flags                    : u64,
    AuthenticationTarget     : u64,
    NumberOfAuthnSchemes     : u64,
    AuthnSchemes             : ^u64,
    ServerCertificateSubject : ^u16,
 };

 RPC_HTTP_TRANSPORT_CREDENTIALS_A :: struct {
    TransportCredentials     : ^SEC_WINNT_AUTH_IDENTITY_A,
    Flags                    : u64,
    AuthenticationTarget     : u64,
    NumberOfAuthnSchemes     : u64,
    AuthnSchemes             : ^u64,
    ServerCertificateSubject : cstring,
 };
 PRPC_HTTP_TRANSPORT_CREDENTIALS_A :: ^struct {
    TransportCredentials     : ^SEC_WINNT_AUTH_IDENTITY_A,
    Flags                    : u64,
    AuthenticationTarget     : u64,
    NumberOfAuthnSchemes     : u64,
    AuthnSchemes             : ^u64,
    ServerCertificateSubject : cstring,
 };

 RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W :: struct {
    TransportCredentials      : ^SEC_WINNT_AUTH_IDENTITY_W,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : ^u16,
    ProxyCredentials          : ^SEC_WINNT_AUTH_IDENTITY_W,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };
 PRPC_HTTP_TRANSPORT_CREDENTIALS_V2_W :: ^struct {
    TransportCredentials      : ^SEC_WINNT_AUTH_IDENTITY_W,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : ^u16,
    ProxyCredentials          : ^SEC_WINNT_AUTH_IDENTITY_W,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };

 RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A :: struct {
    TransportCredentials      : ^SEC_WINNT_AUTH_IDENTITY_A,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : cstring,
    ProxyCredentials          : ^SEC_WINNT_AUTH_IDENTITY_A,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };
 PRPC_HTTP_TRANSPORT_CREDENTIALS_V2_A :: ^struct {
    TransportCredentials      : ^SEC_WINNT_AUTH_IDENTITY_A,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : cstring,
    ProxyCredentials          : ^SEC_WINNT_AUTH_IDENTITY_A,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };

 RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W :: struct {
    TransportCredentials      : RPC_AUTH_IDENTITY_HANDLE,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : ^u16,
    ProxyCredentials          : RPC_AUTH_IDENTITY_HANDLE,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };
 PRPC_HTTP_TRANSPORT_CREDENTIALS_V3_W :: ^struct {
    TransportCredentials      : RPC_AUTH_IDENTITY_HANDLE,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : ^u16,
    ProxyCredentials          : RPC_AUTH_IDENTITY_HANDLE,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };

 RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A :: struct {
    TransportCredentials      : RPC_AUTH_IDENTITY_HANDLE,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : cstring,
    ProxyCredentials          : RPC_AUTH_IDENTITY_HANDLE,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };
 PRPC_HTTP_TRANSPORT_CREDENTIALS_V3_A :: ^struct {
    TransportCredentials      : RPC_AUTH_IDENTITY_HANDLE,
    Flags                     : u64,
    AuthenticationTarget      : u64,
    NumberOfAuthnSchemes      : u64,
    AuthnSchemes              : ^u64,
    ServerCertificateSubject  : cstring,
    ProxyCredentials          : RPC_AUTH_IDENTITY_HANDLE,
    NumberOfProxyAuthnSchemes : u64,
    ProxyAuthnSchemes         : ^u64,
 };

 RPC_SECURITY_QOS_V2_W :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
 };
 PRPC_SECURITY_QOS_V2_W :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
 };

 RPC_SECURITY_QOS_V2_A :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
 };
 PRPC_SECURITY_QOS_V2_A :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
 };

 RPC_SECURITY_QOS_V3_W :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
 };
 PRPC_SECURITY_QOS_V3_W :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
 };

 RPC_SECURITY_QOS_V3_A :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
 };
 PRPC_SECURITY_QOS_V3_A :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
 };

 RPC_SECURITY_QOS_V4_W :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
 };
 PRPC_SECURITY_QOS_V4_W :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
 };

 RPC_SECURITY_QOS_V4_A :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
 };
 PRPC_SECURITY_QOS_V4_A :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
 };

 RPC_SECURITY_QOS_V5_W :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
    ServerSecurityDescriptor   : rawptr,
 };
 PRPC_SECURITY_QOS_V5_W :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
    ServerSecurityDescriptor   : rawptr,
 };

 RPC_SECURITY_QOS_V5_A :: struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
    ServerSecurityDescriptor   : rawptr,
 };
 PRPC_SECURITY_QOS_V5_A :: ^struct {
    Version                    : u64,
    Capabilities               : u64,
    IdentityTracking           : u64,
    ImpersonationType          : u64,
    AdditionalSecurityInfoType : u64,
    u : struct #raw_union {
        HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A,
    },
    Sid                        : rawptr,
    EffectiveOnly              : u32,
    ServerSecurityDescriptor   : rawptr,
 };

 RPC_BINDING_HANDLE_TEMPLATE_V1_W :: struct {
    Version          : u64,
    Flags            : u64,
    ProtocolSequence : u64,
    NetworkAddress   : ^u16,
    StringEndpoint   : ^u16,
    u1 : struct #raw_union {
        Reserved : ^u16,
    },
    ObjectUuid       : UUID,
 };
 PRPC_BINDING_HANDLE_TEMPLATE_V1_W :: ^struct {
    Version          : u64,
    Flags            : u64,
    ProtocolSequence : u64,
    NetworkAddress   : ^u16,
    StringEndpoint   : ^u16,
    u1 : struct #raw_union {
        Reserved : ^u16,
    },
    ObjectUuid       : UUID,
 };

 RPC_BINDING_HANDLE_TEMPLATE_V1_A :: struct {
    Version          : u64,
    Flags            : u64,
    ProtocolSequence : u64,
    NetworkAddress   : cstring,
    StringEndpoint   : cstring,
    u1 : struct #raw_union {
        Reserved : cstring,
    },
    ObjectUuid       : UUID,
 };
 PRPC_BINDING_HANDLE_TEMPLATE_V1_A :: ^struct {
    Version          : u64,
    Flags            : u64,
    ProtocolSequence : u64,
    NetworkAddress   : cstring,
    StringEndpoint   : cstring,
    u1 : struct #raw_union {
        Reserved : cstring,
    },
    ObjectUuid       : UUID,
 };

 RPC_BINDING_HANDLE_SECURITY_V1_W :: struct {
    Version         : u64,
    ServerPrincName : ^u16,
    AuthnLevel      : u64,
    AuthnSvc        : u64,
    AuthIdentity    : ^SEC_WINNT_AUTH_IDENTITY_W,
    SecurityQos     : ^RPC_SECURITY_QOS,
 };
 PRPC_BINDING_HANDLE_SECURITY_V1_W :: ^struct {
    Version         : u64,
    ServerPrincName : ^u16,
    AuthnLevel      : u64,
    AuthnSvc        : u64,
    AuthIdentity    : ^SEC_WINNT_AUTH_IDENTITY_W,
    SecurityQos     : ^RPC_SECURITY_QOS,
 };

 RPC_BINDING_HANDLE_SECURITY_V1_A :: struct {
    Version         : u64,
    ServerPrincName : cstring,
    AuthnLevel      : u64,
    AuthnSvc        : u64,
    AuthIdentity    : ^SEC_WINNT_AUTH_IDENTITY_A,
    SecurityQos     : ^RPC_SECURITY_QOS,
 };
 PRPC_BINDING_HANDLE_SECURITY_V1_A :: ^struct {
    Version         : u64,
    ServerPrincName : cstring,
    AuthnLevel      : u64,
    AuthnSvc        : u64,
    AuthIdentity    : ^SEC_WINNT_AUTH_IDENTITY_A,
    SecurityQos     : ^RPC_SECURITY_QOS,
 };

 RPC_BINDING_HANDLE_OPTIONS_V1 :: struct {
    Version     : u64,
    Flags       : u64,
    ComTimeout  : u64,
    CallTimeout : u64,
 };
 PRPC_BINDING_HANDLE_OPTIONS_V1 :: ^struct {
    Version     : u64,
    Flags       : u64,
    ComTimeout  : u64,
    CallTimeout : u64,
 };

 RPC_HTTP_REDIRECTOR_STAGE :: enum {
    RPCHTTP_RS_REDIRECT = 1,
    RPCHTTP_RS_ACCESS_1,
    RPCHTTP_RS_SESSION,
    RPCHTTP_RS_ACCESS_2,
    RPCHTTP_RS_INTERFACE,
 };

 RPC_NEW_HTTP_PROXY_CHANNEL :: (proc(RedirectorStage : RPC_HTTP_REDIRECTOR_STAGE, ServerName : RPC_WSTR, ServerPort : RPC_WSTR, RemoteUser : RPC_WSTR, AuthType : RPC_WSTR, ResourceUuid : rawptr, SessionId : rawptr, Interface : rawptr, Reserved : rawptr, Flags : u64, NewServerName : ^RPC_WSTR, NewServerPort : ^RPC_WSTR) -> RPC_STATUS);

 RPC_HTTP_PROXY_FREE_STRING :: proc(String : RPC_WSTR);

 RPC_AUTH_KEY_RETRIEVAL_FN :: proc(Arg : rawptr, ServerPrincName : RPC_WSTR, KeyVer : u64, Key : ^rawptr, Status : ^RPC_STATUS);

 RPC_CLIENT_INFORMATION1 :: struct {
    UserName     : cstring,
    ComputerName : cstring,
    Privilege    : u16,
    AuthFlags    : u64,
 };
 PRPC_CLIENT_INFORMATION1 :: ^struct {
    UserName     : cstring,
    ComputerName : cstring,
    Privilege    : u16,
    AuthFlags    : u64,
 };

 RPC_EP_INQ_HANDLE :: ^I_RPC_HANDLE;

 RPC_MGMT_AUTHORIZATION_FN :: (proc(ClientBinding : RPC_BINDING_HANDLE, RequestedMgmtOperation : u64, Status : ^RPC_STATUS) -> i32);

 RPC_INTERFACE_GROUP :: rawptr;
 PRPC_INTERFACE_GROUP :: ^rawptr;

 RPC_ENDPOINT_TEMPLATEW :: struct {
    Version            : u64,
    ProtSeq            : RPC_WSTR,
    Endpoint           : RPC_WSTR,
    SecurityDescriptor : rawptr,
    Backlog            : u64,
 };
 PRPC_ENDPOINT_TEMPLATEW :: ^struct {
    Version            : u64,
    ProtSeq            : RPC_WSTR,
    Endpoint           : RPC_WSTR,
    SecurityDescriptor : rawptr,
    Backlog            : u64,
 };

 RPC_ENDPOINT_TEMPLATEA :: struct {
    Version            : u64,
    ProtSeq            : RPC_CSTR,
    Endpoint           : RPC_CSTR,
    SecurityDescriptor : rawptr,
    Backlog            : u64,
 };
 PRPC_ENDPOINT_TEMPLATEA :: ^struct {
    Version            : u64,
    ProtSeq            : RPC_CSTR,
    Endpoint           : RPC_CSTR,
    SecurityDescriptor : rawptr,
    Backlog            : u64,
 };

 RPC_INTERFACE_TEMPLATEA :: struct {
    Version            : u64,
    IfSpec             : RPC_IF_HANDLE,
    MgrTypeUuid        : ^UUID,
    MgrEpv             : rawptr,
    Flags              : u32,
    MaxCalls           : u32,
    MaxRpcSize         : u32,
    IfCallback         : ^RPC_IF_CALLBACK_FN,
    UuidVector         : ^UUID_VECTOR,
    Annotation         : RPC_CSTR,
    SecurityDescriptor : rawptr,
 };
 PRPC_INTERFACE_TEMPLATEA :: ^struct {
    Version            : u64,
    IfSpec             : RPC_IF_HANDLE,
    MgrTypeUuid        : ^UUID,
    MgrEpv             : rawptr,
    Flags              : u32,
    MaxCalls           : u32,
    MaxRpcSize         : u32,
    IfCallback         : ^RPC_IF_CALLBACK_FN,
    UuidVector         : ^UUID_VECTOR,
    Annotation         : RPC_CSTR,
    SecurityDescriptor : rawptr,
 };

 RPC_INTERFACE_TEMPLATEW :: struct {
    Version            : u64,
    IfSpec             : RPC_IF_HANDLE,
    MgrTypeUuid        : ^UUID,
    MgrEpv             : rawptr,
    Flags              : u32,
    MaxCalls           : u32,
    MaxRpcSize         : u32,
    IfCallback         : ^RPC_IF_CALLBACK_FN,
    UuidVector         : ^UUID_VECTOR,
    Annotation         : RPC_WSTR,
    SecurityDescriptor : rawptr,
 };
 PRPC_INTERFACE_TEMPLATEW :: ^struct {
    Version            : u64,
    IfSpec             : RPC_IF_HANDLE,
    MgrTypeUuid        : ^UUID,
    MgrEpv             : rawptr,
    Flags              : u32,
    MaxCalls           : u32,
    MaxRpcSize         : u32,
    IfCallback         : ^RPC_IF_CALLBACK_FN,
    UuidVector         : ^UUID_VECTOR,
    Annotation         : RPC_WSTR,
    SecurityDescriptor : rawptr,
 };

 RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN :: #type proc(IfGroup : RPC_INTERFACE_GROUP, IdleCallbackContext : rawptr, IsGroupIdle : u64);

 RPC_VERSION :: struct {
    MajorVersion : u16,
    MinorVersion : u16,
 };

 RPC_SYNTAX_IDENTIFIER :: struct {
    SyntaxGUID    : GUID,
    SyntaxVersion : RPC_VERSION,
 };
 PRPC_SYNTAX_IDENTIFIER :: ^struct {
    SyntaxGUID    : GUID,
    SyntaxVersion : RPC_VERSION,
 };

 RPC_MESSAGE :: struct {
    Handle                  : RPC_BINDING_HANDLE,
    DataRepresentation      : u64,
    Buffer                  : rawptr,
    BufferLength            : u32,
    ProcNum                 : u32,
    TransferSyntax          : PRPC_SYNTAX_IDENTIFIER,
    RpcInterfaceInformation : rawptr,
    ReservedForRuntime      : rawptr,
    ManagerEpv              : rawptr,
    ImportContext           : rawptr,
    RpcFlags                : u64,
 };
 PRPC_MESSAGE :: ^struct {
    Handle                  : RPC_BINDING_HANDLE,
    DataRepresentation      : u64,
    Buffer                  : rawptr,
    BufferLength            : u32,
    ProcNum                 : u32,
    TransferSyntax          : PRPC_SYNTAX_IDENTIFIER,
    RpcInterfaceInformation : rawptr,
    ReservedForRuntime      : rawptr,
    ManagerEpv              : rawptr,
    ImportContext           : rawptr,
    RpcFlags                : u64,
 };

 RPC_FORWARD_FUNCTION :: #type (proc(InterfaceId : ^UUID, InterfaceVersion : ^RPC_VERSION, ObjectId : ^UUID, Rpcpro : cstring, ppDestEndpoint : ^rawptr) -> RPC_STATUS);

 RPC_ADDRESS_CHANGE_TYPE :: enum {
    PROTOCOL_NOT_LOADED = 1,
    PROTOCOL_LOADED,
    PROTOCOL_ADDRESS_CHANGE,
 };

 RPC_ADDRESS_CHANGE_FN :: #type proc(arg : rawptr);

 RPC_DISPATCH_FUNCTION :: proc(Message : PRPC_MESSAGE);

 RPC_DISPATCH_TABLE :: struct {
    DispatchTableCount : u32,
    DispatchTable      : ^RPC_DISPATCH_FUNCTION,
    Reserved           : LONG_PTR,
 };
 PRPC_DISPATCH_TABLE :: ^struct {
    DispatchTableCount : u32,
    DispatchTable      : ^RPC_DISPATCH_FUNCTION,
    Reserved           : LONG_PTR,
 };

 RPC_PROTSEQ_ENDPOINT :: struct {
    RpcProtocolSequence : cstring,
    Endpoint            : cstring,
 };
 PRPC_PROTSEQ_ENDPOINT :: ^struct {
    RpcProtocolSequence : cstring,
    Endpoint            : cstring,
 };

 RPC_SERVER_INTERFACE :: struct {
    Length                  : u32,
    InterfaceId             : RPC_SYNTAX_IDENTIFIER,
    TransferSyntax          : RPC_SYNTAX_IDENTIFIER,
    DispatchTable           : PRPC_DISPATCH_TABLE,
    RpcProtseqEndpointCount : u32,
    RpcProtseqEndpoint      : PRPC_PROTSEQ_ENDPOINT,
    DefaultManagerEpv       : rawptr,
    InterpreterInfo         : ^void,
    Flags                   : u32,
 };
 PRPC_SERVER_INTERFACE :: ^struct {
    Length                  : u32,
    InterfaceId             : RPC_SYNTAX_IDENTIFIER,
    TransferSyntax          : RPC_SYNTAX_IDENTIFIER,
    DispatchTable           : PRPC_DISPATCH_TABLE,
    RpcProtseqEndpointCount : u32,
    RpcProtseqEndpoint      : PRPC_PROTSEQ_ENDPOINT,
    DefaultManagerEpv       : rawptr,
    InterpreterInfo         : ^void,
    Flags                   : u32,
 };

 RPC_CLIENT_INTERFACE :: struct {
    Length                  : u32,
    InterfaceId             : RPC_SYNTAX_IDENTIFIER,
    TransferSyntax          : RPC_SYNTAX_IDENTIFIER,
    DispatchTable           : PRPC_DISPATCH_TABLE,
    RpcProtseqEndpointCount : u32,
    RpcProtseqEndpoint      : PRPC_PROTSEQ_ENDPOINT,
    Reserved                : ULONG_PTR,
    InterpreterInfo         : ^void,
    Flags                   : u32,
 };
 PRPC_CLIENT_INTERFACE :: ^struct {
    Length                  : u32,
    InterfaceId             : RPC_SYNTAX_IDENTIFIER,
    TransferSyntax          : RPC_SYNTAX_IDENTIFIER,
    DispatchTable           : PRPC_DISPATCH_TABLE,
    RpcProtseqEndpointCount : u32,
    RpcProtseqEndpoint      : PRPC_PROTSEQ_ENDPOINT,
    Reserved                : ULONG_PTR,
    InterpreterInfo         : ^void,
    Flags                   : u32,
 };

 I_RPC_MUTEX :: rawptr;

 LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION :: enum {
    MarshalDirectionMarshal,
    MarshalDirectionUnmarshal,
 };

 PRPC_RUNDOWN :: proc(AssociationContext : rawptr);

 RPC_SEC_CONTEXT_KEY_INFO :: struct {
    EncryptAlgorithm   : u64,
    KeySize            : u64,
    SignatureAlgorithm : u64,
 };
 PRPC_SEC_CONTEXT_KEY_INFO :: ^struct {
    EncryptAlgorithm   : u64,
    KeySize            : u64,
    SignatureAlgorithm : u64,
 };

 RPC_TRANSFER_SYNTAX :: struct {
    Uuid      : UUID,
    VersMajor : u16,
    VersMinor : u16,
 };

 RPCLT_PDU_FILTER_FUNC :: proc(Buffer : rawptr, BufferLength : u32, fDatagram : i32);

 RPC_SETFILTER_FUNC :: proc(pfnFilter : RPCLT_PDU_FILTER_FUNC);

 RPC_BLOCKING_FN :: (proc(hWnd : rawptr, Context : rawptr, hSyncEvent : rawptr) -> RPC_STATUS);

 RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR :: struct {
    BufferSize : u64,
    Buffer     : cstring,
 };

 RDR_CALLOUT_STATE :: struct {
    LastError           : RPC_STATUS,
    LastEEInfo          : rawptr,
    LastCalledStage     : RPC_HTTP_REDIRECTOR_STAGE,
    ServerName          : ^u16,
    ServerPort          : ^u16,
    RemoteUser          : ^u16,
    AuthType            : ^u16,
    ResourceTypePresent : u8,
    SessionIdPresent    : u8,
    InterfacePresent    : u8,
    ResourceType        : UUID,
    SessionId           : UUID,
    Interface           : RPC_SYNTAX_IDENTIFIER,
    CertContext         : rawptr,
 };

 I_RpcProxyIsValidMachineFn :: (proc(Machine : RPC_WSTR, DotMachine : RPC_WSTR, PortNumber : u64) -> RPC_STATUS);

 I_RpcProxyGetClientAddressFn :: (proc(Context : rawptr, Buffer : cstring, BufferLength : ^u64) -> RPC_STATUS);

 I_RpcProxyGetConnectionTimeoutFn :: (proc(ConnectionTimeout : ^u64) -> RPC_STATUS);

 I_RpcPerformCalloutFn :: (proc(Context : rawptr, CallOutState : ^RDR_CALLOUT_STATE, Stage : RPC_HTTP_REDIRECTOR_STAGE) -> RPC_STATUS);

 I_RpcFreeCalloutStateFn :: proc(CallOutState : ^RDR_CALLOUT_STATE);

 I_RpcProxyGetClientSessionAndResourceUUID :: (proc(Context : rawptr, SessionIdPresent : ^i32, SessionId : ^UUID, ResourceIdPresent : ^i32, ResourceId : ^UUID) -> RPC_STATUS);

 I_RpcProxyFilterIfFn :: (proc(Context : rawptr, IfUuid : ^UUID, IfMajorVersion : u16, fAllow : ^i32) -> RPC_STATUS);

 RpcPerfCounters :: enum {
    RpcCurrentUniqueUser = 1,
    RpcBackEndConnectionAttempts,
    RpcBackEndConnectionFailed,
    RpcRequestsPerSecond,
    RpcIncomingConnections,
    RpcIncomingBandwidth,
    RpcOutgoingBandwidth,
    RpcAttemptedLbsDecisions,
    RpcFailedLbsDecisions,
    RpcAttemptedLbsMessages,
    RpcFailedLbsMessages,
    RpcLastCounter,
 };

 I_RpcProxyUpdatePerfCounterFn :: proc(Counter : RpcPerfCounters, ModifyTrend : i32, Size : u64);

 I_RpcProxyUpdatePerfCounterBackendServerFn :: proc(MachineName : ^u16, IsConnectEvent : i32);

 I_RpcProxyCallbackInterface :: struct {
    IsValidMachineFn                         : I_RpcProxyIsValidMachineFn,
    GetClientAddressFn                       : I_RpcProxyGetClientAddressFn,
    GetConnectionTimeoutFn                   : I_RpcProxyGetConnectionTimeoutFn,
    PerformCalloutFn                         : I_RpcPerformCalloutFn,
    FreeCalloutStateFn                       : I_RpcFreeCalloutStateFn,
    GetClientSessionAndResourceUUIDFn        : I_RpcProxyGetClientSessionAndResourceUUID,
    ProxyFilterIfFn                          : I_RpcProxyFilterIfFn,
    RpcProxyUpdatePerfCounterFn              : I_RpcProxyUpdatePerfCounterFn,
    RpcProxyUpdatePerfCounterBackendServerFn : I_RpcProxyUpdatePerfCounterBackendServerFn,
 };

 RPC_NS_HANDLE :: rawptr;

 RPC_NOTIFICATION_TYPES :: enum {
    RpcNotificationTypeNone,
    RpcNotificationTypeEvent,
    RpcNotificationTypeApc,
    RpcNotificationTypeIoc,
    RpcNotificationTypeHwnd,
    RpcNotificationTypeCallback,
 };

 RPC_ASYNC_EVENT :: enum {
    RpcCallComplete,
    RpcSendComplete,
    RpcReceiveComplete,
    RpcClientDisconnect,
    RpcClientCancel,
 };

 RPCNOTIFICATION_ROUTINE :: #type proc(pAsync : ^RPC_ASYNC_STATE, Context : rawptr, Event : RPC_ASYNC_EVENT);

 PFN_RPCNOTIFICATION_ROUTINE :: ^RPCNOTIFICATION_ROUTINE;

 RPC_ASYNC_NOTIFICATION_INFO :: struct #raw_union {
    APC : struct {
        NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE,
        hThread             : HANDLE,
    },
    IOC : struct {
        hIOPort                    : HANDLE,
        dwNumberOfBytesTransferred : u32,
        dwCompletionKey            : DWORD_PTR,
        lpOverlapped               : LPOVERLAPPED,
    },
    HWND : struct {
        hWnd : HWND,
        Msg  : UINT,
    },
    hEvent              : HANDLE,
    NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE,
 };
 PRPC_ASYNC_NOTIFICATION_INFO :: ^struct #raw_union {
    APC : struct {
        NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE,
        hThread             : HANDLE,
    },
    IOC : struct {
        hIOPort                    : HANDLE,
        dwNumberOfBytesTransferred : u32,
        dwCompletionKey            : DWORD_PTR,
        lpOverlapped               : LPOVERLAPPED,
    },
    HWND : struct {
        hWnd : HWND,
        Msg  : UINT,
    },
    hEvent              : HANDLE,
    NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE,
 };

 RPC_ASYNC_STATE :: struct {
    Size             : u32,
    Signature        : u64,
    Lock             : i64,
    Flags            : u64,
    StubInfo         : rawptr,
    UserInfo         : rawptr,
    RuntimeInfo      : rawptr,
    Event            : RPC_ASYNC_EVENT,
    NotificationType : RPC_NOTIFICATION_TYPES,
    u                : RPC_ASYNC_NOTIFICATION_INFO,
    Reserved         : [4]LONG_PTR,
 };
 PRPC_ASYNC_STATE :: ^struct {
    Size             : u32,
    Signature        : u64,
    Lock             : i64,
    Flags            : u64,
    StubInfo         : rawptr,
    UserInfo         : rawptr,
    RuntimeInfo      : rawptr,
    Event            : RPC_ASYNC_EVENT,
    NotificationType : RPC_NOTIFICATION_TYPES,
    u                : RPC_ASYNC_NOTIFICATION_INFO,
    Reserved         : [4]LONG_PTR,
 };

 ExtendedErrorParamTypes :: enum {
    eeptAnsiString = 1,
    eeptUnicodeString,
    eeptLongVal,
    eeptShortVal,
    eeptPointerVal,
    eeptNone,
    eeptBinary,
 };

 BinaryParam :: struct {
    Buffer : rawptr,
    Size   : i16,
 };

 RPC_EE_INFO_PARAM :: struct {
    ParameterType : ExtendedErrorParamTypes,
    u : struct #raw_union {
        AnsiString    : LPSTR,
        UnicodeString : LPWSTR,
        LVal          : i64,
        SVal          : i16,
        PVal          : ULONGLONG,
        BVal          : BinaryParam,
    },
 };

 RPC_EXTENDED_ERROR_INFO :: struct {
    Version             : ULONG,
    ComputerName        : LPWSTR,
    ProcessID           : ULONG,
    u : struct #raw_union {
        SystemTime : SYSTEMTIME,
        FileTime   : FILETIME,
    },
    GeneratingComponent : ULONG,
    Status              : ULONG,
    DetectionLocation   : USHORT,
    Flags               : USHORT,
    NumberOfParameters  : i32,
    Parameters          : [4]RPC_EE_INFO_PARAM,
 };

 RPC_ERROR_ENUM_HANDLE :: struct {
    Signature  : ULONG,
    CurrentPos : rawptr,
    Head       : rawptr,
 };

 RpcLocalAddressFormat :: enum {
    rlafInvalid = 0,
    rlafIPv4,
    rlafIPv6,
 };

 RPC_CALL_LOCAL_ADDRESS_V1 :: struct {
    Version       : u32,
    Buffer        : rawptr,
    BufferSize    : u64,
    AddressFormat : RpcLocalAddressFormat,
 };
 PRPC_CALL_LOCAL_ADDRESS_V1 :: ^struct {
    Version       : u32,
    Buffer        : rawptr,
    BufferSize    : u64,
    AddressFormat : RpcLocalAddressFormat,
 };

 RPC_CALL_ATTRIBUTES_V1_W :: struct {
    Version                         : u32,
    Flags                           : u64,
    ServerPrincipalNameBufferLength : u64,
    ServerPrincipalName             : ^u16,
    ClientPrincipalNameBufferLength : u64,
    ClientPrincipalName             : ^u16,
    AuthenticationLevel             : u64,
    AuthenticationService           : u64,
    NullSession                     : BOOL,
 };

 RPC_CALL_ATTRIBUTES_V1_A :: struct {
    Version                         : u32,
    Flags                           : u64,
    ServerPrincipalNameBufferLength : u64,
    ServerPrincipalName             : cstring,
    ClientPrincipalNameBufferLength : u64,
    ClientPrincipalName             : cstring,
    AuthenticationLevel             : u64,
    AuthenticationService           : u64,
    NullSession                     : BOOL,
 };

 RpcCallType :: enum {
    rctInvalid = 0,
    rctNormal,
    rctTraining,
    rctGuaranteed,
 };

 RpcCallClientLocality :: enum {
    rcclInvalid = 0,
    rcclLocal,
    rcclRemote,
    rcclClientUnknownLocality,
 };

 RPC_CALL_ATTRIBUTES_V2_W :: struct {
    Version                         : u32,
    Flags                           : u64,
    ServerPrincipalNameBufferLength : u64,
    ServerPrincipalName             : ^u16,
    ClientPrincipalNameBufferLength : u64,
    ClientPrincipalName             : ^u16,
    AuthenticationLevel             : u64,
    AuthenticationService           : u64,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : u64,
    IsClientLocal                   : RpcCallClientLocality,
    ClientPID                       : HANDLE,
    CallStatus                      : u64,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : u16,
    InterfaceUuid                   : UUID,
 };

 RPC_CALL_ATTRIBUTES_V2_A :: struct {
    Version                         : u32,
    Flags                           : u64,
    ServerPrincipalNameBufferLength : u64,
    ServerPrincipalName             : cstring,
    ClientPrincipalNameBufferLength : u64,
    ClientPrincipalName             : cstring,
    AuthenticationLevel             : u64,
    AuthenticationService           : u64,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : u64,
    IsClientLocal                   : u64,
    ClientPID                       : HANDLE,
    CallStatus                      : u64,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : u16,
    InterfaceUuid                   : UUID,
 };

 RPC_CALL_ATTRIBUTES_V3_W :: struct {
    Version                         : u32,
    Flags                           : u64,
    ServerPrincipalNameBufferLength : u64,
    ServerPrincipalName             : ^u16,
    ClientPrincipalNameBufferLength : u64,
    ClientPrincipalName             : ^u16,
    AuthenticationLevel             : u64,
    AuthenticationService           : u64,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : u64,
    IsClientLocal                   : RpcCallClientLocality,
    ClientPID                       : HANDLE,
    CallStatus                      : u64,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : u16,
    InterfaceUuid                   : UUID,
    ClientIdentifierBufferLength    : u64,
    ClientIdentifier                : cstring,
 };

 RPC_CALL_ATTRIBUTES_V3_A :: struct {
    Version                         : u32,
    Flags                           : u64,
    ServerPrincipalNameBufferLength : u64,
    ServerPrincipalName             : cstring,
    ClientPrincipalNameBufferLength : u64,
    ClientPrincipalName             : cstring,
    AuthenticationLevel             : u64,
    AuthenticationService           : u64,
    NullSession                     : BOOL,
    KernelModeCaller                : BOOL,
    ProtocolSequence                : u64,
    IsClientLocal                   : u64,
    ClientPID                       : HANDLE,
    CallStatus                      : u64,
    CallType                        : RpcCallType,
    CallLocalAddress                : ^RPC_CALL_LOCAL_ADDRESS_V1,
    OpNum                           : u16,
    InterfaceUuid                   : UUID,
    ClientIdentifierBufferLength    : u64,
    ClientIdentifier                : cstring,
 };

 RPC_CALL_ATTRIBUTES :: RPC_CALL_ATTRIBUTES_V3_A;

 RPC_NOTIFICATIONS :: enum {
    RpcNotificationCallNone = 0,
    RpcNotificationClientDisconnect = 1,
    RpcNotificationCallCancel = 2,
 };

 HDROP__ :: struct {
    unused : i32,
 };

 HDROP :: ^HDROP__;

 DRAGINFOA :: struct {
    uSize       : UINT,
    pt          : POINT,
    fNC         : BOOL,
    lpFileList  : PZZSTR,
    grfKeyState : u32,
 };
 LPDRAGINFOA :: ^struct {
    uSize       : UINT,
    pt          : POINT,
    fNC         : BOOL,
    lpFileList  : PZZSTR,
    grfKeyState : u32,
 };

 DRAGINFOW :: struct {
    uSize       : UINT,
    pt          : POINT,
    fNC         : BOOL,
    lpFileList  : PZZWSTR,
    grfKeyState : u32,
 };
 LPDRAGINFOW :: ^struct {
    uSize       : UINT,
    pt          : POINT,
    fNC         : BOOL,
    lpFileList  : PZZWSTR,
    grfKeyState : u32,
 };

 DRAGINFO :: DRAGINFOA;

 LPDRAGINFO :: LPDRAGINFOA;

 APPBARDATA :: struct {
    cbSize           : u32,
    hWnd             : HWND,
    uCallbackMessage : UINT,
    uEdge            : UINT,
    rc               : RECT,
    lParam           : LPARAM,
 };
 PAPPBARDATA :: ^struct {
    cbSize           : u32,
    hWnd             : HWND,
    uCallbackMessage : UINT,
    uEdge            : UINT,
    rc               : RECT,
    lParam           : LPARAM,
 };

 FILEOP_FLAGS :: u16;

 PRINTEROP_FLAGS :: u16;

 SHFILEOPSTRUCTA :: struct {
    hwnd                  : HWND,
    wFunc                 : UINT,
    pFrom                 : PCZZSTR,
    pTo                   : PCZZSTR,
    fFlags                : FILEOP_FLAGS,
    fAnyOperationsAborted : BOOL,
    hNameMappings         : LPVOID,
    lpszProgressTitle     : PCSTR,
 };
 LPSHFILEOPSTRUCTA :: ^struct {
    hwnd                  : HWND,
    wFunc                 : UINT,
    pFrom                 : PCZZSTR,
    pTo                   : PCZZSTR,
    fFlags                : FILEOP_FLAGS,
    fAnyOperationsAborted : BOOL,
    hNameMappings         : LPVOID,
    lpszProgressTitle     : PCSTR,
 };

 SHFILEOPSTRUCTW :: struct {
    hwnd                  : HWND,
    wFunc                 : UINT,
    pFrom                 : PCZZWSTR,
    pTo                   : PCZZWSTR,
    fFlags                : FILEOP_FLAGS,
    fAnyOperationsAborted : BOOL,
    hNameMappings         : LPVOID,
    lpszProgressTitle     : PCWSTR,
 };
 LPSHFILEOPSTRUCTW :: ^struct {
    hwnd                  : HWND,
    wFunc                 : UINT,
    pFrom                 : PCZZWSTR,
    pTo                   : PCZZWSTR,
    fFlags                : FILEOP_FLAGS,
    fAnyOperationsAborted : BOOL,
    hNameMappings         : LPVOID,
    lpszProgressTitle     : PCWSTR,
 };

 SHFILEOPSTRUCT :: SHFILEOPSTRUCTA;

 LPSHFILEOPSTRUCT :: LPSHFILEOPSTRUCTA;

 SHNAMEMAPPINGA :: struct {
    pszOldPath : LPSTR,
    pszNewPath : LPSTR,
    cchOldPath : i32,
    cchNewPath : i32,
 };
 LPSHNAMEMAPPINGA :: ^struct {
    pszOldPath : LPSTR,
    pszNewPath : LPSTR,
    cchOldPath : i32,
    cchNewPath : i32,
 };

 SHNAMEMAPPINGW :: struct {
    pszOldPath : LPWSTR,
    pszNewPath : LPWSTR,
    cchOldPath : i32,
    cchNewPath : i32,
 };
 LPSHNAMEMAPPINGW :: ^struct {
    pszOldPath : LPWSTR,
    pszNewPath : LPWSTR,
    cchOldPath : i32,
    cchNewPath : i32,
 };

 SHNAMEMAPPING :: SHNAMEMAPPINGA;

 LPSHNAMEMAPPING :: LPSHNAMEMAPPINGA;

 SHELLEXECUTEINFOA :: struct {
    cbSize       : u32,
    fMask        : ULONG,
    hwnd         : HWND,
    lpVerb       : LPCSTR,
    lpFile       : LPCSTR,
    lpParameters : LPCSTR,
    lpDirectory  : LPCSTR,
    nShow        : i32,
    hInstApp     : HINSTANCE,
    lpIDList     : rawptr,
    lpClass      : LPCSTR,
    hkeyClass    : HKEY,
    dwHotKey     : u32,
    u : struct #raw_union {
        hIcon    : HANDLE,
        hMonitor : HANDLE,
    },
    hProcess     : HANDLE,
 };
 LPSHELLEXECUTEINFOA :: ^struct {
    cbSize       : u32,
    fMask        : ULONG,
    hwnd         : HWND,
    lpVerb       : LPCSTR,
    lpFile       : LPCSTR,
    lpParameters : LPCSTR,
    lpDirectory  : LPCSTR,
    nShow        : i32,
    hInstApp     : HINSTANCE,
    lpIDList     : rawptr,
    lpClass      : LPCSTR,
    hkeyClass    : HKEY,
    dwHotKey     : u32,
    u : struct #raw_union {
        hIcon    : HANDLE,
        hMonitor : HANDLE,
    },
    hProcess     : HANDLE,
 };

 SHELLEXECUTEINFOW :: struct {
    cbSize       : u32,
    fMask        : ULONG,
    hwnd         : HWND,
    lpVerb       : LPCWSTR,
    lpFile       : LPCWSTR,
    lpParameters : LPCWSTR,
    lpDirectory  : LPCWSTR,
    nShow        : i32,
    hInstApp     : HINSTANCE,
    lpIDList     : rawptr,
    lpClass      : LPCWSTR,
    hkeyClass    : HKEY,
    dwHotKey     : u32,
    u : struct #raw_union {
        hIcon    : HANDLE,
        hMonitor : HANDLE,
    },
    hProcess     : HANDLE,
 };
 LPSHELLEXECUTEINFOW :: ^struct {
    cbSize       : u32,
    fMask        : ULONG,
    hwnd         : HWND,
    lpVerb       : LPCWSTR,
    lpFile       : LPCWSTR,
    lpParameters : LPCWSTR,
    lpDirectory  : LPCWSTR,
    nShow        : i32,
    hInstApp     : HINSTANCE,
    lpIDList     : rawptr,
    lpClass      : LPCWSTR,
    hkeyClass    : HKEY,
    dwHotKey     : u32,
    u : struct #raw_union {
        hIcon    : HANDLE,
        hMonitor : HANDLE,
    },
    hProcess     : HANDLE,
 };

 SHELLEXECUTEINFO :: SHELLEXECUTEINFOA;

 LPSHELLEXECUTEINFO :: LPSHELLEXECUTEINFOA;

 SHCREATEPROCESSINFOW :: struct {
    cbSize               : u32,
    fMask                : ULONG,
    hwnd                 : HWND,
    pszFile              : LPCWSTR,
    pszParameters        : LPCWSTR,
    pszCurrentDirectory  : LPCWSTR,
    hUserToken           : HANDLE,
    lpProcessAttributes  : LPSECURITY_ATTRIBUTES,
    lpThreadAttributes   : LPSECURITY_ATTRIBUTES,
    bInheritHandles      : BOOL,
    dwCreationFlags      : u32,
    lpStartupInfo        : LPSTARTUPINFOW,
    lpProcessInformation : LPPROCESS_INFORMATION,
 };
 PSHCREATEPROCESSINFOW :: ^struct {
    cbSize               : u32,
    fMask                : ULONG,
    hwnd                 : HWND,
    pszFile              : LPCWSTR,
    pszParameters        : LPCWSTR,
    pszCurrentDirectory  : LPCWSTR,
    hUserToken           : HANDLE,
    lpProcessAttributes  : LPSECURITY_ATTRIBUTES,
    lpThreadAttributes   : LPSECURITY_ATTRIBUTES,
    bInheritHandles      : BOOL,
    dwCreationFlags      : u32,
    lpStartupInfo        : LPSTARTUPINFOW,
    lpProcessInformation : LPPROCESS_INFORMATION,
 };

 ASSOCCLASS :: enum {
    ASSOCCLASS_SHELL_KEY = 0,
    ASSOCCLASS_PROGID_KEY,
    ASSOCCLASS_PROGID_STR,
    ASSOCCLASS_CLSID_KEY,
    ASSOCCLASS_CLSID_STR,
    ASSOCCLASS_APP_KEY,
    ASSOCCLASS_APP_STR,
    ASSOCCLASS_SYSTEM_STR,
    ASSOCCLASS_FOLDER,
    ASSOCCLASS_STAR,
    ASSOCCLASS_FIXED_PROGID_STR,
    ASSOCCLASS_PROTOCOL_STR,
 };

 ASSOCIATIONELEMENT :: struct {
    ac       : ASSOCCLASS,
    hkClass  : HKEY,
    pszClass : PCWSTR,
 };

 SHQUERYRBINFO :: struct {
    cbSize      : u32,
    i64Size     : i64,
    i64NumItems : i64,
 };
 LPSHQUERYRBINFO :: ^struct {
    cbSize      : u32,
    i64Size     : i64,
    i64NumItems : i64,
 };

 QUERY_USER_NOTIFICATION_STATE :: enum {
    QUNS_NOT_PRESENT = 1,
    QUNS_BUSY = 2,
    QUNS_RUNNING_D3D_FULL_SCREEN = 3,
    QUNS_PRESENTATION_MODE = 4,
    QUNS_ACCEPTS_NOTIFICATIONS = 5,
    QUNS_QUIET_TIME = 6,
    QUNS_APP = 7,
 };

 NOTIFYICONDATAA :: struct {
    cbSize           : u32,
    hWnd             : HWND,
    uID              : UINT,
    uFlags           : UINT,
    uCallbackMessage : UINT,
    hIcon            : HICON,
    szTip            : [128]CHAR,
    dwState          : u32,
    dwStateMask      : u32,
    szInfo           : [256]CHAR,
    u : struct #raw_union {
        uTimeout : UINT,
        uVersion : UINT,
    },
    szInfoTitle      : [64]CHAR,
    dwInfoFlags      : u32,
    guidItem         : GUID,
    hBalloonIcon     : HICON,
 };
 PNOTIFYICONDATAA :: ^struct {
    cbSize           : u32,
    hWnd             : HWND,
    uID              : UINT,
    uFlags           : UINT,
    uCallbackMessage : UINT,
    hIcon            : HICON,
    szTip            : [128]CHAR,
    dwState          : u32,
    dwStateMask      : u32,
    szInfo           : [256]CHAR,
    u : struct #raw_union {
        uTimeout : UINT,
        uVersion : UINT,
    },
    szInfoTitle      : [64]CHAR,
    dwInfoFlags      : u32,
    guidItem         : GUID,
    hBalloonIcon     : HICON,
 };

 NOTIFYICONDATAW :: struct {
    cbSize           : u32,
    hWnd             : HWND,
    uID              : UINT,
    uFlags           : UINT,
    uCallbackMessage : UINT,
    hIcon            : HICON,
    szTip            : [128]WCHAR,
    dwState          : u32,
    dwStateMask      : u32,
    szInfo           : [256]WCHAR,
    u : struct #raw_union {
        uTimeout : UINT,
        uVersion : UINT,
    },
    szInfoTitle      : [64]WCHAR,
    dwInfoFlags      : u32,
    guidItem         : GUID,
    hBalloonIcon     : HICON,
 };
 PNOTIFYICONDATAW :: ^struct {
    cbSize           : u32,
    hWnd             : HWND,
    uID              : UINT,
    uFlags           : UINT,
    uCallbackMessage : UINT,
    hIcon            : HICON,
    szTip            : [128]WCHAR,
    dwState          : u32,
    dwStateMask      : u32,
    szInfo           : [256]WCHAR,
    u : struct #raw_union {
        uTimeout : UINT,
        uVersion : UINT,
    },
    szInfoTitle      : [64]WCHAR,
    dwInfoFlags      : u32,
    guidItem         : GUID,
    hBalloonIcon     : HICON,
 };

 NOTIFYICONDATA :: NOTIFYICONDATAA;

 PNOTIFYICONDATA :: PNOTIFYICONDATAA;

 NOTIFYICONIDENTIFIER :: struct {
    cbSize   : u32,
    hWnd     : HWND,
    uID      : UINT,
    guidItem : GUID,
 };
 PNOTIFYICONIDENTIFIER :: ^struct {
    cbSize   : u32,
    hWnd     : HWND,
    uID      : UINT,
    guidItem : GUID,
 };

 SHFILEINFOA :: struct {
    hIcon         : HICON,
    iIcon         : i32,
    dwAttributes  : u32,
    szDisplayName : [260]CHAR,
    szTypeName    : [80]CHAR,
 };

 SHFILEINFOW :: struct {
    hIcon         : HICON,
    iIcon         : i32,
    dwAttributes  : u32,
    szDisplayName : [260]WCHAR,
    szTypeName    : [80]WCHAR,
 };

 SHFILEINFO :: SHFILEINFOA;

 SHSTOCKICONINFO :: struct {
    cbSize         : u32,
    hIcon          : HICON,
    iSysImageIndex : i32,
    iIcon          : i32,
    szPath         : [260]WCHAR,
 };

 SHSTOCKICONID :: enum {
    SIID_DOCNOASSOC = 0,
    SIID_DOCASSOC = 1,
    SIID_APPLICATION = 2,
    SIID_FOLDER = 3,
    SIID_FOLDEROPEN = 4,
    SIID_DRIVE525 = 5,
    SIID_DRIVE35 = 6,
    SIID_DRIVEREMOVE = 7,
    SIID_DRIVEFIXED = 8,
    SIID_DRIVENET = 9,
    SIID_DRIVENETDISABLED = 10,
    SIID_DRIVECD = 11,
    SIID_DRIVERAM = 12,
    SIID_WORLD = 13,
    SIID_SERVER = 15,
    SIID_PRINTER = 16,
    SIID_MYNETWORK = 17,
    SIID_FIND = 22,
    SIID_HELP = 23,
    SIID_SHARE = 28,
    SIID_LINK = 29,
    SIID_SLOWFILE = 30,
    SIID_RECYCLER = 31,
    SIID_RECYCLERFULL = 32,
    SIID_MEDIACDAUDIO = 40,
    SIID_LOCK = 47,
    SIID_AUTOLIST = 49,
    SIID_PRINTERNET = 50,
    SIID_SERVERSHARE = 51,
    SIID_PRINTERFAX = 52,
    SIID_PRINTERFAXNET = 53,
    SIID_PRINTERFILE = 54,
    SIID_STACK = 55,
    SIID_MEDIASVCD = 56,
    SIID_STUFFEDFOLDER = 57,
    SIID_DRIVEUNKNOWN = 58,
    SIID_DRIVEDVD = 59,
    SIID_MEDIADVD = 60,
    SIID_MEDIADVDRAM = 61,
    SIID_MEDIADVDRW = 62,
    SIID_MEDIADVDR = 63,
    SIID_MEDIADVDROM = 64,
    SIID_MEDIACDAUDIOPLUS = 65,
    SIID_MEDIACDRW = 66,
    SIID_MEDIACDR = 67,
    SIID_MEDIACDBURN = 68,
    SIID_MEDIABLANKCD = 69,
    SIID_MEDIACDROM = 70,
    SIID_AUDIOFILES = 71,
    SIID_IMAGEFILES = 72,
    SIID_VIDEOFILES = 73,
    SIID_MIXEDFILES = 74,
    SIID_FOLDERBACK = 75,
    SIID_FOLDERFRONT = 76,
    SIID_SHIELD = 77,
    SIID_WARNING = 78,
    SIID_INFO = 79,
    SIID_ERROR = 80,
    SIID_KEY = 81,
    SIID_SOFTWARE = 82,
    SIID_RENAME = 83,
    SIID_DELETE = 84,
    SIID_MEDIAAUDIODVD = 85,
    SIID_MEDIAMOVIEDVD = 86,
    SIID_MEDIAENHANCEDCD = 87,
    SIID_MEDIAENHANCEDDVD = 88,
    SIID_MEDIAHDDVD = 89,
    SIID_MEDIABLURAY = 90,
    SIID_MEDIAVCD = 91,
    SIID_MEDIADVDPLUSR = 92,
    SIID_MEDIADVDPLUSRW = 93,
    SIID_DESKTOPPC = 94,
    SIID_MOBILEPC = 95,
    SIID_USERS = 96,
    SIID_MEDIASMARTMEDIA = 97,
    SIID_MEDIACOMPACTFLASH = 98,
    SIID_DEVICECELLPHONE = 99,
    SIID_DEVICECAMERA = 100,
    SIID_DEVICEVIDEOCAMERA = 101,
    SIID_DEVICEAUDIOPLAYER = 102,
    SIID_NETWORKCONNECT = 103,
    SIID_INTERNET = 104,
    SIID_ZIPFILE = 105,
    SIID_SETTINGS = 106,
    SIID_DRIVEHDDVD = 132,
    SIID_DRIVEBD = 133,
    SIID_MEDIAHDDVDROM = 134,
    SIID_MEDIAHDDVDR = 135,
    SIID_MEDIAHDDVDRAM = 136,
    SIID_MEDIABDROM = 137,
    SIID_MEDIABDR = 138,
    SIID_MEDIABDRE = 139,
    SIID_CLUSTEREDDRIVE = 140,
    SIID_MAX_ICONS = 181,
 };

 OPEN_PRINTER_PROPS_INFOA :: struct {
    dwSize       : u32,
    pszSheetName : LPSTR,
    uSheetIndex  : UINT,
    dwFlags      : u32,
    bModal       : BOOL,
 };
 POPEN_PRINTER_PROPS_INFOA :: ^struct {
    dwSize       : u32,
    pszSheetName : LPSTR,
    uSheetIndex  : UINT,
    dwFlags      : u32,
    bModal       : BOOL,
 };

 OPEN_PRINTER_PROPS_INFOW :: struct {
    dwSize       : u32,
    pszSheetName : LPWSTR,
    uSheetIndex  : UINT,
    dwFlags      : u32,
    bModal       : BOOL,
 };
 POPEN_PRINTER_PROPS_INFOW :: ^struct {
    dwSize       : u32,
    pszSheetName : LPWSTR,
    uSheetIndex  : UINT,
    dwFlags      : u32,
    bModal       : BOOL,
 };

 OPEN_PRINTER_PROPS_INFO :: OPEN_PRINTER_PROPS_INFOA;

 POPEN_PRINTER_PROPS_INFO :: POPEN_PRINTER_PROPS_INFOA;

 PFNCANSHAREFOLDERW :: (proc(pszPath : PCWSTR) -> HRESULT);

 PFNSHOWSHAREFOLDERUIW :: (proc(hwndParent : HWND, pszPath : PCWSTR) -> HRESULT);

 NC_ADDRESS :: struct {
    pAddrInfo    : ^NET_ADDRESS_INFO_,
    PortNumber   : USHORT,
    PrefixLength : BYTE,
 };
 PNC_ADDRESS :: ^struct {
    pAddrInfo    : ^NET_ADDRESS_INFO_,
    PortNumber   : USHORT,
    PrefixLength : BYTE,
 };

 PERF_DATA_BLOCK :: struct {
    Signature        : [4]WCHAR,
    LittleEndian     : u32,
    Version          : u32,
    Revision         : u32,
    TotalByteLength  : u32,
    HeaderLength     : u32,
    NumObjectTypes   : u32,
    DefaultObject    : LONG,
    SystemTime       : SYSTEMTIME,
    PerfTime         : LARGE_INTEGER,
    PerfFreq         : LARGE_INTEGER,
    PerfTime100nSec  : LARGE_INTEGER,
    SystemNameLength : u32,
    SystemNameOffset : u32,
 };
 PPERF_DATA_BLOCK :: ^struct {
    Signature        : [4]WCHAR,
    LittleEndian     : u32,
    Version          : u32,
    Revision         : u32,
    TotalByteLength  : u32,
    HeaderLength     : u32,
    NumObjectTypes   : u32,
    DefaultObject    : LONG,
    SystemTime       : SYSTEMTIME,
    PerfTime         : LARGE_INTEGER,
    PerfFreq         : LARGE_INTEGER,
    PerfTime100nSec  : LARGE_INTEGER,
    SystemNameLength : u32,
    SystemNameOffset : u32,
 };

 PERF_OBJECT_TYPE :: struct {
    TotalByteLength      : u32,
    DefinitionLength     : u32,
    HeaderLength         : u32,
    ObjectNameTitleIndex : u32,
    ObjectNameTitle      : LPWSTR,
    ObjectHelpTitleIndex : u32,
    ObjectHelpTitle      : LPWSTR,
    DetailLevel          : u32,
    NumCounters          : u32,
    DefaultCounter       : LONG,
    NumInstances         : LONG,
    CodePage             : u32,
    PerfTime             : LARGE_INTEGER,
    PerfFreq             : LARGE_INTEGER,
 };
 PPERF_OBJECT_TYPE :: ^struct {
    TotalByteLength      : u32,
    DefinitionLength     : u32,
    HeaderLength         : u32,
    ObjectNameTitleIndex : u32,
    ObjectNameTitle      : LPWSTR,
    ObjectHelpTitleIndex : u32,
    ObjectHelpTitle      : LPWSTR,
    DetailLevel          : u32,
    NumCounters          : u32,
    DefaultCounter       : LONG,
    NumInstances         : LONG,
    CodePage             : u32,
    PerfTime             : LARGE_INTEGER,
    PerfFreq             : LARGE_INTEGER,
 };

 PERF_COUNTER_DEFINITION :: struct {
    ByteLength            : u32,
    CounterNameTitleIndex : u32,
    CounterNameTitle      : LPWSTR,
    CounterHelpTitleIndex : u32,
    CounterHelpTitle      : LPWSTR,
    DefaultScale          : LONG,
    DetailLevel           : u32,
    CounterType           : u32,
    CounterSize           : u32,
    CounterOffset         : u32,
 };
 PPERF_COUNTER_DEFINITION :: ^struct {
    ByteLength            : u32,
    CounterNameTitleIndex : u32,
    CounterNameTitle      : LPWSTR,
    CounterHelpTitleIndex : u32,
    CounterHelpTitle      : LPWSTR,
    DefaultScale          : LONG,
    DetailLevel           : u32,
    CounterType           : u32,
    CounterSize           : u32,
    CounterOffset         : u32,
 };

 PERF_INSTANCE_DEFINITION :: struct {
    ByteLength             : u32,
    ParentObjectTitleIndex : u32,
    ParentObjectInstance   : u32,
    UniqueID               : LONG,
    NameOffset             : u32,
    NameLength             : u32,
 };
 PPERF_INSTANCE_DEFINITION :: ^struct {
    ByteLength             : u32,
    ParentObjectTitleIndex : u32,
    ParentObjectInstance   : u32,
    UniqueID               : LONG,
    NameOffset             : u32,
    NameLength             : u32,
 };

 PERF_COUNTER_BLOCK :: struct {
    ByteLength : u32,
 };
 PPERF_COUNTER_BLOCK :: ^struct {
    ByteLength : u32,
 };

 PM_OPEN_PROC :: #type (proc(LPWSTR) -> u32);

 PM_COLLECT_PROC :: #type (proc(lpValueName : LPWSTR, lppData : ^LPVOID, lpcbTotalBytes : LPDWORD, lpNumObjectTypes : LPDWORD) -> u32);

 PM_CLOSE_PROC :: #type (proc(void) -> u32);

 PM_QUERY_PROC :: #type (proc(LPDWORD, ^LPVOID, LPDWORD, LPDWORD) -> u32);

 u_char :: u8;

 u_short :: u16;

 u_int :: u32;

 u_long :: u64;

 SOCKET :: UINT_PTR;

 FD_SET :: struct {
    fd_count : u_int,
    fd_array : [64]SOCKET,
 };

 TIMEVAL :: struct {
    tv_sec  : i64,
    tv_usec : i64,
 };

 HOSTENT :: struct {
    h_name      : cstring,
    h_aliases   : ^cstring,
    h_addrtype  : i16,
    h_length    : i16,
    h_addr_list : ^cstring,
 };

 netent :: struct {
    n_name     : cstring,
    n_aliases  : ^cstring,
    n_addrtype : i16,
    n_net      : u_long,
 };

 SERVENT :: struct {
    s_name    : cstring,
    s_aliases : ^cstring,
    s_port    : i16,
    s_proto   : cstring,
 };

 PROTOENT :: struct {
    p_name    : cstring,
    p_aliases : ^cstring,
    p_proto   : i16,
 };

 IN_ADDR :: struct {
    S_un : struct #raw_union {
        S_un_b : struct {
            s_b1 : UCHAR,
            s_b2 : UCHAR,
            s_b3 : UCHAR,
            s_b4 : UCHAR,
        },
        S_un_w : struct {
            s_w1 : USHORT,
            s_w2 : USHORT,
        },
        S_addr : ULONG,
    },
 };
 PIN_ADDR :: ^struct {
    S_un : struct #raw_union {
        S_un_b : struct {
            s_b1 : UCHAR,
            s_b2 : UCHAR,
            s_b3 : UCHAR,
            s_b4 : UCHAR,
        },
        S_un_w : struct {
            s_w1 : USHORT,
            s_w2 : USHORT,
        },
        S_addr : ULONG,
    },
 };
 LPIN_ADDR :: ^struct {
    S_un : struct #raw_union {
        S_un_b : struct {
            s_b1 : UCHAR,
            s_b2 : UCHAR,
            s_b3 : UCHAR,
            s_b4 : UCHAR,
        },
        S_un_w : struct {
            s_w1 : USHORT,
            s_w2 : USHORT,
        },
        S_addr : ULONG,
    },
 };

 SOCKADDR_IN :: struct {
    sin_family : i16,
    sin_port   : u_short,
    sin_addr   : IN_ADDR,
    sin_zero   : [8]u8,
 };

 WSADATA :: struct {
    wVersion       : u16,
    wHighVersion   : u16,
    szDescription  : [256 + 1]u8,
    szSystemStatus : [128 + 1]u8,
    iMaxSockets    : u16,
    iMaxUdpDg      : u16,
    lpVendorInfo   : cstring,
 };

 LPWSADATA :: ^WSADATA;

 ip_mreq :: struct {
    imr_multiaddr : IN_ADDR,
    imr_interface : IN_ADDR,
 };

 SOCKADDR :: struct {
    sa_family : u_short,
    sa_data   : [14]u8,
 };

 sockproto :: struct {
    sp_family   : u_short,
    sp_protocol : u_short,
 };

 LINGER :: struct {
    l_onoff  : u_short,
    l_linger : u_short,
 };

 TRANSMIT_FILE_BUFFERS :: struct {
    Head       : PVOID,
    HeadLength : u32,
    Tail       : PVOID,
    TailLength : u32,
 };
 PTRANSMIT_FILE_BUFFERS :: ^struct {
    Head       : PVOID,
    HeadLength : u32,
    Tail       : PVOID,
    TailLength : u32,
 };
 LPTRANSMIT_FILE_BUFFERS :: ^struct {
    Head       : PVOID,
    HeadLength : u32,
    Tail       : PVOID,
    TailLength : u32,
 };

 SOCKADDR :: struct {};

 ;

 PSOCKADDR :: ^SOCKADDR;

 LPSOCKADDR :: ^SOCKADDR;

 SOCKADDR_IN :: struct {};

 ;

 PSOCKADDR_IN :: ^SOCKADDR_IN;

 LPSOCKADDR_IN :: ^SOCKADDR_IN;

 LINGER :: struct {};

 ;

 PLINGER :: ^LINGER;

 LPLINGER :: ^LINGER;

 FD_SET :: struct {};

 ;

 PFD_SET :: ^FD_SET;

 LPFD_SET :: ^FD_SET;

 HOSTENT :: struct {};

 ;

 PHOSTENT :: ^HOSTENT;

 LPHOSTENT :: ^HOSTENT;

 SERVENT :: struct {};

 ;

 PSERVENT :: ^SERVENT;

 LPSERVENT :: ^SERVENT;

 PROTOENT :: struct {};

 ;

 PPROTOENT :: ^PROTOENT;

 LPPROTOENT :: ^PROTOENT;

 TIMEVAL :: struct {};

 ;

 PTIMEVAL :: ^TIMEVAL;

 LPTIMEVAL :: ^TIMEVAL;

 ALG_ID :: u32;

 HCRYPTPROV :: ULONG_PTR;

 HCRYPTKEY :: ULONG_PTR;

 HCRYPTHASH :: ULONG_PTR;

 CMS_KEY_INFO :: struct {
    dwVersion : u32,
    Algid     : ALG_ID,
    pbOID     : ^BYTE,
    cbOID     : u32,
 };
 PCMS_KEY_INFO :: ^struct {
    dwVersion : u32,
    Algid     : ALG_ID,
    pbOID     : ^BYTE,
    cbOID     : u32,
 };

 HMAC_INFO :: struct {
    HashAlgid     : ALG_ID,
    pbInnerString : ^BYTE,
    cbInnerString : u32,
    pbOuterString : ^BYTE,
    cbOuterString : u32,
 };
 PHMAC_INFO :: ^struct {
    HashAlgid     : ALG_ID,
    pbInnerString : ^BYTE,
    cbInnerString : u32,
    pbOuterString : ^BYTE,
    cbOuterString : u32,
 };

 SCHANNEL_ALG :: struct {
    dwUse      : u32,
    Algid      : ALG_ID,
    cBits      : u32,
    dwFlags    : u32,
    dwReserved : u32,
 };
 PSCHANNEL_ALG :: ^struct {
    dwUse      : u32,
    Algid      : ALG_ID,
    cBits      : u32,
    dwFlags    : u32,
    dwReserved : u32,
 };

 PROV_ENUMALGS :: struct {
    aiAlgid   : ALG_ID,
    dwBitLen  : u32,
    dwNameLen : u32,
    szName    : [20]CHAR,
 };

 PROV_ENUMALGS_EX :: struct {
    aiAlgid       : ALG_ID,
    dwDefaultLen  : u32,
    dwMinLen      : u32,
    dwMaxLen      : u32,
    dwProtocols   : u32,
    dwNameLen     : u32,
    szName        : [20]CHAR,
    dwLongNameLen : u32,
    szLongName    : [40]CHAR,
 };

 BLOBHEADER :: struct {
    bType    : BYTE,
    bVersion : BYTE,
    reserved : u16,
    aiKeyAlg : ALG_ID,
 };
 PUBLICKEYSTRUC :: struct {
    bType    : BYTE,
    bVersion : BYTE,
    reserved : u16,
    aiKeyAlg : ALG_ID,
 };

 RSAPUBKEY :: struct {
    magic  : u32,
    bitlen : u32,
    pubexp : u32,
 };

 DHPUBKEY :: struct {
    magic  : u32,
    bitlen : u32,
 };
 DSSPUBKEY :: struct {
    magic  : u32,
    bitlen : u32,
 };
 KEAPUBKEY :: struct {
    magic  : u32,
    bitlen : u32,
 };
 TEKPUBKEY :: struct {
    magic  : u32,
    bitlen : u32,
 };

 DSSSEED :: struct {
    counter : u32,
    seed    : [20]BYTE,
 };

 DHPUBKEY_VER3 :: struct {
    magic   : u32,
    bitlenP : u32,
    bitlenQ : u32,
    bitlenJ : u32,
    DSSSeed : DSSSEED,
 };
 DSSPUBKEY_VER3 :: struct {
    magic   : u32,
    bitlenP : u32,
    bitlenQ : u32,
    bitlenJ : u32,
    DSSSeed : DSSSEED,
 };

 DHPRIVKEY_VER3 :: struct {
    magic   : u32,
    bitlenP : u32,
    bitlenQ : u32,
    bitlenJ : u32,
    bitlenX : u32,
    DSSSeed : DSSSEED,
 };
 DSSPRIVKEY_VER3 :: struct {
    magic   : u32,
    bitlenP : u32,
    bitlenQ : u32,
    bitlenJ : u32,
    bitlenX : u32,
    DSSSeed : DSSSEED,
 };

 KEY_TYPE_SUBTYPE :: struct {
    dwKeySpec : u32,
    Type      : GUID,
    Subtype   : GUID,
 };
 PKEY_TYPE_SUBTYPE :: ^struct {
    dwKeySpec : u32,
    Type      : GUID,
    Subtype   : GUID,
 };

 CERT_FORTEZZA_DATA_PROP :: struct {
    SerialNumber : [8]u8,
    CertIndex    : i32,
    CertLabel    : [36]u8,
 };

 CRYPT_RC4_KEY_STATE :: struct {
    Key  : [16]u8,
    SBox : [256]u8,
    i    : u8,
    j    : u8,
 };
 PCRYPT_RC4_KEY_STATE :: ^struct {
    Key  : [16]u8,
    SBox : [256]u8,
    i    : u8,
    j    : u8,
 };

 CRYPT_DES_KEY_STATE :: struct {
    Key      : [8]u8,
    IV       : [8]u8,
    Feedback : [8]u8,
 };
 PCRYPT_DES_KEY_STATE :: ^struct {
    Key      : [8]u8,
    IV       : [8]u8,
    Feedback : [8]u8,
 };

 CRYPT_3DES_KEY_STATE :: struct {
    Key      : [24]u8,
    IV       : [8]u8,
    Feedback : [8]u8,
 };
 PCRYPT_3DES_KEY_STATE :: ^struct {
    Key      : [24]u8,
    IV       : [8]u8,
    Feedback : [8]u8,
 };

 CRYPT_AES_128_KEY_STATE :: struct {
    Key             : [16]u8,
    IV              : [16]u8,
    EncryptionState : [11][16]u8,
    DecryptionState : [11][16]u8,
    Feedback        : [16]u8,
 };
 PCRYPT_AES_128_KEY_STATE :: ^struct {
    Key             : [16]u8,
    IV              : [16]u8,
    EncryptionState : [11][16]u8,
    DecryptionState : [11][16]u8,
    Feedback        : [16]u8,
 };

 CRYPT_AES_256_KEY_STATE :: struct {
    Key             : [32]u8,
    IV              : [16]u8,
    EncryptionState : [15][16]u8,
    DecryptionState : [15][16]u8,
    Feedback        : [16]u8,
 };
 PCRYPT_AES_256_KEY_STATE :: ^struct {
    Key             : [32]u8,
    IV              : [16]u8,
    EncryptionState : [15][16]u8,
    DecryptionState : [15][16]u8,
    Feedback        : [16]u8,
 };

 CRYPT_INTEGER_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_INTEGER_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRYPT_UINT_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_UINT_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRYPT_OBJID_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_OBJID_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CERT_NAME_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCERT_NAME_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CERT_RDN_VALUE_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCERT_RDN_VALUE_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CERT_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCERT_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRL_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRL_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 DATA_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PDATA_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRYPT_DATA_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_DATA_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRYPT_HASH_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_HASH_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRYPT_DIGEST_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_DIGEST_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRYPT_DER_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_DER_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 CRYPT_ATTR_BLOB :: struct {
    cbData : u32,
    pbData : ^BYTE,
 };
 PCRYPT_ATTR_BLOB :: ^struct {
    cbData : u32,
    pbData : ^BYTE,
 };

 CMS_DH_KEY_INFO :: struct {
    dwVersion          : u32,
    Algid              : ALG_ID,
    pszContentEncObjId : LPSTR,
    PubInfo            : CRYPT_DATA_BLOB,
    pReserved          : rawptr,
 };
 PCMS_DH_KEY_INFO :: ^struct {
    dwVersion          : u32,
    Algid              : ALG_ID,
    pszContentEncObjId : LPSTR,
    PubInfo            : CRYPT_DATA_BLOB,
    pReserved          : rawptr,
 };

 NTSTATUS :: LONG;

 PNTSTATUS :: ^NTSTATUS;

 BCRYPT_KEY_LENGTHS_STRUCT :: struct {
    dwMinLength : ULONG,
    dwMaxLength : ULONG,
    dwIncrement : ULONG,
 };

 BCRYPT_AUTH_TAG_LENGTHS_STRUCT :: BCRYPT_KEY_LENGTHS_STRUCT;

 BCRYPT_OID :: struct {
    cbOID : ULONG,
    pbOID : PUCHAR,
 };

 BCRYPT_OID_LIST :: struct {
    dwOIDCount : ULONG,
    pOIDs      : ^BCRYPT_OID,
 };

 BCRYPT_PKCS1_PADDING_INFO :: struct {
    pszAlgId : LPCWSTR,
 };

 BCRYPT_PSS_PADDING_INFO :: struct {
    pszAlgId : LPCWSTR,
    cbSalt   : ULONG,
 };

 BCRYPT_OAEP_PADDING_INFO :: struct {
    pszAlgId : LPCWSTR,
    pbLabel  : PUCHAR,
    cbLabel  : ULONG,
 };

 BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO :: struct {
    cbSize        : ULONG,
    dwInfoVersion : ULONG,
    pbNonce       : PUCHAR,
    cbNonce       : ULONG,
    pbAuthData    : PUCHAR,
    cbAuthData    : ULONG,
    pbTag         : PUCHAR,
    cbTag         : ULONG,
    pbMacContext  : PUCHAR,
    cbMacContext  : ULONG,
    cbAAD         : ULONG,
    cbData        : ULONGLONG,
    dwFlags       : ULONG,
 };
 PBCRYPT_AUTHENTICATED_CIPHER_MODE_INFO :: ^struct {
    cbSize        : ULONG,
    dwInfoVersion : ULONG,
    pbNonce       : PUCHAR,
    cbNonce       : ULONG,
    pbAuthData    : PUCHAR,
    cbAuthData    : ULONG,
    pbTag         : PUCHAR,
    cbTag         : ULONG,
    pbMacContext  : PUCHAR,
    cbMacContext  : ULONG,
    cbAAD         : ULONG,
    cbData        : ULONGLONG,
    dwFlags       : ULONG,
 };

 BCryptBuffer :: struct {
    cbBuffer   : ULONG,
    BufferType : ULONG,
    pvBuffer   : PVOID,
 };
 PBCryptBuffer :: ^struct {
    cbBuffer   : ULONG,
    BufferType : ULONG,
    pvBuffer   : PVOID,
 };

 BCryptBufferDesc :: struct {
    ulVersion : ULONG,
    cBuffers  : ULONG,
    pBuffers  : PBCryptBuffer,
 };
 PBCryptBufferDesc :: ^struct {
    ulVersion : ULONG,
    cBuffers  : ULONG,
    pBuffers  : PBCryptBuffer,
 };

 BCRYPT_HANDLE :: PVOID;

 BCRYPT_ALG_HANDLE :: PVOID;

 BCRYPT_KEY_HANDLE :: PVOID;

 BCRYPT_HASH_HANDLE :: PVOID;

 BCRYPT_SECRET_HANDLE :: PVOID;

 BCRYPT_KEY_BLOB :: struct {
    Magic : ULONG,
 };

 BCRYPT_RSAKEY_BLOB :: struct {
    Magic       : ULONG,
    BitLength   : ULONG,
    cbPublicExp : ULONG,
    cbModulus   : ULONG,
    cbPrime1    : ULONG,
    cbPrime2    : ULONG,
 };

 BCRYPT_ECCKEY_BLOB :: struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
 };
 PBCRYPT_ECCKEY_BLOB :: ^struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
 };

 SSL_ECCKEY_BLOB :: struct {
    dwCurveType : ULONG,
    cbKey       : ULONG,
 };
 PSSL_ECCKEY_BLOB :: ^struct {
    dwCurveType : ULONG,
    cbKey       : ULONG,
 };

 ECC_CURVE_TYPE_ENUM :: enum {
    BCRYPT_ECC_PRIME_SHORT_WEIERSTRASS_CURVE = 0x1,
    BCRYPT_ECC_PRIME_TWISTED_EDWARDS_CURVE = 0x2,
    BCRYPT_ECC_PRIME_MONTGOMERY_CURVE = 0x3,
 };

 ECC_CURVE_ALG_ID_ENUM :: enum {
    BCRYPT_NO_CURVE_GENERATION_ALG_ID = 0x0,
 };

 BCRYPT_ECCFULLKEY_BLOB :: struct {
    dwMagic                : ULONG,
    dwVersion              : ULONG,
    dwCurveType            : ECC_CURVE_TYPE_ENUM,
    dwCurveGenerationAlgId : ECC_CURVE_ALG_ID_ENUM,
    cbFieldLength          : ULONG,
    cbSubgroupOrder        : ULONG,
    cbCofactor             : ULONG,
    cbSeed                 : ULONG,
 };
 PBCRYPT_ECCFULLKEY_BLOB :: ^struct {
    dwMagic                : ULONG,
    dwVersion              : ULONG,
    dwCurveType            : ECC_CURVE_TYPE_ENUM,
    dwCurveGenerationAlgId : ECC_CURVE_ALG_ID_ENUM,
    cbFieldLength          : ULONG,
    cbSubgroupOrder        : ULONG,
    cbCofactor             : ULONG,
    cbSeed                 : ULONG,
 };

 BCRYPT_DH_KEY_BLOB :: struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
 };
 PBCRYPT_DH_KEY_BLOB :: ^struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
 };

 BCRYPT_DH_PARAMETER_HEADER :: struct {
    cbLength    : ULONG,
    dwMagic     : ULONG,
    cbKeyLength : ULONG,
 };

 BCRYPT_DSA_KEY_BLOB :: struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
    Count   : [4]UCHAR,
    Seed    : [20]UCHAR,
    q       : [20]UCHAR,
 };
 PBCRYPT_DSA_KEY_BLOB :: ^struct {
    dwMagic : ULONG,
    cbKey   : ULONG,
    Count   : [4]UCHAR,
    Seed    : [20]UCHAR,
    q       : [20]UCHAR,
 };

 HASHALGORITHM_ENUM :: enum {
    DSA_HASH_ALGORITHM_SHA1,
    DSA_HASH_ALGORITHM_SHA256,
    DSA_HASH_ALGORITHM_SHA512,
 };

 DSAFIPSVERSION_ENUM :: enum {
    DSA_FIPS186_2,
    DSA_FIPS186_3,
 };

 BCRYPT_DSA_KEY_BLOB_V2 :: struct {
    dwMagic         : ULONG,
    cbKey           : ULONG,
    hashAlgorithm   : HASHALGORITHM_ENUM,
    standardVersion : DSAFIPSVERSION_ENUM,
    cbSeedLength    : ULONG,
    cbGroupSize     : ULONG,
    Count           : [4]UCHAR,
 };
 PBCRYPT_DSA_KEY_BLOB_V2 :: ^struct {
    dwMagic         : ULONG,
    cbKey           : ULONG,
    hashAlgorithm   : HASHALGORITHM_ENUM,
    standardVersion : DSAFIPSVERSION_ENUM,
    cbSeedLength    : ULONG,
    cbGroupSize     : ULONG,
    Count           : [4]UCHAR,
 };

 BCRYPT_KEY_DATA_BLOB_HEADER :: struct {
    dwMagic   : ULONG,
    dwVersion : ULONG,
    cbKeyData : ULONG,
 };
 PBCRYPT_KEY_DATA_BLOB_HEADER :: ^struct {
    dwMagic   : ULONG,
    dwVersion : ULONG,
    cbKeyData : ULONG,
 };

 BCRYPT_DSA_PARAMETER_HEADER :: struct {
    cbLength    : ULONG,
    dwMagic     : ULONG,
    cbKeyLength : ULONG,
    Count       : [4]UCHAR,
    Seed        : [20]UCHAR,
    q           : [20]UCHAR,
 };

 BCRYPT_DSA_PARAMETER_HEADER_V2 :: struct {
    cbLength        : ULONG,
    dwMagic         : ULONG,
    cbKeyLength     : ULONG,
    hashAlgorithm   : HASHALGORITHM_ENUM,
    standardVersion : DSAFIPSVERSION_ENUM,
    cbSeedLength    : ULONG,
    cbGroupSize     : ULONG,
    Count           : [4]UCHAR,
 };

 BCRYPT_ECC_CURVE_NAMES :: struct {
    dwEccCurveNames : ULONG,
    pEccCurveNames  : ^LPWSTR,
 };

 BCRYPT_HASH_OPERATION_TYPE :: enum {
    BCRYPT_HASH_OPERATION_HASH_DATA = 1,
    BCRYPT_HASH_OPERATION_FINISH_HASH = 2,
 };

 BCRYPT_MULTI_HASH_OPERATION :: struct {
    iHash         : ULONG,
    hashOperation : BCRYPT_HASH_OPERATION_TYPE,
    pbBuffer      : PUCHAR,
    cbBuffer      : ULONG,
 };

 BCRYPT_MULTI_OPERATION_TYPE :: enum {
    BCRYPT_OPERATION_TYPE_HASH = 1,
 };

 BCRYPT_MULTI_OBJECT_LENGTH_STRUCT :: struct {
    cbPerObject  : ULONG,
    cbPerElement : ULONG,
 };

 BCRYPT_ALGORITHM_IDENTIFIER :: struct {
    pszName : LPWSTR,
    dwClass : ULONG,
    dwFlags : ULONG,
 };

 BCRYPT_PROVIDER_NAME :: struct {
    pszProviderName : LPWSTR,
 };

 BCRYPT_INTERFACE_VERSION :: struct {
    MajorVersion : USHORT,
    MinorVersion : USHORT,
 };
 PBCRYPT_INTERFACE_VERSION :: ^struct {
    MajorVersion : USHORT,
    MinorVersion : USHORT,
 };

 CRYPT_INTERFACE_REG :: struct {
    dwInterface    : ULONG,
    dwFlags        : ULONG,
    cFunctions     : ULONG,
    rgpszFunctions : ^PWSTR,
 };
 PCRYPT_INTERFACE_REG :: ^struct {
    dwInterface    : ULONG,
    dwFlags        : ULONG,
    cFunctions     : ULONG,
    rgpszFunctions : ^PWSTR,
 };

 CRYPT_IMAGE_REG :: struct {
    pszImage      : PWSTR,
    cInterfaces   : ULONG,
    rgpInterfaces : ^PCRYPT_INTERFACE_REG,
 };
 PCRYPT_IMAGE_REG :: ^struct {
    pszImage      : PWSTR,
    cInterfaces   : ULONG,
    rgpInterfaces : ^PCRYPT_INTERFACE_REG,
 };

 CRYPT_PROVIDER_REG :: struct {
    cAliases     : ULONG,
    rgpszAliases : ^PWSTR,
    pUM          : PCRYPT_IMAGE_REG,
    pKM          : PCRYPT_IMAGE_REG,
 };
 PCRYPT_PROVIDER_REG :: ^struct {
    cAliases     : ULONG,
    rgpszAliases : ^PWSTR,
    pUM          : PCRYPT_IMAGE_REG,
    pKM          : PCRYPT_IMAGE_REG,
 };

 CRYPT_PROVIDERS :: struct {
    cProviders     : ULONG,
    rgpszProviders : ^PWSTR,
 };
 PCRYPT_PROVIDERS :: ^struct {
    cProviders     : ULONG,
    rgpszProviders : ^PWSTR,
 };

 CRYPT_CONTEXT_CONFIG :: struct {
    dwFlags    : ULONG,
    dwReserved : ULONG,
 };
 PCRYPT_CONTEXT_CONFIG :: ^struct {
    dwFlags    : ULONG,
    dwReserved : ULONG,
 };

 CRYPT_CONTEXT_FUNCTION_CONFIG :: struct {
    dwFlags    : ULONG,
    dwReserved : ULONG,
 };
 PCRYPT_CONTEXT_FUNCTION_CONFIG :: ^struct {
    dwFlags    : ULONG,
    dwReserved : ULONG,
 };

 CRYPT_CONTEXTS :: struct {
    cContexts     : ULONG,
    rgpszContexts : ^PWSTR,
 };
 PCRYPT_CONTEXTS :: ^struct {
    cContexts     : ULONG,
    rgpszContexts : ^PWSTR,
 };

 CRYPT_CONTEXT_FUNCTIONS :: struct {
    cFunctions     : ULONG,
    rgpszFunctions : ^PWSTR,
 };
 PCRYPT_CONTEXT_FUNCTIONS :: ^struct {
    cFunctions     : ULONG,
    rgpszFunctions : ^PWSTR,
 };

 CRYPT_CONTEXT_FUNCTION_PROVIDERS :: struct {
    cProviders     : ULONG,
    rgpszProviders : ^PWSTR,
 };
 PCRYPT_CONTEXT_FUNCTION_PROVIDERS :: ^struct {
    cProviders     : ULONG,
    rgpszProviders : ^PWSTR,
 };

 CRYPT_PROPERTY_REF :: struct {
    pszProperty : PWSTR,
    cbValue     : ULONG,
    pbValue     : PUCHAR,
 };
 PCRYPT_PROPERTY_REF :: ^struct {
    pszProperty : PWSTR,
    cbValue     : ULONG,
    pbValue     : PUCHAR,
 };

 CRYPT_IMAGE_REF :: struct {
    pszImage : PWSTR,
    dwFlags  : ULONG,
 };
 PCRYPT_IMAGE_REF :: ^struct {
    pszImage : PWSTR,
    dwFlags  : ULONG,
 };

 CRYPT_PROVIDER_REF :: struct {
    dwInterface   : ULONG,
    pszFunction   : PWSTR,
    pszProvider   : PWSTR,
    cProperties   : ULONG,
    rgpProperties : ^PCRYPT_PROPERTY_REF,
    pUM           : PCRYPT_IMAGE_REF,
    pKM           : PCRYPT_IMAGE_REF,
 };
 PCRYPT_PROVIDER_REF :: ^struct {
    dwInterface   : ULONG,
    pszFunction   : PWSTR,
    pszProvider   : PWSTR,
    cProperties   : ULONG,
    rgpProperties : ^PCRYPT_PROPERTY_REF,
    pUM           : PCRYPT_IMAGE_REF,
    pKM           : PCRYPT_IMAGE_REF,
 };

 CRYPT_PROVIDER_REFS :: struct {
    cProviders   : ULONG,
    rgpProviders : ^PCRYPT_PROVIDER_REF,
 };
 PCRYPT_PROVIDER_REFS :: ^struct {
    cProviders   : ULONG,
    rgpProviders : ^PCRYPT_PROVIDER_REF,
 };

 SECURITY_STATUS :: LONG;

 PFN_NCRYPT_ALLOC :: (proc(cbSize : SIZE_T) -> LPVOID);

 PFN_NCRYPT_FREE :: proc(pv : LPVOID);

 NCRYPT_ALLOC_PARA :: struct {
    cbSize   : u32,
    pfnAlloc : PFN_NCRYPT_ALLOC,
    pfnFree  : PFN_NCRYPT_FREE,
 };

 NCryptBuffer :: BCryptBuffer;

 PNCryptBuffer :: ^BCryptBuffer;

 NCryptBufferDesc :: BCryptBufferDesc;

 PNCryptBufferDesc :: ^BCryptBufferDesc;

 NCRYPT_HANDLE :: ULONG_PTR;

 NCRYPT_PROV_HANDLE :: ULONG_PTR;

 NCRYPT_KEY_HANDLE :: ULONG_PTR;

 NCRYPT_HASH_HANDLE :: ULONG_PTR;

 NCRYPT_SECRET_HANDLE :: ULONG_PTR;

 NCRYPT_CIPHER_PADDING_INFO :: struct {
    cbSize      : ULONG,
    dwFlags     : u32,
    pbIV        : PUCHAR,
    cbIV        : ULONG,
    pbOtherInfo : PUCHAR,
    cbOtherInfo : ULONG,
 };
 PNCRYPT_CIPHER_PADDING_INFO :: ^struct {
    cbSize      : ULONG,
    dwFlags     : u32,
    pbIV        : PUCHAR,
    cbIV        : ULONG,
    pbOtherInfo : PUCHAR,
    cbOtherInfo : ULONG,
 };

 NCRYPT_PLATFORM_ATTEST_PADDING_INFO :: struct {
    magic   : ULONG,
    pcrMask : ULONG,
 };

 NCRYPT_KEY_ATTEST_PADDING_INFO :: struct {
    magic     : ULONG,
    pbKeyBlob : PUCHAR,
    cbKeyBlob : ULONG,
    pbKeyAuth : PUCHAR,
    cbKeyAuth : ULONG,
 };

 NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES :: struct {
    Version         : ULONG,
    Flags           : ULONG,
    cbPublicKeyBlob : ULONG,
 };
 PNCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES :: ^struct {
    Version         : ULONG,
    Flags           : ULONG,
    cbPublicKeyBlob : ULONG,
 };

 NCRYPT_VSM_KEY_ATTESTATION_STATEMENT :: struct {
    Magic        : ULONG,
    Version      : ULONG,
    cbSignature  : ULONG,
    cbReport     : ULONG,
    cbAttributes : ULONG,
 };
 PNCRYPT_VSM_KEY_ATTESTATION_STATEMENT :: ^struct {
    Magic        : ULONG,
    Version      : ULONG,
    cbSignature  : ULONG,
    cbReport     : ULONG,
    cbAttributes : ULONG,
 };

 NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS :: struct {
    Version        : ULONG,
    TrustletId     : ULONGLONG,
    MinSvn         : ULONG,
    FlagsMask      : ULONG,
    FlagsExpected  : ULONG,
    AllowDebugging : ,
    Reserved       : ,
 };
 PNCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS :: ^struct {
    Version        : ULONG,
    TrustletId     : ULONGLONG,
    MinSvn         : ULONG,
    FlagsMask      : ULONG,
    FlagsExpected  : ULONG,
    AllowDebugging : ,
    Reserved       : ,
 };

 NCRYPT_EXPORTED_ISOLATED_KEY_HEADER :: struct {
    Version       : ULONG,
    KeyUsage      : ULONG,
    PerBootKey    : ,
    Reserved      : ,
    cbAlgName     : ULONG,
    cbNonce       : ULONG,
    cbAuthTag     : ULONG,
    cbWrappingKey : ULONG,
    cbIsolatedKey : ULONG,
 };
 PNCRYPT_EXPORTED_ISOLATED_KEY_HEADER :: ^struct {
    Version       : ULONG,
    KeyUsage      : ULONG,
    PerBootKey    : ,
    Reserved      : ,
    cbAlgName     : ULONG,
    cbNonce       : ULONG,
    cbAuthTag     : ULONG,
    cbWrappingKey : ULONG,
    cbIsolatedKey : ULONG,
 };

 NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE :: struct {
    Header : NCRYPT_EXPORTED_ISOLATED_KEY_HEADER,
 };
 PNCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE :: ^struct {
    Header : NCRYPT_EXPORTED_ISOLATED_KEY_HEADER,
 };

 NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT :: struct {
    Magic         : UINT32,
    Version       : UINT32,
    HeaderSize    : UINT32,
    cbCertifyInfo : UINT32,
    cbSignature   : UINT32,
    cbTpmPublic   : UINT32,
 };
 PNCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT :: ^struct {
    Magic         : UINT32,
    Version       : UINT32,
    HeaderSize    : UINT32,
    cbCertifyInfo : UINT32,
    cbSignature   : UINT32,
    cbTpmPublic   : UINT32,
 };

 NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT :: struct {
    Magic       : ULONG,
    Version     : ULONG,
    pcrAlg      : ULONG,
    cbSignature : ULONG,
    cbQuote     : ULONG,
    cbPcrs      : ULONG,
 };
 PNCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT :: ^struct {
    Magic       : ULONG,
    Version     : ULONG,
    pcrAlg      : ULONG,
    cbSignature : ULONG,
    cbQuote     : ULONG,
    cbPcrs      : ULONG,
 };

 NCryptAlgorithmName :: struct {
    pszName         : LPWSTR,
    dwClass         : u32,
    dwAlgOperations : u32,
    dwFlags         : u32,
 };

 NCryptKeyName :: struct {
    pszName         : LPWSTR,
    pszAlgid        : LPWSTR,
    dwLegacyKeySpec : u32,
    dwFlags         : u32,
 };

 NCryptProviderName :: struct {
    pszName    : LPWSTR,
    pszComment : LPWSTR,
 };

 NCRYPT_UI_POLICY :: struct {
    dwVersion        : u32,
    dwFlags          : u32,
    pszCreationTitle : LPCWSTR,
    pszFriendlyName  : LPCWSTR,
    pszDescription   : LPCWSTR,
 };

 NCRYPT_KEY_ACCESS_POLICY_BLOB :: struct {
    dwVersion        : u32,
    dwPolicyFlags    : u32,
    cbUserSid        : u32,
    cbApplicationSid : u32,
 };

 NCRYPT_SUPPORTED_LENGTHS :: struct {
    dwMinLength     : u32,
    dwMaxLength     : u32,
    dwIncrement     : u32,
    dwDefaultLength : u32,
 };

 NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO :: struct {
    dwVersion    : u32,
    iExpiration  : INT32,
    pabNonce     : [32]BYTE,
    pabPolicyRef : [32]BYTE,
    pabHMAC      : [32]BYTE,
 };

 NCRYPT_PCP_TPM_FW_VERSION_INFO :: struct {
    major1 : UINT16,
    major2 : UINT16,
    minor1 : UINT16,
    minor2 : UINT16,
 };

 NCRYPT_PCP_RAW_POLICYDIGEST_INFO :: struct {
    dwVersion : u32,
    cbDigest  : u32,
 };

 NCRYPT_KEY_BLOB_HEADER :: struct {
    cbSize    : ULONG,
    dwMagic   : ULONG,
    cbAlgName : ULONG,
    cbKeyData : ULONG,
 };
 PNCRYPT_KEY_BLOB_HEADER :: ^struct {
    cbSize    : ULONG,
    dwMagic   : ULONG,
    cbAlgName : ULONG,
    cbKeyData : ULONG,
 };

 NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER :: struct {
    magic     : u32,
    cbHeader  : u32,
    cbPublic  : u32,
    cbPrivate : u32,
    cbName    : u32,
 };
 PNCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER :: ^struct {
    magic     : u32,
    cbHeader  : u32,
    cbPublic  : u32,
    cbPrivate : u32,
    cbName    : u32,
 };

 HCRYPTPROV_OR_NCRYPT_KEY_HANDLE :: ULONG_PTR;

 HCRYPTPROV_LEGACY :: ULONG_PTR;

 CRYPT_BIT_BLOB :: struct {
    cbData      : u32,
    pbData      : ^BYTE,
    cUnusedBits : u32,
 };
 PCRYPT_BIT_BLOB :: ^struct {
    cbData      : u32,
    pbData      : ^BYTE,
    cUnusedBits : u32,
 };

 CRYPT_ALGORITHM_IDENTIFIER :: struct {
    pszObjId   : LPSTR,
    Parameters : CRYPT_OBJID_BLOB,
 };
 PCRYPT_ALGORITHM_IDENTIFIER :: ^struct {
    pszObjId   : LPSTR,
    Parameters : CRYPT_OBJID_BLOB,
 };

 CRYPT_OBJID_TABLE :: struct {
    dwAlgId  : u32,
    pszObjId : LPCSTR,
 };
 PCRYPT_OBJID_TABLE :: ^struct {
    dwAlgId  : u32,
    pszObjId : LPCSTR,
 };

 CRYPT_HASH_INFO :: struct {
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Hash          : CRYPT_HASH_BLOB,
 };
 PCRYPT_HASH_INFO :: ^struct {
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Hash          : CRYPT_HASH_BLOB,
 };

 CERT_EXTENSION :: struct {
    pszObjId  : LPSTR,
    fCritical : BOOL,
    Value     : CRYPT_OBJID_BLOB,
 };
 PCERT_EXTENSION :: ^struct {
    pszObjId  : LPSTR,
    fCritical : BOOL,
    Value     : CRYPT_OBJID_BLOB,
 };

 PCCERT_EXTENSION :: ^CERT_EXTENSION;

 CRYPT_ATTRIBUTE_TYPE_VALUE :: struct {
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
 };
 PCRYPT_ATTRIBUTE_TYPE_VALUE :: ^struct {
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
 };

 CRYPT_ATTRIBUTE :: struct {
    pszObjId : LPSTR,
    cValue   : u32,
    rgValue  : PCRYPT_ATTR_BLOB,
 };
 PCRYPT_ATTRIBUTE :: ^struct {
    pszObjId : LPSTR,
    cValue   : u32,
    rgValue  : PCRYPT_ATTR_BLOB,
 };

 CRYPT_ATTRIBUTES :: struct {
    cAttr  : u32,
    rgAttr : PCRYPT_ATTRIBUTE,
 };
 PCRYPT_ATTRIBUTES :: ^struct {
    cAttr  : u32,
    rgAttr : PCRYPT_ATTRIBUTE,
 };

 CERT_RDN_ATTR :: struct {
    pszObjId    : LPSTR,
    dwValueType : u32,
    Value       : CERT_RDN_VALUE_BLOB,
 };
 PCERT_RDN_ATTR :: ^struct {
    pszObjId    : LPSTR,
    dwValueType : u32,
    Value       : CERT_RDN_VALUE_BLOB,
 };

 CERT_RDN :: struct {
    cRDNAttr  : u32,
    rgRDNAttr : PCERT_RDN_ATTR,
 };
 PCERT_RDN :: ^struct {
    cRDNAttr  : u32,
    rgRDNAttr : PCERT_RDN_ATTR,
 };

 CERT_NAME_INFO :: struct {
    cRDN  : u32,
    rgRDN : PCERT_RDN,
 };
 PCERT_NAME_INFO :: ^struct {
    cRDN  : u32,
    rgRDN : PCERT_RDN,
 };

 CERT_NAME_VALUE :: struct {
    dwValueType : u32,
    Value       : CERT_RDN_VALUE_BLOB,
 };
 PCERT_NAME_VALUE :: ^struct {
    dwValueType : u32,
    Value       : CERT_RDN_VALUE_BLOB,
 };

 CERT_PUBLIC_KEY_INFO :: struct {
    Algorithm : CRYPT_ALGORITHM_IDENTIFIER,
    PublicKey : CRYPT_BIT_BLOB,
 };
 PCERT_PUBLIC_KEY_INFO :: ^struct {
    Algorithm : CRYPT_ALGORITHM_IDENTIFIER,
    PublicKey : CRYPT_BIT_BLOB,
 };

 CRYPT_ECC_PRIVATE_KEY_INFO :: struct {
    dwVersion  : u32,
    PrivateKey : CRYPT_DER_BLOB,
    szCurveOid : LPSTR,
    PublicKey  : CRYPT_BIT_BLOB,
 };
 PCRYPT_ECC_PRIVATE_KEY_INFO :: ^struct {
    dwVersion  : u32,
    PrivateKey : CRYPT_DER_BLOB,
    szCurveOid : LPSTR,
    PublicKey  : CRYPT_BIT_BLOB,
 };

 CRYPT_PRIVATE_KEY_INFO :: struct {
    Version     : u32,
    Algorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    PrivateKey  : CRYPT_DER_BLOB,
    pAttributes : PCRYPT_ATTRIBUTES,
 };
 PCRYPT_PRIVATE_KEY_INFO :: ^struct {
    Version     : u32,
    Algorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    PrivateKey  : CRYPT_DER_BLOB,
    pAttributes : PCRYPT_ATTRIBUTES,
 };

 CRYPT_ENCRYPTED_PRIVATE_KEY_INFO :: struct {
    EncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedPrivateKey : CRYPT_DATA_BLOB,
 };
 PCRYPT_ENCRYPTED_PRIVATE_KEY_INFO :: ^struct {
    EncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedPrivateKey : CRYPT_DATA_BLOB,
 };

 PCRYPT_DECRYPT_PRIVATE_KEY_FUNC :: (proc(Algorithm : CRYPT_ALGORITHM_IDENTIFIER, EncryptedPrivateKey : CRYPT_DATA_BLOB, pbClearTextKey : ^BYTE, pcbClearTextKey : ^u32, pVoidDecryptFunc : LPVOID) -> BOOL);

 PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC :: (proc(pAlgorithm : ^CRYPT_ALGORITHM_IDENTIFIER, pClearTextPrivateKey : ^CRYPT_DATA_BLOB, pbEncryptedKey : ^BYTE, pcbEncryptedKey : ^u32, pVoidEncryptFunc : LPVOID) -> BOOL);

 PCRYPT_RESOLVE_HCRYPTPROV_FUNC :: (proc(pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, phCryptProv : ^HCRYPTPROV, pVoidResolveFunc : LPVOID) -> BOOL);

 CRYPT_PKCS8_IMPORT_PARAMS :: struct {
    PrivateKey             : CRYPT_DIGEST_BLOB,
    pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
    pVoidResolveFunc       : LPVOID,
    pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
    pVoidDecryptFunc       : LPVOID,
 };
 PCRYPT_PKCS8_IMPORT_PARAMS :: ^struct {
    PrivateKey             : CRYPT_DIGEST_BLOB,
    pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
    pVoidResolveFunc       : LPVOID,
    pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
    pVoidDecryptFunc       : LPVOID,
 };
 CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS :: struct {
    PrivateKey             : CRYPT_DIGEST_BLOB,
    pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
    pVoidResolveFunc       : LPVOID,
    pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
    pVoidDecryptFunc       : LPVOID,
 };
 PCRYPT_PRIVATE_KEY_BLOB_AND_PARAMS :: ^struct {
    PrivateKey             : CRYPT_DIGEST_BLOB,
    pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
    pVoidResolveFunc       : LPVOID,
    pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
    pVoidDecryptFunc       : LPVOID,
 };

 CRYPT_PKCS8_EXPORT_PARAMS :: struct {
    hCryptProv             : HCRYPTPROV,
    dwKeySpec              : u32,
    pszPrivateKeyObjId     : LPSTR,
    pEncryptPrivateKeyFunc : PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC,
    pVoidEncryptFunc       : LPVOID,
 };
 PCRYPT_PKCS8_EXPORT_PARAMS :: ^struct {
    hCryptProv             : HCRYPTPROV,
    dwKeySpec              : u32,
    pszPrivateKeyObjId     : LPSTR,
    pEncryptPrivateKeyFunc : PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC,
    pVoidEncryptFunc       : LPVOID,
 };

 CERT_INFO :: struct {
    dwVersion            : u32,
    SerialNumber         : CRYPT_INTEGER_BLOB,
    SignatureAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    Issuer               : CERT_NAME_BLOB,
    NotBefore            : FILETIME,
    NotAfter             : FILETIME,
    Subject              : CERT_NAME_BLOB,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    IssuerUniqueId       : CRYPT_BIT_BLOB,
    SubjectUniqueId      : CRYPT_BIT_BLOB,
    cExtension           : u32,
    rgExtension          : PCERT_EXTENSION,
 };
 PCERT_INFO :: ^struct {
    dwVersion            : u32,
    SerialNumber         : CRYPT_INTEGER_BLOB,
    SignatureAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    Issuer               : CERT_NAME_BLOB,
    NotBefore            : FILETIME,
    NotAfter             : FILETIME,
    Subject              : CERT_NAME_BLOB,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    IssuerUniqueId       : CRYPT_BIT_BLOB,
    SubjectUniqueId      : CRYPT_BIT_BLOB,
    cExtension           : u32,
    rgExtension          : PCERT_EXTENSION,
 };

 CRL_ENTRY :: struct {
    SerialNumber   : CRYPT_INTEGER_BLOB,
    RevocationDate : FILETIME,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };
 PCRL_ENTRY :: ^struct {
    SerialNumber   : CRYPT_INTEGER_BLOB,
    RevocationDate : FILETIME,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };

 CRL_INFO :: struct {
    dwVersion          : u32,
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Issuer             : CERT_NAME_BLOB,
    ThisUpdate         : FILETIME,
    NextUpdate         : FILETIME,
    cCRLEntry          : u32,
    rgCRLEntry         : PCRL_ENTRY,
    cExtension         : u32,
    rgExtension        : PCERT_EXTENSION,
 };
 PCRL_INFO :: ^struct {
    dwVersion          : u32,
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Issuer             : CERT_NAME_BLOB,
    ThisUpdate         : FILETIME,
    NextUpdate         : FILETIME,
    cCRLEntry          : u32,
    rgCRLEntry         : PCRL_ENTRY,
    cExtension         : u32,
    rgExtension        : PCERT_EXTENSION,
 };

 CERT_OR_CRL_BLOB :: struct {
    dwChoice  : u32,
    cbEncoded : u32,
    pbEncoded : ^BYTE,
 };
 PCERT_OR_CRL_BLOB :: ^struct {
    dwChoice  : u32,
    cbEncoded : u32,
    pbEncoded : ^BYTE,
 };

 CERT_OR_CRL_BUNDLE :: struct {
    cItem  : u32,
    rgItem : PCERT_OR_CRL_BLOB,
 };
 PCERT_OR_CRL_BUNDLE :: ^struct {
    cItem  : u32,
    rgItem : PCERT_OR_CRL_BLOB,
 };

 CERT_REQUEST_INFO :: struct {
    dwVersion            : u32,
    Subject              : CERT_NAME_BLOB,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    cAttribute           : u32,
    rgAttribute          : PCRYPT_ATTRIBUTE,
 };
 PCERT_REQUEST_INFO :: ^struct {
    dwVersion            : u32,
    Subject              : CERT_NAME_BLOB,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    cAttribute           : u32,
    rgAttribute          : PCRYPT_ATTRIBUTE,
 };

 CERT_KEYGEN_REQUEST_INFO :: struct {
    dwVersion            : u32,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    pwszChallengeString  : LPWSTR,
 };
 PCERT_KEYGEN_REQUEST_INFO :: ^struct {
    dwVersion            : u32,
    SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    pwszChallengeString  : LPWSTR,
 };

 CERT_SIGNED_CONTENT_INFO :: struct {
    ToBeSigned         : CRYPT_DER_BLOB,
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Signature          : CRYPT_BIT_BLOB,
 };
 PCERT_SIGNED_CONTENT_INFO :: ^struct {
    ToBeSigned         : CRYPT_DER_BLOB,
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Signature          : CRYPT_BIT_BLOB,
 };

 CTL_USAGE :: struct {
    cUsageIdentifier     : u32,
    rgpszUsageIdentifier : ^LPSTR,
 };
 PCTL_USAGE :: ^struct {
    cUsageIdentifier     : u32,
    rgpszUsageIdentifier : ^LPSTR,
 };
 CERT_ENHKEY_USAGE :: struct {
    cUsageIdentifier     : u32,
    rgpszUsageIdentifier : ^LPSTR,
 };
 PCERT_ENHKEY_USAGE :: ^struct {
    cUsageIdentifier     : u32,
    rgpszUsageIdentifier : ^LPSTR,
 };

 PCCTL_USAGE :: ^CTL_USAGE;

 PCCERT_ENHKEY_USAGE :: ^CERT_ENHKEY_USAGE;

 CTL_ENTRY :: struct {
    SubjectIdentifier : CRYPT_DATA_BLOB,
    cAttribute        : u32,
    rgAttribute       : PCRYPT_ATTRIBUTE,
 };
 PCTL_ENTRY :: ^struct {
    SubjectIdentifier : CRYPT_DATA_BLOB,
    cAttribute        : u32,
    rgAttribute       : PCRYPT_ATTRIBUTE,
 };

 CTL_INFO :: struct {
    dwVersion        : u32,
    SubjectUsage     : CTL_USAGE,
    ListIdentifier   : CRYPT_DATA_BLOB,
    SequenceNumber   : CRYPT_INTEGER_BLOB,
    ThisUpdate       : FILETIME,
    NextUpdate       : FILETIME,
    SubjectAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    cCTLEntry        : u32,
    rgCTLEntry       : PCTL_ENTRY,
    cExtension       : u32,
    rgExtension      : PCERT_EXTENSION,
 };
 PCTL_INFO :: ^struct {
    dwVersion        : u32,
    SubjectUsage     : CTL_USAGE,
    ListIdentifier   : CRYPT_DATA_BLOB,
    SequenceNumber   : CRYPT_INTEGER_BLOB,
    ThisUpdate       : FILETIME,
    NextUpdate       : FILETIME,
    SubjectAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    cCTLEntry        : u32,
    rgCTLEntry       : PCTL_ENTRY,
    cExtension       : u32,
    rgExtension      : PCERT_EXTENSION,
 };

 CRYPT_TIME_STAMP_REQUEST_INFO :: struct {
    pszTimeStampAlgorithm : LPSTR,
    pszContentType        : LPSTR,
    Content               : CRYPT_OBJID_BLOB,
    cAttribute            : u32,
    rgAttribute           : PCRYPT_ATTRIBUTE,
 };
 PCRYPT_TIME_STAMP_REQUEST_INFO :: ^struct {
    pszTimeStampAlgorithm : LPSTR,
    pszContentType        : LPSTR,
    Content               : CRYPT_OBJID_BLOB,
    cAttribute            : u32,
    rgAttribute           : PCRYPT_ATTRIBUTE,
 };

 CRYPT_ENROLLMENT_NAME_VALUE_PAIR :: struct {
    pwszName  : LPWSTR,
    pwszValue : LPWSTR,
 };
 PCRYPT_ENROLLMENT_NAME_VALUE_PAIR :: ^struct {
    pwszName  : LPWSTR,
    pwszValue : LPWSTR,
 };

 CRYPT_CSP_PROVIDER :: struct {
    dwKeySpec        : u32,
    pwszProviderName : LPWSTR,
    Signature        : CRYPT_BIT_BLOB,
 };
 PCRYPT_CSP_PROVIDER :: ^struct {
    dwKeySpec        : u32,
    pwszProviderName : LPWSTR,
    Signature        : CRYPT_BIT_BLOB,
 };

 PFN_CRYPT_ALLOC :: (proc(cbSize : uint) -> LPVOID);

 PFN_CRYPT_FREE :: proc(pv : LPVOID);

 CRYPT_ENCODE_PARA :: struct {
    cbSize   : u32,
    pfnAlloc : PFN_CRYPT_ALLOC,
    pfnFree  : PFN_CRYPT_FREE,
 };
 PCRYPT_ENCODE_PARA :: ^struct {
    cbSize   : u32,
    pfnAlloc : PFN_CRYPT_ALLOC,
    pfnFree  : PFN_CRYPT_FREE,
 };

 CRYPT_DECODE_PARA :: struct {
    cbSize   : u32,
    pfnAlloc : PFN_CRYPT_ALLOC,
    pfnFree  : PFN_CRYPT_FREE,
 };
 PCRYPT_DECODE_PARA :: ^struct {
    cbSize   : u32,
    pfnAlloc : PFN_CRYPT_ALLOC,
    pfnFree  : PFN_CRYPT_FREE,
 };

 CERT_EXTENSIONS :: struct {
    cExtension  : u32,
    rgExtension : PCERT_EXTENSION,
 };
 PCERT_EXTENSIONS :: ^struct {
    cExtension  : u32,
    rgExtension : PCERT_EXTENSION,
 };

 CERT_AUTHORITY_KEY_ID_INFO :: struct {
    KeyId            : CRYPT_DATA_BLOB,
    CertIssuer       : CERT_NAME_BLOB,
    CertSerialNumber : CRYPT_INTEGER_BLOB,
 };
 PCERT_AUTHORITY_KEY_ID_INFO :: ^struct {
    KeyId            : CRYPT_DATA_BLOB,
    CertIssuer       : CERT_NAME_BLOB,
    CertSerialNumber : CRYPT_INTEGER_BLOB,
 };

 CERT_PRIVATE_KEY_VALIDITY :: struct {
    NotBefore : FILETIME,
    NotAfter  : FILETIME,
 };
 PCERT_PRIVATE_KEY_VALIDITY :: ^struct {
    NotBefore : FILETIME,
    NotAfter  : FILETIME,
 };

 CERT_KEY_ATTRIBUTES_INFO :: struct {
    KeyId                  : CRYPT_DATA_BLOB,
    IntendedKeyUsage       : CRYPT_BIT_BLOB,
    pPrivateKeyUsagePeriod : PCERT_PRIVATE_KEY_VALIDITY,
 };
 PCERT_KEY_ATTRIBUTES_INFO :: ^struct {
    KeyId                  : CRYPT_DATA_BLOB,
    IntendedKeyUsage       : CRYPT_BIT_BLOB,
    pPrivateKeyUsagePeriod : PCERT_PRIVATE_KEY_VALIDITY,
 };

 CERT_POLICY_ID :: struct {
    cCertPolicyElementId     : u32,
    rgpszCertPolicyElementId : ^LPSTR,
 };
 PCERT_POLICY_ID :: ^struct {
    cCertPolicyElementId     : u32,
    rgpszCertPolicyElementId : ^LPSTR,
 };

 CERT_KEY_USAGE_RESTRICTION_INFO :: struct {
    cCertPolicyId      : u32,
    rgCertPolicyId     : PCERT_POLICY_ID,
    RestrictedKeyUsage : CRYPT_BIT_BLOB,
 };
 PCERT_KEY_USAGE_RESTRICTION_INFO :: ^struct {
    cCertPolicyId      : u32,
    rgCertPolicyId     : PCERT_POLICY_ID,
    RestrictedKeyUsage : CRYPT_BIT_BLOB,
 };

 CERT_OTHER_NAME :: struct {
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
 };
 PCERT_OTHER_NAME :: ^struct {
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
 };

 CERT_ALT_NAME_ENTRY :: struct {
    dwAltNameChoice : u32,
    u : struct #raw_union {
        pOtherName      : PCERT_OTHER_NAME,
        pwszRfc822Name  : LPWSTR,
        pwszDNSName     : LPWSTR,
        DirectoryName   : CERT_NAME_BLOB,
        pwszURL         : LPWSTR,
        IPAddress       : CRYPT_DATA_BLOB,
        pszRegisteredID : LPSTR,
    },
 };
 PCERT_ALT_NAME_ENTRY :: ^struct {
    dwAltNameChoice : u32,
    u : struct #raw_union {
        pOtherName      : PCERT_OTHER_NAME,
        pwszRfc822Name  : LPWSTR,
        pwszDNSName     : LPWSTR,
        DirectoryName   : CERT_NAME_BLOB,
        pwszURL         : LPWSTR,
        IPAddress       : CRYPT_DATA_BLOB,
        pszRegisteredID : LPSTR,
    },
 };

 CERT_ALT_NAME_INFO :: struct {
    cAltEntry  : u32,
    rgAltEntry : PCERT_ALT_NAME_ENTRY,
 };
 PCERT_ALT_NAME_INFO :: ^struct {
    cAltEntry  : u32,
    rgAltEntry : PCERT_ALT_NAME_ENTRY,
 };

 CERT_BASIC_CONSTRAINTS_INFO :: struct {
    SubjectType          : CRYPT_BIT_BLOB,
    fPathLenConstraint   : BOOL,
    dwPathLenConstraint  : u32,
    cSubtreesConstraint  : u32,
    rgSubtreesConstraint : ^CERT_NAME_BLOB,
 };
 PCERT_BASIC_CONSTRAINTS_INFO :: ^struct {
    SubjectType          : CRYPT_BIT_BLOB,
    fPathLenConstraint   : BOOL,
    dwPathLenConstraint  : u32,
    cSubtreesConstraint  : u32,
    rgSubtreesConstraint : ^CERT_NAME_BLOB,
 };

 CERT_BASIC_CONSTRAINTS2_INFO :: struct {
    fCA                 : BOOL,
    fPathLenConstraint  : BOOL,
    dwPathLenConstraint : u32,
 };
 PCERT_BASIC_CONSTRAINTS2_INFO :: ^struct {
    fCA                 : BOOL,
    fPathLenConstraint  : BOOL,
    dwPathLenConstraint : u32,
 };

 CERT_POLICY_QUALIFIER_INFO :: struct {
    pszPolicyQualifierId : LPSTR,
    Qualifier            : CRYPT_OBJID_BLOB,
 };
 PCERT_POLICY_QUALIFIER_INFO :: ^struct {
    pszPolicyQualifierId : LPSTR,
    Qualifier            : CRYPT_OBJID_BLOB,
 };

 CERT_POLICY_INFO :: struct {
    pszPolicyIdentifier : LPSTR,
    cPolicyQualifier    : u32,
    rgPolicyQualifier   : ^CERT_POLICY_QUALIFIER_INFO,
 };
 PCERT_POLICY_INFO :: ^struct {
    pszPolicyIdentifier : LPSTR,
    cPolicyQualifier    : u32,
    rgPolicyQualifier   : ^CERT_POLICY_QUALIFIER_INFO,
 };

 CERT_POLICIES_INFO :: struct {
    cPolicyInfo  : u32,
    rgPolicyInfo : ^CERT_POLICY_INFO,
 };
 PCERT_POLICIES_INFO :: ^struct {
    cPolicyInfo  : u32,
    rgPolicyInfo : ^CERT_POLICY_INFO,
 };

 CERT_POLICY_QUALIFIER_NOTICE_REFERENCE :: struct {
    pszOrganization : LPSTR,
    cNoticeNumbers  : u32,
    rgNoticeNumbers : ^i32,
 };
 PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE :: ^struct {
    pszOrganization : LPSTR,
    cNoticeNumbers  : u32,
    rgNoticeNumbers : ^i32,
 };

 CERT_POLICY_QUALIFIER_USER_NOTICE :: struct {
    pNoticeReference : ^CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
    pszDisplayText   : LPWSTR,
 };
 PCERT_POLICY_QUALIFIER_USER_NOTICE :: ^struct {
    pNoticeReference : ^CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
    pszDisplayText   : LPWSTR,
 };

 CPS_URLS :: struct {
    pszURL     : LPWSTR,
    pAlgorithm : ^CRYPT_ALGORITHM_IDENTIFIER,
    pDigest    : ^CRYPT_DATA_BLOB,
 };
 PCPS_URLS :: ^struct {
    pszURL     : LPWSTR,
    pAlgorithm : ^CRYPT_ALGORITHM_IDENTIFIER,
    pDigest    : ^CRYPT_DATA_BLOB,
 };

 CERT_POLICY95_QUALIFIER1 :: struct {
    pszPracticesReference  : LPWSTR,
    pszNoticeIdentifier    : LPSTR,
    pszNSINoticeIdentifier : LPSTR,
    cCPSURLs               : u32,
    rgCPSURLs              : ^CPS_URLS,
 };
 PCERT_POLICY95_QUALIFIER1 :: ^struct {
    pszPracticesReference  : LPWSTR,
    pszNoticeIdentifier    : LPSTR,
    pszNSINoticeIdentifier : LPSTR,
    cCPSURLs               : u32,
    rgCPSURLs              : ^CPS_URLS,
 };

 CERT_POLICY_MAPPING :: struct {
    pszIssuerDomainPolicy  : LPSTR,
    pszSubjectDomainPolicy : LPSTR,
 };
 PCERT_POLICY_MAPPING :: ^struct {
    pszIssuerDomainPolicy  : LPSTR,
    pszSubjectDomainPolicy : LPSTR,
 };

 CERT_POLICY_MAPPINGS_INFO :: struct {
    cPolicyMapping  : u32,
    rgPolicyMapping : PCERT_POLICY_MAPPING,
 };
 PCERT_POLICY_MAPPINGS_INFO :: ^struct {
    cPolicyMapping  : u32,
    rgPolicyMapping : PCERT_POLICY_MAPPING,
 };

 CERT_POLICY_CONSTRAINTS_INFO :: struct {
    fRequireExplicitPolicy           : BOOL,
    dwRequireExplicitPolicySkipCerts : u32,
    fInhibitPolicyMapping            : BOOL,
    dwInhibitPolicyMappingSkipCerts  : u32,
 };
 PCERT_POLICY_CONSTRAINTS_INFO :: ^struct {
    fRequireExplicitPolicy           : BOOL,
    dwRequireExplicitPolicySkipCerts : u32,
    fInhibitPolicyMapping            : BOOL,
    dwInhibitPolicyMappingSkipCerts  : u32,
 };

 CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY :: struct {
    pszObjId : LPSTR,
    cValue   : u32,
    rgValue  : PCRYPT_DER_BLOB,
 };
 PCRYPT_CONTENT_INFO_SEQUENCE_OF_ANY :: ^struct {
    pszObjId : LPSTR,
    cValue   : u32,
    rgValue  : PCRYPT_DER_BLOB,
 };

 CRYPT_CONTENT_INFO :: struct {
    pszObjId : LPSTR,
    Content  : CRYPT_DER_BLOB,
 };
 PCRYPT_CONTENT_INFO :: ^struct {
    pszObjId : LPSTR,
    Content  : CRYPT_DER_BLOB,
 };

 CRYPT_SEQUENCE_OF_ANY :: struct {
    cValue  : u32,
    rgValue : PCRYPT_DER_BLOB,
 };
 PCRYPT_SEQUENCE_OF_ANY :: ^struct {
    cValue  : u32,
    rgValue : PCRYPT_DER_BLOB,
 };

 CERT_AUTHORITY_KEY_ID2_INFO :: struct {
    KeyId                     : CRYPT_DATA_BLOB,
    AuthorityCertIssuer       : CERT_ALT_NAME_INFO,
    AuthorityCertSerialNumber : CRYPT_INTEGER_BLOB,
 };
 PCERT_AUTHORITY_KEY_ID2_INFO :: ^struct {
    KeyId                     : CRYPT_DATA_BLOB,
    AuthorityCertIssuer       : CERT_ALT_NAME_INFO,
    AuthorityCertSerialNumber : CRYPT_INTEGER_BLOB,
 };

 CERT_ACCESS_DESCRIPTION :: struct {
    pszAccessMethod : LPSTR,
    AccessLocation  : CERT_ALT_NAME_ENTRY,
 };
 PCERT_ACCESS_DESCRIPTION :: ^struct {
    pszAccessMethod : LPSTR,
    AccessLocation  : CERT_ALT_NAME_ENTRY,
 };

 CERT_AUTHORITY_INFO_ACCESS :: struct {
    cAccDescr  : u32,
    rgAccDescr : PCERT_ACCESS_DESCRIPTION,
 };
 PCERT_AUTHORITY_INFO_ACCESS :: ^struct {
    cAccDescr  : u32,
    rgAccDescr : PCERT_ACCESS_DESCRIPTION,
 };
 CERT_SUBJECT_INFO_ACCESS :: struct {
    cAccDescr  : u32,
    rgAccDescr : PCERT_ACCESS_DESCRIPTION,
 };
 PCERT_SUBJECT_INFO_ACCESS :: ^struct {
    cAccDescr  : u32,
    rgAccDescr : PCERT_ACCESS_DESCRIPTION,
 };

 CRL_DIST_POINT_NAME :: struct {
    dwDistPointNameChoice : u32,
    u : struct #raw_union {
        FullName : CERT_ALT_NAME_INFO,
    },
 };
 PCRL_DIST_POINT_NAME :: ^struct {
    dwDistPointNameChoice : u32,
    u : struct #raw_union {
        FullName : CERT_ALT_NAME_INFO,
    },
 };

 CRL_DIST_POINT :: struct {
    DistPointName : CRL_DIST_POINT_NAME,
    ReasonFlags   : CRYPT_BIT_BLOB,
    CRLIssuer     : CERT_ALT_NAME_INFO,
 };
 PCRL_DIST_POINT :: ^struct {
    DistPointName : CRL_DIST_POINT_NAME,
    ReasonFlags   : CRYPT_BIT_BLOB,
    CRLIssuer     : CERT_ALT_NAME_INFO,
 };

 CRL_DIST_POINTS_INFO :: struct {
    cDistPoint  : u32,
    rgDistPoint : PCRL_DIST_POINT,
 };
 PCRL_DIST_POINTS_INFO :: ^struct {
    cDistPoint  : u32,
    rgDistPoint : PCRL_DIST_POINT,
 };

 CROSS_CERT_DIST_POINTS_INFO :: struct {
    dwSyncDeltaTime : u32,
    cDistPoint      : u32,
    rgDistPoint     : PCERT_ALT_NAME_INFO,
 };
 PCROSS_CERT_DIST_POINTS_INFO :: ^struct {
    dwSyncDeltaTime : u32,
    cDistPoint      : u32,
    rgDistPoint     : PCERT_ALT_NAME_INFO,
 };

 CERT_PAIR :: struct {
    Forward : CERT_BLOB,
    Reverse : CERT_BLOB,
 };
 PCERT_PAIR :: ^struct {
    Forward : CERT_BLOB,
    Reverse : CERT_BLOB,
 };

 CRL_ISSUING_DIST_POINT :: struct {
    DistPointName          : CRL_DIST_POINT_NAME,
    fOnlyContainsUserCerts : BOOL,
    fOnlyContainsCACerts   : BOOL,
    OnlySomeReasonFlags    : CRYPT_BIT_BLOB,
    fIndirectCRL           : BOOL,
 };
 PCRL_ISSUING_DIST_POINT :: ^struct {
    DistPointName          : CRL_DIST_POINT_NAME,
    fOnlyContainsUserCerts : BOOL,
    fOnlyContainsCACerts   : BOOL,
    OnlySomeReasonFlags    : CRYPT_BIT_BLOB,
    fIndirectCRL           : BOOL,
 };

 CERT_GENERAL_SUBTREE :: struct {
    Base      : CERT_ALT_NAME_ENTRY,
    dwMinimum : u32,
    fMaximum  : BOOL,
    dwMaximum : u32,
 };
 PCERT_GENERAL_SUBTREE :: ^struct {
    Base      : CERT_ALT_NAME_ENTRY,
    dwMinimum : u32,
    fMaximum  : BOOL,
    dwMaximum : u32,
 };

 CERT_NAME_CONSTRAINTS_INFO :: struct {
    cPermittedSubtree  : u32,
    rgPermittedSubtree : PCERT_GENERAL_SUBTREE,
    cExcludedSubtree   : u32,
    rgExcludedSubtree  : PCERT_GENERAL_SUBTREE,
 };
 PCERT_NAME_CONSTRAINTS_INFO :: ^struct {
    cPermittedSubtree  : u32,
    rgPermittedSubtree : PCERT_GENERAL_SUBTREE,
    cExcludedSubtree   : u32,
    rgExcludedSubtree  : PCERT_GENERAL_SUBTREE,
 };

 CERT_DSS_PARAMETERS :: struct {
    p : CRYPT_UINT_BLOB,
    q : CRYPT_UINT_BLOB,
    g : CRYPT_UINT_BLOB,
 };
 PCERT_DSS_PARAMETERS :: ^struct {
    p : CRYPT_UINT_BLOB,
    q : CRYPT_UINT_BLOB,
    g : CRYPT_UINT_BLOB,
 };

 CERT_DH_PARAMETERS :: struct {
    p : CRYPT_UINT_BLOB,
    g : CRYPT_UINT_BLOB,
 };
 PCERT_DH_PARAMETERS :: ^struct {
    p : CRYPT_UINT_BLOB,
    g : CRYPT_UINT_BLOB,
 };

 CERT_ECC_SIGNATURE :: struct {
    r : CRYPT_UINT_BLOB,
    s : CRYPT_UINT_BLOB,
 };
 PCERT_ECC_SIGNATURE :: ^struct {
    r : CRYPT_UINT_BLOB,
    s : CRYPT_UINT_BLOB,
 };

 CERT_X942_DH_VALIDATION_PARAMS :: struct {
    seed        : CRYPT_BIT_BLOB,
    pgenCounter : u32,
 };
 PCERT_X942_DH_VALIDATION_PARAMS :: ^struct {
    seed        : CRYPT_BIT_BLOB,
    pgenCounter : u32,
 };

 CERT_X942_DH_PARAMETERS :: struct {
    p                 : CRYPT_UINT_BLOB,
    g                 : CRYPT_UINT_BLOB,
    q                 : CRYPT_UINT_BLOB,
    j                 : CRYPT_UINT_BLOB,
    pValidationParams : PCERT_X942_DH_VALIDATION_PARAMS,
 };
 PCERT_X942_DH_PARAMETERS :: ^struct {
    p                 : CRYPT_UINT_BLOB,
    g                 : CRYPT_UINT_BLOB,
    q                 : CRYPT_UINT_BLOB,
    j                 : CRYPT_UINT_BLOB,
    pValidationParams : PCERT_X942_DH_VALIDATION_PARAMS,
 };

 CRYPT_X942_OTHER_INFO :: struct {
    pszContentEncryptionObjId : LPSTR,
    rgbCounter                : [4]BYTE,
    rgbKeyLength              : [4]BYTE,
    PubInfo                   : CRYPT_DATA_BLOB,
 };
 PCRYPT_X942_OTHER_INFO :: ^struct {
    pszContentEncryptionObjId : LPSTR,
    rgbCounter                : [4]BYTE,
    rgbKeyLength              : [4]BYTE,
    PubInfo                   : CRYPT_DATA_BLOB,
 };

 CRYPT_ECC_CMS_SHARED_INFO :: struct {
    Algorithm      : CRYPT_ALGORITHM_IDENTIFIER,
    EntityUInfo    : CRYPT_DATA_BLOB,
    rgbSuppPubInfo : [4]BYTE,
 };
 PCRYPT_ECC_CMS_SHARED_INFO :: ^struct {
    Algorithm      : CRYPT_ALGORITHM_IDENTIFIER,
    EntityUInfo    : CRYPT_DATA_BLOB,
    rgbSuppPubInfo : [4]BYTE,
 };

 CRYPT_RC2_CBC_PARAMETERS :: struct {
    dwVersion : u32,
    fIV       : BOOL,
    rgbIV     : [8]BYTE,
 };
 PCRYPT_RC2_CBC_PARAMETERS :: ^struct {
    dwVersion : u32,
    fIV       : BOOL,
    rgbIV     : [8]BYTE,
 };

 CRYPT_SMIME_CAPABILITY :: struct {
    pszObjId   : LPSTR,
    Parameters : CRYPT_OBJID_BLOB,
 };
 PCRYPT_SMIME_CAPABILITY :: ^struct {
    pszObjId   : LPSTR,
    Parameters : CRYPT_OBJID_BLOB,
 };

 CRYPT_SMIME_CAPABILITIES :: struct {
    cCapability  : u32,
    rgCapability : PCRYPT_SMIME_CAPABILITY,
 };
 PCRYPT_SMIME_CAPABILITIES :: ^struct {
    cCapability  : u32,
    rgCapability : PCRYPT_SMIME_CAPABILITY,
 };

 CERT_QC_STATEMENT :: struct {
    pszStatementId : LPSTR,
    StatementInfo  : CRYPT_OBJID_BLOB,
 };
 PCERT_QC_STATEMENT :: ^struct {
    pszStatementId : LPSTR,
    StatementInfo  : CRYPT_OBJID_BLOB,
 };

 CERT_QC_STATEMENTS_EXT_INFO :: struct {
    cStatement  : u32,
    rgStatement : PCERT_QC_STATEMENT,
 };
 PCERT_QC_STATEMENTS_EXT_INFO :: ^struct {
    cStatement  : u32,
    rgStatement : PCERT_QC_STATEMENT,
 };

 CRYPT_MASK_GEN_ALGORITHM :: struct {
    pszObjId      : LPSTR,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
 };
 PCRYPT_MASK_GEN_ALGORITHM :: ^struct {
    pszObjId      : LPSTR,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
 };

 CRYPT_RSA_SSA_PSS_PARAMETERS :: struct {
    HashAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM,
    dwSaltLength     : u32,
    dwTrailerField   : u32,
 };
 PCRYPT_RSA_SSA_PSS_PARAMETERS :: ^struct {
    HashAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM,
    dwSaltLength     : u32,
    dwTrailerField   : u32,
 };

 CRYPT_PSOURCE_ALGORITHM :: struct {
    pszObjId           : LPSTR,
    EncodingParameters : CRYPT_DATA_BLOB,
 };
 PCRYPT_PSOURCE_ALGORITHM :: ^struct {
    pszObjId           : LPSTR,
    EncodingParameters : CRYPT_DATA_BLOB,
 };

 CRYPT_RSAES_OAEP_PARAMETERS :: struct {
    HashAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM,
    PSourceAlgorithm : CRYPT_PSOURCE_ALGORITHM,
 };
 PCRYPT_RSAES_OAEP_PARAMETERS :: ^struct {
    HashAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM,
    PSourceAlgorithm : CRYPT_PSOURCE_ALGORITHM,
 };

 CMC_TAGGED_ATTRIBUTE :: struct {
    dwBodyPartID : u32,
    Attribute    : CRYPT_ATTRIBUTE,
 };
 PCMC_TAGGED_ATTRIBUTE :: ^struct {
    dwBodyPartID : u32,
    Attribute    : CRYPT_ATTRIBUTE,
 };

 CMC_TAGGED_CERT_REQUEST :: struct {
    dwBodyPartID      : u32,
    SignedCertRequest : CRYPT_DER_BLOB,
 };
 PCMC_TAGGED_CERT_REQUEST :: ^struct {
    dwBodyPartID      : u32,
    SignedCertRequest : CRYPT_DER_BLOB,
 };

 CMC_TAGGED_REQUEST :: struct {
    dwTaggedRequestChoice : u32,
    u : struct #raw_union {
        pTaggedCertRequest : PCMC_TAGGED_CERT_REQUEST,
    },
 };
 PCMC_TAGGED_REQUEST :: ^struct {
    dwTaggedRequestChoice : u32,
    u : struct #raw_union {
        pTaggedCertRequest : PCMC_TAGGED_CERT_REQUEST,
    },
 };

 CMC_TAGGED_CONTENT_INFO :: struct {
    dwBodyPartID       : u32,
    EncodedContentInfo : CRYPT_DER_BLOB,
 };
 PCMC_TAGGED_CONTENT_INFO :: ^struct {
    dwBodyPartID       : u32,
    EncodedContentInfo : CRYPT_DER_BLOB,
 };

 CMC_TAGGED_OTHER_MSG :: struct {
    dwBodyPartID : u32,
    pszObjId     : LPSTR,
    Value        : CRYPT_OBJID_BLOB,
 };
 PCMC_TAGGED_OTHER_MSG :: ^struct {
    dwBodyPartID : u32,
    pszObjId     : LPSTR,
    Value        : CRYPT_OBJID_BLOB,
 };

 CMC_DATA_INFO :: struct {
    cTaggedAttribute    : u32,
    rgTaggedAttribute   : PCMC_TAGGED_ATTRIBUTE,
    cTaggedRequest      : u32,
    rgTaggedRequest     : PCMC_TAGGED_REQUEST,
    cTaggedContentInfo  : u32,
    rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO,
    cTaggedOtherMsg     : u32,
    rgTaggedOtherMsg    : PCMC_TAGGED_OTHER_MSG,
 };
 PCMC_DATA_INFO :: ^struct {
    cTaggedAttribute    : u32,
    rgTaggedAttribute   : PCMC_TAGGED_ATTRIBUTE,
    cTaggedRequest      : u32,
    rgTaggedRequest     : PCMC_TAGGED_REQUEST,
    cTaggedContentInfo  : u32,
    rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO,
    cTaggedOtherMsg     : u32,
    rgTaggedOtherMsg    : PCMC_TAGGED_OTHER_MSG,
 };

 CMC_RESPONSE_INFO :: struct {
    cTaggedAttribute    : u32,
    rgTaggedAttribute   : PCMC_TAGGED_ATTRIBUTE,
    cTaggedContentInfo  : u32,
    rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO,
    cTaggedOtherMsg     : u32,
    rgTaggedOtherMsg    : PCMC_TAGGED_OTHER_MSG,
 };
 PCMC_RESPONSE_INFO :: ^struct {
    cTaggedAttribute    : u32,
    rgTaggedAttribute   : PCMC_TAGGED_ATTRIBUTE,
    cTaggedContentInfo  : u32,
    rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO,
    cTaggedOtherMsg     : u32,
    rgTaggedOtherMsg    : PCMC_TAGGED_OTHER_MSG,
 };

 CMC_PEND_INFO :: struct {
    PendToken : CRYPT_DATA_BLOB,
    PendTime  : FILETIME,
 };
 PCMC_PEND_INFO :: ^struct {
    PendToken : CRYPT_DATA_BLOB,
    PendTime  : FILETIME,
 };

 CMC_STATUS_INFO :: struct {
    dwStatus          : u32,
    cBodyList         : u32,
    rgdwBodyList      : ^u32,
    pwszStatusString  : LPWSTR,
    dwOtherInfoChoice : u32,
    u : struct #raw_union {
        dwFailInfo : u32,
        pPendInfo  : PCMC_PEND_INFO,
    },
 };
 PCMC_STATUS_INFO :: ^struct {
    dwStatus          : u32,
    cBodyList         : u32,
    rgdwBodyList      : ^u32,
    pwszStatusString  : LPWSTR,
    dwOtherInfoChoice : u32,
    u : struct #raw_union {
        dwFailInfo : u32,
        pPendInfo  : PCMC_PEND_INFO,
    },
 };

 CMC_ADD_EXTENSIONS_INFO :: struct {
    dwCmcDataReference : u32,
    cCertReference     : u32,
    rgdwCertReference  : ^u32,
    cExtension         : u32,
    rgExtension        : PCERT_EXTENSION,
 };
 PCMC_ADD_EXTENSIONS_INFO :: ^struct {
    dwCmcDataReference : u32,
    cCertReference     : u32,
    rgdwCertReference  : ^u32,
    cExtension         : u32,
    rgExtension        : PCERT_EXTENSION,
 };

 CMC_ADD_ATTRIBUTES_INFO :: struct {
    dwCmcDataReference : u32,
    cCertReference     : u32,
    rgdwCertReference  : ^u32,
    cAttribute         : u32,
    rgAttribute        : PCRYPT_ATTRIBUTE,
 };
 PCMC_ADD_ATTRIBUTES_INFO :: ^struct {
    dwCmcDataReference : u32,
    cCertReference     : u32,
    rgdwCertReference  : ^u32,
    cAttribute         : u32,
    rgAttribute        : PCRYPT_ATTRIBUTE,
 };

 CERT_TEMPLATE_EXT :: struct {
    pszObjId       : LPSTR,
    dwMajorVersion : u32,
    fMinorVersion  : BOOL,
    dwMinorVersion : u32,
 };
 PCERT_TEMPLATE_EXT :: ^struct {
    pszObjId       : LPSTR,
    dwMajorVersion : u32,
    fMinorVersion  : BOOL,
    dwMinorVersion : u32,
 };

 CERT_HASHED_URL :: struct {
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Hash          : CRYPT_HASH_BLOB,
    pwszUrl       : LPWSTR,
 };
 PCERT_HASHED_URL :: ^struct {
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Hash          : CRYPT_HASH_BLOB,
    pwszUrl       : LPWSTR,
 };

 CERT_LOGOTYPE_DETAILS :: struct {
    pwszMimeType : LPWSTR,
    cHashedUrl   : u32,
    rgHashedUrl  : PCERT_HASHED_URL,
 };
 PCERT_LOGOTYPE_DETAILS :: ^struct {
    pwszMimeType : LPWSTR,
    cHashedUrl   : u32,
    rgHashedUrl  : PCERT_HASHED_URL,
 };

 CERT_LOGOTYPE_REFERENCE :: struct {
    cHashedUrl  : u32,
    rgHashedUrl : PCERT_HASHED_URL,
 };
 PCERT_LOGOTYPE_REFERENCE :: ^struct {
    cHashedUrl  : u32,
    rgHashedUrl : PCERT_HASHED_URL,
 };

 CERT_LOGOTYPE_IMAGE_INFO :: struct {
    dwLogotypeImageInfoChoice       : u32,
    dwFileSize                      : u32,
    dwXSize                         : u32,
    dwYSize                         : u32,
    dwLogotypeImageResolutionChoice : u32,
    u : struct #raw_union {
        dwNumBits   : u32,
        dwTableSize : u32,
    },
    pwszLanguage                    : LPWSTR,
 };
 PCERT_LOGOTYPE_IMAGE_INFO :: ^struct {
    dwLogotypeImageInfoChoice       : u32,
    dwFileSize                      : u32,
    dwXSize                         : u32,
    dwYSize                         : u32,
    dwLogotypeImageResolutionChoice : u32,
    u : struct #raw_union {
        dwNumBits   : u32,
        dwTableSize : u32,
    },
    pwszLanguage                    : LPWSTR,
 };

 CERT_LOGOTYPE_IMAGE :: struct {
    LogotypeDetails    : CERT_LOGOTYPE_DETAILS,
    pLogotypeImageInfo : PCERT_LOGOTYPE_IMAGE_INFO,
 };
 PCERT_LOGOTYPE_IMAGE :: ^struct {
    LogotypeDetails    : CERT_LOGOTYPE_DETAILS,
    pLogotypeImageInfo : PCERT_LOGOTYPE_IMAGE_INFO,
 };

 CERT_LOGOTYPE_AUDIO_INFO :: struct {
    dwFileSize   : u32,
    dwPlayTime   : u32,
    dwChannels   : u32,
    dwSampleRate : u32,
    pwszLanguage : LPWSTR,
 };
 PCERT_LOGOTYPE_AUDIO_INFO :: ^struct {
    dwFileSize   : u32,
    dwPlayTime   : u32,
    dwChannels   : u32,
    dwSampleRate : u32,
    pwszLanguage : LPWSTR,
 };

 CERT_LOGOTYPE_AUDIO :: struct {
    LogotypeDetails    : CERT_LOGOTYPE_DETAILS,
    pLogotypeAudioInfo : PCERT_LOGOTYPE_AUDIO_INFO,
 };
 PCERT_LOGOTYPE_AUDIO :: ^struct {
    LogotypeDetails    : CERT_LOGOTYPE_DETAILS,
    pLogotypeAudioInfo : PCERT_LOGOTYPE_AUDIO_INFO,
 };

 CERT_LOGOTYPE_DATA :: struct {
    cLogotypeImage  : u32,
    rgLogotypeImage : PCERT_LOGOTYPE_IMAGE,
    cLogotypeAudio  : u32,
    rgLogotypeAudio : PCERT_LOGOTYPE_AUDIO,
 };
 PCERT_LOGOTYPE_DATA :: ^struct {
    cLogotypeImage  : u32,
    rgLogotypeImage : PCERT_LOGOTYPE_IMAGE,
    cLogotypeAudio  : u32,
    rgLogotypeAudio : PCERT_LOGOTYPE_AUDIO,
 };

 CERT_LOGOTYPE_INFO :: struct {
    dwLogotypeInfoChoice : u32,
    u : struct #raw_union {
        pLogotypeDirectInfo   : PCERT_LOGOTYPE_DATA,
        pLogotypeIndirectInfo : PCERT_LOGOTYPE_REFERENCE,
    },
 };
 PCERT_LOGOTYPE_INFO :: ^struct {
    dwLogotypeInfoChoice : u32,
    u : struct #raw_union {
        pLogotypeDirectInfo   : PCERT_LOGOTYPE_DATA,
        pLogotypeIndirectInfo : PCERT_LOGOTYPE_REFERENCE,
    },
 };

 CERT_OTHER_LOGOTYPE_INFO :: struct {
    pszObjId     : LPSTR,
    LogotypeInfo : CERT_LOGOTYPE_INFO,
 };
 PCERT_OTHER_LOGOTYPE_INFO :: ^struct {
    pszObjId     : LPSTR,
    LogotypeInfo : CERT_LOGOTYPE_INFO,
 };

 CERT_LOGOTYPE_EXT_INFO :: struct {
    cCommunityLogo  : u32,
    rgCommunityLogo : PCERT_LOGOTYPE_INFO,
    pIssuerLogo     : PCERT_LOGOTYPE_INFO,
    pSubjectLogo    : PCERT_LOGOTYPE_INFO,
    cOtherLogo      : u32,
    rgOtherLogo     : PCERT_OTHER_LOGOTYPE_INFO,
 };
 PCERT_LOGOTYPE_EXT_INFO :: ^struct {
    cCommunityLogo  : u32,
    rgCommunityLogo : PCERT_LOGOTYPE_INFO,
    pIssuerLogo     : PCERT_LOGOTYPE_INFO,
    pSubjectLogo    : PCERT_LOGOTYPE_INFO,
    cOtherLogo      : u32,
    rgOtherLogo     : PCERT_OTHER_LOGOTYPE_INFO,
 };

 CERT_BIOMETRIC_DATA :: struct {
    dwTypeOfBiometricDataChoice : u32,
    u : struct #raw_union {
        dwPredefined : u32,
        pszObjId     : LPSTR,
    },
    HashedUrl                   : CERT_HASHED_URL,
 };
 PCERT_BIOMETRIC_DATA :: ^struct {
    dwTypeOfBiometricDataChoice : u32,
    u : struct #raw_union {
        dwPredefined : u32,
        pszObjId     : LPSTR,
    },
    HashedUrl                   : CERT_HASHED_URL,
 };

 CERT_BIOMETRIC_EXT_INFO :: struct {
    cBiometricData  : u32,
    rgBiometricData : PCERT_BIOMETRIC_DATA,
 };
 PCERT_BIOMETRIC_EXT_INFO :: ^struct {
    cBiometricData  : u32,
    rgBiometricData : PCERT_BIOMETRIC_DATA,
 };

 OCSP_SIGNATURE_INFO :: struct {
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Signature          : CRYPT_BIT_BLOB,
    cCertEncoded       : u32,
    rgCertEncoded      : PCERT_BLOB,
 };
 POCSP_SIGNATURE_INFO :: ^struct {
    SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    Signature          : CRYPT_BIT_BLOB,
    cCertEncoded       : u32,
    rgCertEncoded      : PCERT_BLOB,
 };

 OCSP_SIGNED_REQUEST_INFO :: struct {
    ToBeSigned             : CRYPT_DER_BLOB,
    pOptionalSignatureInfo : POCSP_SIGNATURE_INFO,
 };
 POCSP_SIGNED_REQUEST_INFO :: ^struct {
    ToBeSigned             : CRYPT_DER_BLOB,
    pOptionalSignatureInfo : POCSP_SIGNATURE_INFO,
 };

 OCSP_CERT_ID :: struct {
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    IssuerNameHash : CRYPT_HASH_BLOB,
    IssuerKeyHash  : CRYPT_HASH_BLOB,
    SerialNumber   : CRYPT_INTEGER_BLOB,
 };
 POCSP_CERT_ID :: ^struct {
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    IssuerNameHash : CRYPT_HASH_BLOB,
    IssuerKeyHash  : CRYPT_HASH_BLOB,
    SerialNumber   : CRYPT_INTEGER_BLOB,
 };

 OCSP_REQUEST_ENTRY :: struct {
    CertId      : OCSP_CERT_ID,
    cExtension  : u32,
    rgExtension : PCERT_EXTENSION,
 };
 POCSP_REQUEST_ENTRY :: ^struct {
    CertId      : OCSP_CERT_ID,
    cExtension  : u32,
    rgExtension : PCERT_EXTENSION,
 };

 OCSP_REQUEST_INFO :: struct {
    dwVersion      : u32,
    pRequestorName : PCERT_ALT_NAME_ENTRY,
    cRequestEntry  : u32,
    rgRequestEntry : POCSP_REQUEST_ENTRY,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };
 POCSP_REQUEST_INFO :: ^struct {
    dwVersion      : u32,
    pRequestorName : PCERT_ALT_NAME_ENTRY,
    cRequestEntry  : u32,
    rgRequestEntry : POCSP_REQUEST_ENTRY,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };

 OCSP_RESPONSE_INFO :: struct {
    dwStatus : u32,
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
 };
 POCSP_RESPONSE_INFO :: ^struct {
    dwStatus : u32,
    pszObjId : LPSTR,
    Value    : CRYPT_OBJID_BLOB,
 };

 OCSP_BASIC_SIGNED_RESPONSE_INFO :: struct {
    ToBeSigned    : CRYPT_DER_BLOB,
    SignatureInfo : OCSP_SIGNATURE_INFO,
 };
 POCSP_BASIC_SIGNED_RESPONSE_INFO :: ^struct {
    ToBeSigned    : CRYPT_DER_BLOB,
    SignatureInfo : OCSP_SIGNATURE_INFO,
 };

 OCSP_BASIC_REVOKED_INFO :: struct {
    RevocationDate  : FILETIME,
    dwCrlReasonCode : u32,
 };
 POCSP_BASIC_REVOKED_INFO :: ^struct {
    RevocationDate  : FILETIME,
    dwCrlReasonCode : u32,
 };

 OCSP_BASIC_RESPONSE_ENTRY :: struct {
    CertId       : OCSP_CERT_ID,
    dwCertStatus : u32,
    u : struct #raw_union {
        pRevokedInfo : POCSP_BASIC_REVOKED_INFO,
    },
    ThisUpdate   : FILETIME,
    NextUpdate   : FILETIME,
    cExtension   : u32,
    rgExtension  : PCERT_EXTENSION,
 };
 POCSP_BASIC_RESPONSE_ENTRY :: ^struct {
    CertId       : OCSP_CERT_ID,
    dwCertStatus : u32,
    u : struct #raw_union {
        pRevokedInfo : POCSP_BASIC_REVOKED_INFO,
    },
    ThisUpdate   : FILETIME,
    NextUpdate   : FILETIME,
    cExtension   : u32,
    rgExtension  : PCERT_EXTENSION,
 };

 OCSP_BASIC_RESPONSE_INFO :: struct {
    dwVersion           : u32,
    dwResponderIdChoice : u32,
    u : struct #raw_union {
        ByNameResponderId : CERT_NAME_BLOB,
        ByKeyResponderId  : CRYPT_HASH_BLOB,
    },
    ProducedAt          : FILETIME,
    cResponseEntry      : u32,
    rgResponseEntry     : POCSP_BASIC_RESPONSE_ENTRY,
    cExtension          : u32,
    rgExtension         : PCERT_EXTENSION,
 };
 POCSP_BASIC_RESPONSE_INFO :: ^struct {
    dwVersion           : u32,
    dwResponderIdChoice : u32,
    u : struct #raw_union {
        ByNameResponderId : CERT_NAME_BLOB,
        ByKeyResponderId  : CRYPT_HASH_BLOB,
    },
    ProducedAt          : FILETIME,
    cResponseEntry      : u32,
    rgResponseEntry     : POCSP_BASIC_RESPONSE_ENTRY,
    cExtension          : u32,
    rgExtension         : PCERT_EXTENSION,
 };

 CERT_SUPPORTED_ALGORITHM_INFO :: struct {
    Algorithm            : CRYPT_ALGORITHM_IDENTIFIER,
    IntendedKeyUsage     : CRYPT_BIT_BLOB,
    IntendedCertPolicies : CERT_POLICIES_INFO,
 };
 PCERT_SUPPORTED_ALGORITHM_INFO :: ^struct {
    Algorithm            : CRYPT_ALGORITHM_IDENTIFIER,
    IntendedKeyUsage     : CRYPT_BIT_BLOB,
    IntendedCertPolicies : CERT_POLICIES_INFO,
 };

 CERT_TPM_SPECIFICATION_INFO :: struct {
    pwszFamily : LPWSTR,
    dwLevel    : u32,
    dwRevision : u32,
 };
 PCERT_TPM_SPECIFICATION_INFO :: ^struct {
    pwszFamily : LPWSTR,
    dwLevel    : u32,
    dwRevision : u32,
 };

 HCRYPTOIDFUNCSET :: rawptr;

 HCRYPTOIDFUNCADDR :: rawptr;

 CRYPT_OID_FUNC_ENTRY :: struct {
    pszOID     : LPCSTR,
    pvFuncAddr : rawptr,
 };
 PCRYPT_OID_FUNC_ENTRY :: ^struct {
    pszOID     : LPCSTR,
    pvFuncAddr : rawptr,
 };

 PFN_CRYPT_ENUM_OID_FUNC :: (proc(dwEncodingType : u32, pszFuncName : LPCSTR, pszOID : LPCSTR, cValue : u32, rgdwValueType : []u32, rgpwszValueName : []LPCWSTR, rgpbValueData : []^BYTE, rgcbValueData : []u32, pvArg : rawptr) -> BOOL);

 CRYPT_OID_INFO :: struct {
    cbSize    : u32,
    pszOID    : LPCSTR,
    pwszName  : LPCWSTR,
    dwGroupId : u32,
    u : struct #raw_union {
        dwValue  : u32,
        Algid    : ALG_ID,
        dwLength : u32,
    },
    ExtraInfo : CRYPT_DATA_BLOB,
 };
 PCRYPT_OID_INFO :: ^struct {
    cbSize    : u32,
    pszOID    : LPCSTR,
    pwszName  : LPCWSTR,
    dwGroupId : u32,
    u : struct #raw_union {
        dwValue  : u32,
        Algid    : ALG_ID,
        dwLength : u32,
    },
    ExtraInfo : CRYPT_DATA_BLOB,
 };

 CCRYPT_OID_INFO :: CRYPT_OID_INFO;
 PCCRYPT_OID_INFO :: ^CRYPT_OID_INFO;

 PFN_CRYPT_ENUM_OID_INFO :: (proc(pInfo : PCCRYPT_OID_INFO, pvArg : rawptr) -> BOOL);

 CERT_STRONG_SIGN_SERIALIZED_INFO :: struct {
    dwFlags                    : u32,
    pwszCNGSignHashAlgids      : LPWSTR,
    pwszCNGPubKeyMinBitLengths : LPWSTR,
 };
 PCERT_STRONG_SIGN_SERIALIZED_INFO :: ^struct {
    dwFlags                    : u32,
    pwszCNGSignHashAlgids      : LPWSTR,
    pwszCNGPubKeyMinBitLengths : LPWSTR,
 };

 CERT_STRONG_SIGN_PARA :: struct {
    cbSize       : u32,
    dwInfoChoice : u32,
    u : struct #raw_union {
        pvInfo          : rawptr,
        pSerializedInfo : PCERT_STRONG_SIGN_SERIALIZED_INFO,
        pszOID          : LPSTR,
    },
 };
 PCERT_STRONG_SIGN_PARA :: ^struct {
    cbSize       : u32,
    dwInfoChoice : u32,
    u : struct #raw_union {
        pvInfo          : rawptr,
        pSerializedInfo : PCERT_STRONG_SIGN_SERIALIZED_INFO,
        pszOID          : LPSTR,
    },
 };

 PCCERT_STRONG_SIGN_PARA :: ^CERT_STRONG_SIGN_PARA;

 HCRYPTMSG :: rawptr;

 CERT_ISSUER_SERIAL_NUMBER :: struct {
    Issuer       : CERT_NAME_BLOB,
    SerialNumber : CRYPT_INTEGER_BLOB,
 };
 PCERT_ISSUER_SERIAL_NUMBER :: ^struct {
    Issuer       : CERT_NAME_BLOB,
    SerialNumber : CRYPT_INTEGER_BLOB,
 };

 CERT_ID :: struct {
    dwIdChoice : u32,
    u : struct #raw_union {
        IssuerSerialNumber : CERT_ISSUER_SERIAL_NUMBER,
        KeyId              : CRYPT_HASH_BLOB,
        HashId             : CRYPT_HASH_BLOB,
    },
 };
 PCERT_ID :: ^struct {
    dwIdChoice : u32,
    u : struct #raw_union {
        IssuerSerialNumber : CERT_ISSUER_SERIAL_NUMBER,
        KeyId              : CRYPT_HASH_BLOB,
        HashId             : CRYPT_HASH_BLOB,
    },
 };

 CMSG_SIGNER_ENCODE_INFO :: struct {
    cbSize        : u32,
    pCertInfo     : PCERT_INFO,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec     : u32,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo : rawptr,
    cAuthAttr     : u32,
    rgAuthAttr    : PCRYPT_ATTRIBUTE,
    cUnauthAttr   : u32,
    rgUnauthAttr  : PCRYPT_ATTRIBUTE,
 };
 PCMSG_SIGNER_ENCODE_INFO :: ^struct {
    cbSize        : u32,
    pCertInfo     : PCERT_INFO,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec     : u32,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo : rawptr,
    cAuthAttr     : u32,
    rgAuthAttr    : PCRYPT_ATTRIBUTE,
    cUnauthAttr   : u32,
    rgUnauthAttr  : PCRYPT_ATTRIBUTE,
 };

 CMSG_SIGNED_ENCODE_INFO :: struct {
    cbSize        : u32,
    cSigners      : u32,
    rgSigners     : PCMSG_SIGNER_ENCODE_INFO,
    cCertEncoded  : u32,
    rgCertEncoded : PCERT_BLOB,
    cCrlEncoded   : u32,
    rgCrlEncoded  : PCRL_BLOB,
 };
 PCMSG_SIGNED_ENCODE_INFO :: ^struct {
    cbSize        : u32,
    cSigners      : u32,
    rgSigners     : PCMSG_SIGNER_ENCODE_INFO,
    cCertEncoded  : u32,
    rgCertEncoded : PCERT_BLOB,
    cCrlEncoded   : u32,
    rgCrlEncoded  : PCRL_BLOB,
 };

 CMSG_RECIPIENT_ENCODE_INFO :: struct {};

 PCMSG_RECIPIENT_ENCODE_INFO :: ^CMSG_RECIPIENT_ENCODE_INFO;

 CMSG_ENVELOPED_ENCODE_INFO :: struct {
    cbSize                     : u32,
    hCryptProv                 : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
    cRecipients                : u32,
    rgpRecipients              : ^PCERT_INFO,
 };
 PCMSG_ENVELOPED_ENCODE_INFO :: ^struct {
    cbSize                     : u32,
    hCryptProv                 : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
    cRecipients                : u32,
    rgpRecipients              : ^PCERT_INFO,
 };

 CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO :: struct {
    cbSize                 : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo : rawptr,
    hCryptProv             : HCRYPTPROV_LEGACY,
    RecipientPublicKey     : CRYPT_BIT_BLOB,
    RecipientId            : CERT_ID,
 };
 PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO :: ^struct {
    cbSize                 : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo : rawptr,
    hCryptProv             : HCRYPTPROV_LEGACY,
    RecipientPublicKey     : CRYPT_BIT_BLOB,
    RecipientId            : CERT_ID,
 };

 CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO :: struct {
    cbSize             : u32,
    RecipientPublicKey : CRYPT_BIT_BLOB,
    RecipientId        : CERT_ID,
    Date               : FILETIME,
    pOtherAttr         : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };
 PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO :: ^struct {
    cbSize             : u32,
    RecipientPublicKey : CRYPT_BIT_BLOB,
    RecipientId        : CERT_ID,
    Date               : FILETIME,
    pOtherAttr         : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };

 CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO :: struct {
    cbSize                    : u32,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo    : rawptr,
    KeyWrapAlgorithm          : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyWrapAuxInfo          : rawptr,
    hCryptProv                : HCRYPTPROV_LEGACY,
    dwKeySpec                 : u32,
    dwKeyChoice               : u32,
    u : struct #raw_union {
        pEphemeralAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER,
        pSenderId           : PCERT_ID,
    },
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    cRecipientEncryptedKeys   : u32,
    rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO,
 };
 PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO :: ^struct {
    cbSize                    : u32,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo    : rawptr,
    KeyWrapAlgorithm          : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyWrapAuxInfo          : rawptr,
    hCryptProv                : HCRYPTPROV_LEGACY,
    dwKeySpec                 : u32,
    dwKeyChoice               : u32,
    u : struct #raw_union {
        pEphemeralAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER,
        pSenderId           : PCERT_ID,
    },
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    cRecipientEncryptedKeys   : u32,
    rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO,
 };

 CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO :: struct {
    cbSize                 : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo : rawptr,
    hCryptProv             : HCRYPTPROV,
    dwKeyChoice            : u32,
    u : struct #raw_union {
        hKeyEncryptionKey  : HCRYPTKEY,
        pvKeyEncryptionKey : rawptr,
    },
    KeyId                  : CRYPT_DATA_BLOB,
    Date                   : FILETIME,
    pOtherAttr             : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };
 PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO :: ^struct {
    cbSize                 : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvKeyEncryptionAuxInfo : rawptr,
    hCryptProv             : HCRYPTPROV,
    dwKeyChoice            : u32,
    u : struct #raw_union {
        hKeyEncryptionKey  : HCRYPTKEY,
        pvKeyEncryptionKey : rawptr,
    },
    KeyId                  : CRYPT_DATA_BLOB,
    Date                   : FILETIME,
    pOtherAttr             : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };

 CMSG_RECIPIENT_ENCODE_INFO :: struct {
    dwRecipientChoice : u32,
    u : struct #raw_union {
        pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO,
        pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO,
        pMailList : PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO,
    },
 };

 CMSG_RC2_AUX_INFO :: struct {
    cbSize   : u32,
    dwBitLen : u32,
 };
 PCMSG_RC2_AUX_INFO :: ^struct {
    cbSize   : u32,
    dwBitLen : u32,
 };

 CMSG_SP3_COMPATIBLE_AUX_INFO :: struct {
    cbSize  : u32,
    dwFlags : u32,
 };
 PCMSG_SP3_COMPATIBLE_AUX_INFO :: ^struct {
    cbSize  : u32,
    dwFlags : u32,
 };

 CMSG_RC4_AUX_INFO :: struct {
    cbSize   : u32,
    dwBitLen : u32,
 };
 PCMSG_RC4_AUX_INFO :: ^struct {
    cbSize   : u32,
    dwBitLen : u32,
 };

 CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO :: struct {
    cbSize        : u32,
    SignedInfo    : CMSG_SIGNED_ENCODE_INFO,
    EnvelopedInfo : CMSG_ENVELOPED_ENCODE_INFO,
 };
 PCMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO :: ^struct {
    cbSize        : u32,
    SignedInfo    : CMSG_SIGNED_ENCODE_INFO,
    EnvelopedInfo : CMSG_ENVELOPED_ENCODE_INFO,
 };

 CMSG_HASHED_ENCODE_INFO :: struct {
    cbSize        : u32,
    hCryptProv    : HCRYPTPROV_LEGACY,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo : rawptr,
 };
 PCMSG_HASHED_ENCODE_INFO :: ^struct {
    cbSize        : u32,
    hCryptProv    : HCRYPTPROV_LEGACY,
    HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo : rawptr,
 };

 CMSG_ENCRYPTED_ENCODE_INFO :: struct {
    cbSize                     : u32,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
 };
 PCMSG_ENCRYPTED_ENCODE_INFO :: ^struct {
    cbSize                     : u32,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
 };

 PFN_CMSG_STREAM_OUTPUT :: (proc(pvArg : rawptr, pbData : ^BYTE, cbData : u32, fFinal : BOOL) -> BOOL);

 CMSG_STREAM_INFO :: struct {
    cbContent       : u32,
    pfnStreamOutput : PFN_CMSG_STREAM_OUTPUT,
    pvArg           : rawptr,
 };
 PCMSG_STREAM_INFO :: ^struct {
    cbContent       : u32,
    pfnStreamOutput : PFN_CMSG_STREAM_OUTPUT,
    pvArg           : rawptr,
 };

 CMSG_SIGNER_INFO :: struct {
    dwVersion               : u32,
    Issuer                  : CERT_NAME_BLOB,
    SerialNumber            : CRYPT_INTEGER_BLOB,
    HashAlgorithm           : CRYPT_ALGORITHM_IDENTIFIER,
    HashEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedHash           : CRYPT_DATA_BLOB,
    AuthAttrs               : CRYPT_ATTRIBUTES,
    UnauthAttrs             : CRYPT_ATTRIBUTES,
 };
 PCMSG_SIGNER_INFO :: ^struct {
    dwVersion               : u32,
    Issuer                  : CERT_NAME_BLOB,
    SerialNumber            : CRYPT_INTEGER_BLOB,
    HashAlgorithm           : CRYPT_ALGORITHM_IDENTIFIER,
    HashEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedHash           : CRYPT_DATA_BLOB,
    AuthAttrs               : CRYPT_ATTRIBUTES,
    UnauthAttrs             : CRYPT_ATTRIBUTES,
 };

 CMSG_CMS_SIGNER_INFO :: struct {
    dwVersion               : u32,
    SignerId                : CERT_ID,
    HashAlgorithm           : CRYPT_ALGORITHM_IDENTIFIER,
    HashEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedHash           : CRYPT_DATA_BLOB,
    AuthAttrs               : CRYPT_ATTRIBUTES,
    UnauthAttrs             : CRYPT_ATTRIBUTES,
 };
 PCMSG_CMS_SIGNER_INFO :: ^struct {
    dwVersion               : u32,
    SignerId                : CERT_ID,
    HashAlgorithm           : CRYPT_ALGORITHM_IDENTIFIER,
    HashEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedHash           : CRYPT_DATA_BLOB,
    AuthAttrs               : CRYPT_ATTRIBUTES,
    UnauthAttrs             : CRYPT_ATTRIBUTES,
 };

 CMSG_ATTR :: CRYPT_ATTRIBUTES;

 PCMSG_ATTR :: ^CRYPT_ATTRIBUTES;

 CMSG_KEY_TRANS_RECIPIENT_INFO :: struct {
    dwVersion              : u32,
    RecipientId            : CERT_ID,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
 };
 PCMSG_KEY_TRANS_RECIPIENT_INFO :: ^struct {
    dwVersion              : u32,
    RecipientId            : CERT_ID,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
 };

 CMSG_RECIPIENT_ENCRYPTED_KEY_INFO :: struct {
    RecipientId  : CERT_ID,
    EncryptedKey : CRYPT_DATA_BLOB,
    Date         : FILETIME,
    pOtherAttr   : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };
 PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO :: ^struct {
    RecipientId  : CERT_ID,
    EncryptedKey : CRYPT_DATA_BLOB,
    Date         : FILETIME,
    pOtherAttr   : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };

 CMSG_KEY_AGREE_RECIPIENT_INFO :: struct {
    dwVersion                 : u32,
    dwOriginatorChoice        : u32,
    u : struct #raw_union {
        OriginatorCertId        : CERT_ID,
        OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    },
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    cRecipientEncryptedKeys   : u32,
    rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO,
 };
 PCMSG_KEY_AGREE_RECIPIENT_INFO :: ^struct {
    dwVersion                 : u32,
    dwOriginatorChoice        : u32,
    u : struct #raw_union {
        OriginatorCertId        : CERT_ID,
        OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    },
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    cRecipientEncryptedKeys   : u32,
    rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO,
 };

 CMSG_MAIL_LIST_RECIPIENT_INFO :: struct {
    dwVersion              : u32,
    KeyId                  : CRYPT_DATA_BLOB,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    Date                   : FILETIME,
    pOtherAttr             : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };
 PCMSG_MAIL_LIST_RECIPIENT_INFO :: ^struct {
    dwVersion              : u32,
    KeyId                  : CRYPT_DATA_BLOB,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    Date                   : FILETIME,
    pOtherAttr             : PCRYPT_ATTRIBUTE_TYPE_VALUE,
 };

 CMSG_CMS_RECIPIENT_INFO :: struct {
    dwRecipientChoice : u32,
    u : struct #raw_union {
        pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_INFO,
        pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_INFO,
        pMailList : PCMSG_MAIL_LIST_RECIPIENT_INFO,
    },
 };
 PCMSG_CMS_RECIPIENT_INFO :: ^struct {
    dwRecipientChoice : u32,
    u : struct #raw_union {
        pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_INFO,
        pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_INFO,
        pMailList : PCMSG_MAIL_LIST_RECIPIENT_INFO,
    },
 };

 CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA :: struct {
    cbSize        : u32,
    hCryptProv    : HCRYPTPROV_LEGACY,
    dwSignerIndex : u32,
    dwSignerType  : u32,
    pvSigner      : rawptr,
 };
 PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA :: ^struct {
    cbSize        : u32,
    hCryptProv    : HCRYPTPROV_LEGACY,
    dwSignerIndex : u32,
    dwSignerType  : u32,
    pvSigner      : rawptr,
 };

 CMSG_CTRL_DECRYPT_PARA :: struct {
    cbSize           : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec        : u32,
    dwRecipientIndex : u32,
 };
 PCMSG_CTRL_DECRYPT_PARA :: ^struct {
    cbSize           : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec        : u32,
    dwRecipientIndex : u32,
 };

 CMSG_CTRL_KEY_TRANS_DECRYPT_PARA :: struct {
    cbSize           : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec        : u32,
    pKeyTrans        : PCMSG_KEY_TRANS_RECIPIENT_INFO,
    dwRecipientIndex : u32,
 };
 PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA :: ^struct {
    cbSize           : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec        : u32,
    pKeyTrans        : PCMSG_KEY_TRANS_RECIPIENT_INFO,
    dwRecipientIndex : u32,
 };

 CMSG_CTRL_KEY_AGREE_DECRYPT_PARA :: struct {
    cbSize                       : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec                    : u32,
    pKeyAgree                    : PCMSG_KEY_AGREE_RECIPIENT_INFO,
    dwRecipientIndex             : u32,
    dwRecipientEncryptedKeyIndex : u32,
    OriginatorPublicKey          : CRYPT_BIT_BLOB,
 };
 PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA :: ^struct {
    cbSize                       : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec                    : u32,
    pKeyAgree                    : PCMSG_KEY_AGREE_RECIPIENT_INFO,
    dwRecipientIndex             : u32,
    dwRecipientEncryptedKeyIndex : u32,
    OriginatorPublicKey          : CRYPT_BIT_BLOB,
 };

 CMSG_CTRL_MAIL_LIST_DECRYPT_PARA :: struct {
    cbSize           : u32,
    hCryptProv       : HCRYPTPROV,
    pMailList        : PCMSG_MAIL_LIST_RECIPIENT_INFO,
    dwRecipientIndex : u32,
    dwKeyChoice      : u32,
    u : struct #raw_union {
        hKeyEncryptionKey  : HCRYPTKEY,
        pvKeyEncryptionKey : rawptr,
    },
 };
 PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA :: ^struct {
    cbSize           : u32,
    hCryptProv       : HCRYPTPROV,
    pMailList        : PCMSG_MAIL_LIST_RECIPIENT_INFO,
    dwRecipientIndex : u32,
    dwKeyChoice      : u32,
    u : struct #raw_union {
        hKeyEncryptionKey  : HCRYPTKEY,
        pvKeyEncryptionKey : rawptr,
    },
 };

 CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA :: struct {
    cbSize        : u32,
    dwSignerIndex : u32,
    blob          : CRYPT_DATA_BLOB,
 };
 PCMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA :: ^struct {
    cbSize        : u32,
    dwSignerIndex : u32,
    blob          : CRYPT_DATA_BLOB,
 };

 CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA :: struct {
    cbSize            : u32,
    dwSignerIndex     : u32,
    dwUnauthAttrIndex : u32,
 };
 PCMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA :: ^struct {
    cbSize            : u32,
    dwSignerIndex     : u32,
    dwUnauthAttrIndex : u32,
 };

 PFN_CMSG_ALLOC :: (proc(cb : uint) -> rawptr);

 PFN_CMSG_FREE :: proc(pv : rawptr);

 PFN_CMSG_GEN_ENCRYPT_KEY :: (proc(phCryptProv : ^HCRYPTPROV, paiEncrypt : PCRYPT_ALGORITHM_IDENTIFIER, pvEncryptAuxInfo : PVOID, pPublicKeyInfo : PCERT_PUBLIC_KEY_INFO, pfnAlloc : PFN_CMSG_ALLOC, phEncryptKey : ^HCRYPTKEY, ppbEncryptParameters : ^PBYTE, pcbEncryptParameters : PDWORD) -> BOOL);

 PFN_CMSG_EXPORT_ENCRYPT_KEY :: (proc(hCryptProv : HCRYPTPROV, hEncryptKey : HCRYPTKEY, pPublicKeyInfo : PCERT_PUBLIC_KEY_INFO, pbData : PBYTE, pcbData : PDWORD) -> BOOL);

 PFN_CMSG_IMPORT_ENCRYPT_KEY :: (proc(hCryptProv : HCRYPTPROV, dwKeySpec : u32, paiEncrypt : PCRYPT_ALGORITHM_IDENTIFIER, paiPubKey : PCRYPT_ALGORITHM_IDENTIFIER, pbEncodedKey : PBYTE, cbEncodedKey : u32, phEncryptKey : ^HCRYPTKEY) -> BOOL);

 CMSG_CONTENT_ENCRYPT_INFO :: struct {
    cbSize                       : u32,
    hCryptProv                   : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo          : rawptr,
    cRecipients                  : u32,
    rgCmsRecipients              : PCMSG_RECIPIENT_ENCODE_INFO,
    pfnAlloc                     : PFN_CMSG_ALLOC,
    pfnFree                      : PFN_CMSG_FREE,
    dwEncryptFlags               : u32,
    u : struct #raw_union {
        hContentEncryptKey    : HCRYPTKEY,
        hCNGContentEncryptKey : BCRYPT_KEY_HANDLE,
    },
    dwFlags                      : u32,
    fCNG                         : BOOL,
    pbCNGContentEncryptKeyObject : ^BYTE,
    pbContentEncryptKey          : ^BYTE,
    cbContentEncryptKey          : u32,
 };
 PCMSG_CONTENT_ENCRYPT_INFO :: ^struct {
    cbSize                       : u32,
    hCryptProv                   : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo          : rawptr,
    cRecipients                  : u32,
    rgCmsRecipients              : PCMSG_RECIPIENT_ENCODE_INFO,
    pfnAlloc                     : PFN_CMSG_ALLOC,
    pfnFree                      : PFN_CMSG_FREE,
    dwEncryptFlags               : u32,
    u : struct #raw_union {
        hContentEncryptKey    : HCRYPTKEY,
        hCNGContentEncryptKey : BCRYPT_KEY_HANDLE,
    },
    dwFlags                      : u32,
    fCNG                         : BOOL,
    pbCNGContentEncryptKeyObject : ^BYTE,
    pbContentEncryptKey          : ^BYTE,
    cbContentEncryptKey          : u32,
 };

 PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY :: (proc(pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, dwFlags : u32, pvReserved : rawptr) -> BOOL);

 CMSG_KEY_TRANS_ENCRYPT_INFO :: struct {
    cbSize                 : u32,
    dwRecipientIndex       : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    dwFlags                : u32,
 };
 PCMSG_KEY_TRANS_ENCRYPT_INFO :: ^struct {
    cbSize                 : u32,
    dwRecipientIndex       : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    dwFlags                : u32,
 };

 PFN_CMSG_EXPORT_KEY_TRANS :: (proc(pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pKeyTransEncodeInfo : PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO, pKeyTransEncryptInfo : PCMSG_KEY_TRANS_ENCRYPT_INFO, dwFlags : u32, pvReserved : rawptr) -> BOOL);

 CMSG_KEY_AGREE_KEY_ENCRYPT_INFO :: struct {
    cbSize       : u32,
    EncryptedKey : CRYPT_DATA_BLOB,
 };
 PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO :: ^struct {
    cbSize       : u32,
    EncryptedKey : CRYPT_DATA_BLOB,
 };

 CMSG_KEY_AGREE_ENCRYPT_INFO :: struct {
    cbSize                    : u32,
    dwRecipientIndex          : u32,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    dwOriginatorChoice        : u32,
    u : struct #raw_union {
        OriginatorCertId        : CERT_ID,
        OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    },
    cKeyAgreeKeyEncryptInfo   : u32,
    rgpKeyAgreeKeyEncryptInfo : ^PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO,
    dwFlags                   : u32,
 };
 PCMSG_KEY_AGREE_ENCRYPT_INFO :: ^struct {
    cbSize                    : u32,
    dwRecipientIndex          : u32,
    KeyEncryptionAlgorithm    : CRYPT_ALGORITHM_IDENTIFIER,
    UserKeyingMaterial        : CRYPT_DATA_BLOB,
    dwOriginatorChoice        : u32,
    u : struct #raw_union {
        OriginatorCertId        : CERT_ID,
        OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO,
    },
    cKeyAgreeKeyEncryptInfo   : u32,
    rgpKeyAgreeKeyEncryptInfo : ^PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO,
    dwFlags                   : u32,
 };

 PFN_CMSG_EXPORT_KEY_AGREE :: (proc(pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pKeyAgreeEncodeInfo : PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, pKeyAgreeEncryptInfo : PCMSG_KEY_AGREE_ENCRYPT_INFO, dwFlags : u32, pvReserved : rawptr) -> BOOL);

 CMSG_MAIL_LIST_ENCRYPT_INFO :: struct {
    cbSize                 : u32,
    dwRecipientIndex       : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    dwFlags                : u32,
 };
 PCMSG_MAIL_LIST_ENCRYPT_INFO :: ^struct {
    cbSize                 : u32,
    dwRecipientIndex       : u32,
    KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    EncryptedKey           : CRYPT_DATA_BLOB,
    dwFlags                : u32,
 };

 PFN_CMSG_EXPORT_MAIL_LIST :: (proc(pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pMailListEncodeInfo : PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, pMailListEncryptInfo : PCMSG_MAIL_LIST_ENCRYPT_INFO, dwFlags : u32, pvReserved : rawptr) -> BOOL);

 PFN_CMSG_IMPORT_KEY_TRANS :: (proc(pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pKeyTransDecryptPara : PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags : u32, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL);

 PFN_CMSG_IMPORT_KEY_AGREE :: (proc(pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pKeyAgreeDecryptPara : PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags : u32, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL);

 PFN_CMSG_IMPORT_MAIL_LIST :: (proc(pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pMailListDecryptPara : PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA, dwFlags : u32, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL);

 CMSG_CNG_CONTENT_DECRYPT_INFO :: struct {
    cbSize                       : u32,
    ContentEncryptionAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    pfnAlloc                     : PFN_CMSG_ALLOC,
    pfnFree                      : PFN_CMSG_FREE,
    hNCryptKey                   : NCRYPT_KEY_HANDLE,
    pbContentEncryptKey          : ^BYTE,
    cbContentEncryptKey          : u32,
    hCNGContentEncryptKey        : BCRYPT_KEY_HANDLE,
    pbCNGContentEncryptKeyObject : ^BYTE,
 };
 PCMSG_CNG_CONTENT_DECRYPT_INFO :: ^struct {
    cbSize                       : u32,
    ContentEncryptionAlgorithm   : CRYPT_ALGORITHM_IDENTIFIER,
    pfnAlloc                     : PFN_CMSG_ALLOC,
    pfnFree                      : PFN_CMSG_FREE,
    hNCryptKey                   : NCRYPT_KEY_HANDLE,
    pbContentEncryptKey          : ^BYTE,
    cbContentEncryptKey          : u32,
    hCNGContentEncryptKey        : BCRYPT_KEY_HANDLE,
    pbCNGContentEncryptKeyObject : ^BYTE,
 };

 PFN_CMSG_CNG_IMPORT_KEY_TRANS :: (proc(pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyTransDecryptPara : PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags : u32, pvReserved : rawptr) -> BOOL);

 PFN_CMSG_CNG_IMPORT_KEY_AGREE :: (proc(pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyAgreeDecryptPara : PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags : u32, pvReserved : rawptr) -> BOOL);

 PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY :: (proc(pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, dwFlags : u32, pvReserved : rawptr) -> BOOL);

 HCERTSTORE :: rawptr;

 CERT_CONTEXT :: struct {
    dwCertEncodingType : u32,
    pbCertEncoded      : ^BYTE,
    cbCertEncoded      : u32,
    pCertInfo          : PCERT_INFO,
    hCertStore         : HCERTSTORE,
 };
 PCERT_CONTEXT :: ^struct {
    dwCertEncodingType : u32,
    pbCertEncoded      : ^BYTE,
    cbCertEncoded      : u32,
    pCertInfo          : PCERT_INFO,
    hCertStore         : HCERTSTORE,
 };

 PCCERT_CONTEXT :: ^CERT_CONTEXT;

 CRL_CONTEXT :: struct {
    dwCertEncodingType : u32,
    pbCrlEncoded       : ^BYTE,
    cbCrlEncoded       : u32,
    pCrlInfo           : PCRL_INFO,
    hCertStore         : HCERTSTORE,
 };
 PCRL_CONTEXT :: ^struct {
    dwCertEncodingType : u32,
    pbCrlEncoded       : ^BYTE,
    cbCrlEncoded       : u32,
    pCrlInfo           : PCRL_INFO,
    hCertStore         : HCERTSTORE,
 };

 PCCRL_CONTEXT :: ^CRL_CONTEXT;

 CTL_CONTEXT :: struct {
    dwMsgAndCertEncodingType : u32,
    pbCtlEncoded             : ^BYTE,
    cbCtlEncoded             : u32,
    pCtlInfo                 : PCTL_INFO,
    hCertStore               : HCERTSTORE,
    hCryptMsg                : HCRYPTMSG,
    pbCtlContent             : ^BYTE,
    cbCtlContent             : u32,
 };
 PCTL_CONTEXT :: ^struct {
    dwMsgAndCertEncodingType : u32,
    pbCtlEncoded             : ^BYTE,
    cbCtlEncoded             : u32,
    pCtlInfo                 : PCTL_INFO,
    hCertStore               : HCERTSTORE,
    hCryptMsg                : HCRYPTMSG,
    pbCtlContent             : ^BYTE,
    cbCtlContent             : u32,
 };

 PCCTL_CONTEXT :: ^CTL_CONTEXT;

 CertKeyType :: enum {
    KeyTypeOther = 0,
    KeyTypeVirtualSmartCard = 1,
    KeyTypePhysicalSmartCard = 2,
    KeyTypePassport = 3,
    KeyTypePassportRemote = 4,
    KeyTypePassportSmartCard = 5,
    KeyTypeHardware = 6,
    KeyTypeSoftware = 7,
    KeyTypeSelfSigned = 8,
 };

 CRYPT_KEY_PROV_PARAM :: struct {
    dwParam : u32,
    pbData  : ^BYTE,
    cbData  : u32,
    dwFlags : u32,
 };
 PCRYPT_KEY_PROV_PARAM :: ^struct {
    dwParam : u32,
    pbData  : ^BYTE,
    cbData  : u32,
    dwFlags : u32,
 };

 CRYPT_KEY_PROV_INFO :: struct {
    pwszContainerName : LPWSTR,
    pwszProvName      : LPWSTR,
    dwProvType        : u32,
    dwFlags           : u32,
    cProvParam        : u32,
    rgProvParam       : PCRYPT_KEY_PROV_PARAM,
    dwKeySpec         : u32,
 };
 PCRYPT_KEY_PROV_INFO :: ^struct {
    pwszContainerName : LPWSTR,
    pwszProvName      : LPWSTR,
    dwProvType        : u32,
    dwFlags           : u32,
    cProvParam        : u32,
    rgProvParam       : PCRYPT_KEY_PROV_PARAM,
    dwKeySpec         : u32,
 };

 CERT_KEY_CONTEXT :: struct {
    cbSize    : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec : u32,
 };
 PCERT_KEY_CONTEXT :: ^struct {
    cbSize    : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec : u32,
 };

 ROOT_INFO_LUID :: struct {
    LowPart  : u32,
    HighPart : LONG,
 };
 PROOT_INFO_LUID :: ^struct {
    LowPart  : u32,
    HighPart : LONG,
 };

 CRYPT_SMART_CARD_ROOT_INFO :: struct {
    rgbCardID : [16]BYTE,
    luid      : ROOT_INFO_LUID,
 };
 PCRYPT_SMART_CARD_ROOT_INFO :: ^struct {
    rgbCardID : [16]BYTE,
    luid      : ROOT_INFO_LUID,
 };

 CERT_SYSTEM_STORE_RELOCATE_PARA :: struct {
    u : struct #raw_union {
        hKeyBase : HKEY,
        pvBase   : rawptr,
    },
    u2 : struct #raw_union {
        pvSystemStore   : rawptr,
        pszSystemStore  : LPCSTR,
        pwszSystemStore : LPCWSTR,
    },
 };
 PCERT_SYSTEM_STORE_RELOCATE_PARA :: ^struct {
    u : struct #raw_union {
        hKeyBase : HKEY,
        pvBase   : rawptr,
    },
    u2 : struct #raw_union {
        pvSystemStore   : rawptr,
        pszSystemStore  : LPCSTR,
        pwszSystemStore : LPCWSTR,
    },
 };

 CERT_REGISTRY_STORE_CLIENT_GPT_PARA :: struct {
    hKeyBase    : HKEY,
    pwszRegPath : LPWSTR,
 };
 PCERT_REGISTRY_STORE_CLIENT_GPT_PARA :: ^struct {
    hKeyBase    : HKEY,
    pwszRegPath : LPWSTR,
 };

 CERT_REGISTRY_STORE_ROAMING_PARA :: struct {
    hKey               : HKEY,
    pwszStoreDirectory : LPWSTR,
 };
 PCERT_REGISTRY_STORE_ROAMING_PARA :: ^struct {
    hKey               : HKEY,
    pwszStoreDirectory : LPWSTR,
 };

 CERT_LDAP_STORE_OPENED_PARA :: struct {
    pvLdapSessionHandle : rawptr,
    pwszLdapUrl         : LPCWSTR,
 };
 PCERT_LDAP_STORE_OPENED_PARA :: ^struct {
    pvLdapSessionHandle : rawptr,
    pwszLdapUrl         : LPCWSTR,
 };

 HCERTSTOREPROV :: rawptr;

 CERT_STORE_PROV_INFO :: struct {
    cbSize              : u32,
    cStoreProvFunc      : u32,
    rgpvStoreProvFunc   : ^rawptr,
    hStoreProv          : HCERTSTOREPROV,
    dwStoreProvFlags    : u32,
    hStoreProvFuncAddr2 : HCRYPTOIDFUNCADDR,
 };
 PCERT_STORE_PROV_INFO :: ^struct {
    cbSize              : u32,
    cStoreProvFunc      : u32,
    rgpvStoreProvFunc   : ^rawptr,
    hStoreProv          : HCERTSTOREPROV,
    dwStoreProvFlags    : u32,
    hStoreProvFuncAddr2 : HCRYPTOIDFUNCADDR,
 };

 PFN_CERT_DLL_OPEN_STORE_PROV_FUNC :: (proc(lpszStoreProvider : LPCSTR, dwEncodingType : u32, hCryptProv : HCRYPTPROV_LEGACY, dwFlags : u32, pvPara : rawptr, hCertStore : HCERTSTORE, pStoreProvInfo : PCERT_STORE_PROV_INFO) -> BOOL);

 PFN_CERT_STORE_PROV_CLOSE :: proc(hStoreProv : HCERTSTOREPROV, dwFlags : u32);

 PFN_CERT_STORE_PROV_READ_CERT :: (proc(hStoreProv : HCERTSTOREPROV, pStoreCertContext : PCCERT_CONTEXT, dwFlags : u32, ppProvCertContext : ^PCCERT_CONTEXT) -> BOOL);

 PFN_CERT_STORE_PROV_WRITE_CERT :: (proc(hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_DELETE_CERT :: (proc(hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_SET_CERT_PROPERTY :: (proc(hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwPropId : u32, dwFlags : u32, pvData : rawptr) -> BOOL);

 PFN_CERT_STORE_PROV_READ_CRL :: (proc(hStoreProv : HCERTSTOREPROV, pStoreCrlContext : PCCRL_CONTEXT, dwFlags : u32, ppProvCrlContext : ^PCCRL_CONTEXT) -> BOOL);

 PFN_CERT_STORE_PROV_WRITE_CRL :: (proc(hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_DELETE_CRL :: (proc(hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_SET_CRL_PROPERTY :: (proc(hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwPropId : u32, dwFlags : u32, pvData : rawptr) -> BOOL);

 PFN_CERT_STORE_PROV_READ_CTL :: (proc(hStoreProv : HCERTSTOREPROV, pStoreCtlContext : PCCTL_CONTEXT, dwFlags : u32, ppProvCtlContext : ^PCCTL_CONTEXT) -> BOOL);

 PFN_CERT_STORE_PROV_WRITE_CTL :: (proc(hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_DELETE_CTL :: (proc(hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_SET_CTL_PROPERTY :: (proc(hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwPropId : u32, dwFlags : u32, pvData : rawptr) -> BOOL);

 PFN_CERT_STORE_PROV_CONTROL :: (proc(hStoreProv : HCERTSTOREPROV, dwFlags : u32, dwCtrlType : u32, pvCtrlPara : ^void) -> BOOL);

 CERT_STORE_PROV_FIND_INFO :: struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    dwFindFlags              : u32,
    dwFindType               : u32,
    pvFindPara               : rawptr,
 };
 PCERT_STORE_PROV_FIND_INFO :: ^struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    dwFindFlags              : u32,
    dwFindType               : u32,
    pvFindPara               : rawptr,
 };

 CCERT_STORE_PROV_FIND_INFO :: CERT_STORE_PROV_FIND_INFO;
 PCCERT_STORE_PROV_FIND_INFO :: ^CERT_STORE_PROV_FIND_INFO;

 PFN_CERT_STORE_PROV_FIND_CERT :: (proc(hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCertContext : PCCERT_CONTEXT, dwFlags : u32, ppvStoreProvFindInfo : ^rawptr, ppProvCertContext : ^PCCERT_CONTEXT) -> BOOL);

 PFN_CERT_STORE_PROV_FREE_FIND_CERT :: (proc(hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_GET_CERT_PROPERTY :: (proc(hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwPropId : u32, dwFlags : u32, pvData : rawptr, pcbData : ^u32) -> BOOL);

 PFN_CERT_STORE_PROV_FIND_CRL :: (proc(hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCrlContext : PCCRL_CONTEXT, dwFlags : u32, ppvStoreProvFindInfo : ^rawptr, ppProvCrlContext : ^PCCRL_CONTEXT) -> BOOL);

 PFN_CERT_STORE_PROV_FREE_FIND_CRL :: (proc(hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_GET_CRL_PROPERTY :: (proc(hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwPropId : u32, dwFlags : u32, pvData : rawptr, pcbData : ^u32) -> BOOL);

 PFN_CERT_STORE_PROV_FIND_CTL :: (proc(hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCtlContext : PCCTL_CONTEXT, dwFlags : u32, ppvStoreProvFindInfo : ^rawptr, ppProvCtlContext : ^PCCTL_CONTEXT) -> BOOL);

 PFN_CERT_STORE_PROV_FREE_FIND_CTL :: (proc(hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : u32) -> BOOL);

 PFN_CERT_STORE_PROV_GET_CTL_PROPERTY :: (proc(hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwPropId : u32, dwFlags : u32, pvData : rawptr, pcbData : ^u32) -> BOOL);

 CRL_FIND_ISSUED_FOR_PARA :: struct {
    pSubjectCert : PCCERT_CONTEXT,
    pIssuerCert  : PCCERT_CONTEXT,
 };
 PCRL_FIND_ISSUED_FOR_PARA :: ^struct {
    pSubjectCert : PCCERT_CONTEXT,
    pIssuerCert  : PCCERT_CONTEXT,
 };

 CTL_ANY_SUBJECT_INFO :: struct {
    SubjectAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    SubjectIdentifier : CRYPT_DATA_BLOB,
 };
 PCTL_ANY_SUBJECT_INFO :: ^struct {
    SubjectAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    SubjectIdentifier : CRYPT_DATA_BLOB,
 };

 CTL_FIND_USAGE_PARA :: struct {
    cbSize         : u32,
    SubjectUsage   : CTL_USAGE,
    ListIdentifier : CRYPT_DATA_BLOB,
    pSigner        : PCERT_INFO,
 };
 PCTL_FIND_USAGE_PARA :: ^struct {
    cbSize         : u32,
    SubjectUsage   : CTL_USAGE,
    ListIdentifier : CRYPT_DATA_BLOB,
    pSigner        : PCERT_INFO,
 };

 CTL_FIND_SUBJECT_PARA :: struct {
    cbSize        : u32,
    pUsagePara    : PCTL_FIND_USAGE_PARA,
    dwSubjectType : u32,
    pvSubject     : rawptr,
 };
 PCTL_FIND_SUBJECT_PARA :: ^struct {
    cbSize        : u32,
    pUsagePara    : PCTL_FIND_USAGE_PARA,
    dwSubjectType : u32,
    pvSubject     : rawptr,
 };

 PFN_CERT_CREATE_CONTEXT_SORT_FUNC :: (proc(cbTotalEncoded : u32, cbRemainEncoded : u32, cEntry : u32, pvSort : rawptr) -> BOOL);

 CERT_CREATE_CONTEXT_PARA :: struct {
    cbSize  : u32,
    pfnFree : PFN_CRYPT_FREE,
    pvFree  : rawptr,
    pfnSort : PFN_CERT_CREATE_CONTEXT_SORT_FUNC,
    pvSort  : rawptr,
 };
 PCERT_CREATE_CONTEXT_PARA :: ^struct {
    cbSize  : u32,
    pfnFree : PFN_CRYPT_FREE,
    pvFree  : rawptr,
    pfnSort : PFN_CERT_CREATE_CONTEXT_SORT_FUNC,
    pvSort  : rawptr,
 };

 CERT_SYSTEM_STORE_INFO :: struct {
    cbSize : u32,
 };
 PCERT_SYSTEM_STORE_INFO :: ^struct {
    cbSize : u32,
 };

 CERT_PHYSICAL_STORE_INFO :: struct {
    cbSize               : u32,
    pszOpenStoreProvider : LPSTR,
    dwOpenEncodingType   : u32,
    dwOpenFlags          : u32,
    OpenParameters       : CRYPT_DATA_BLOB,
    dwFlags              : u32,
    dwPriority           : u32,
 };
 PCERT_PHYSICAL_STORE_INFO :: ^struct {
    cbSize               : u32,
    pszOpenStoreProvider : LPSTR,
    dwOpenEncodingType   : u32,
    dwOpenFlags          : u32,
    OpenParameters       : CRYPT_DATA_BLOB,
    dwFlags              : u32,
    dwPriority           : u32,
 };

 PFN_CERT_ENUM_SYSTEM_STORE_LOCATION :: (proc(pwszStoreLocation : LPCWSTR, dwFlags : u32, pvReserved : rawptr, pvArg : rawptr) -> BOOL);

 PFN_CERT_ENUM_SYSTEM_STORE :: (proc(pvSystemStore : rawptr, dwFlags : u32, pStoreInfo : PCERT_SYSTEM_STORE_INFO, pvReserved : rawptr, pvArg : rawptr) -> BOOL);

 PFN_CERT_ENUM_PHYSICAL_STORE :: (proc(pvSystemStore : rawptr, dwFlags : u32, pwszStoreName : LPCWSTR, pStoreInfo : PCERT_PHYSICAL_STORE_INFO, pvReserved : rawptr, pvArg : rawptr) -> BOOL);

 CTL_VERIFY_USAGE_PARA :: struct {
    cbSize         : u32,
    ListIdentifier : CRYPT_DATA_BLOB,
    cCtlStore      : u32,
    rghCtlStore    : ^HCERTSTORE,
    cSignerStore   : u32,
    rghSignerStore : ^HCERTSTORE,
 };
 PCTL_VERIFY_USAGE_PARA :: ^struct {
    cbSize         : u32,
    ListIdentifier : CRYPT_DATA_BLOB,
    cCtlStore      : u32,
    rghCtlStore    : ^HCERTSTORE,
    cSignerStore   : u32,
    rghSignerStore : ^HCERTSTORE,
 };

 CTL_VERIFY_USAGE_STATUS :: struct {
    cbSize          : u32,
    dwError         : u32,
    dwFlags         : u32,
    ppCtl           : ^PCCTL_CONTEXT,
    dwCtlEntryIndex : u32,
    ppSigner        : ^PCCERT_CONTEXT,
    dwSignerIndex   : u32,
 };
 PCTL_VERIFY_USAGE_STATUS :: ^struct {
    cbSize          : u32,
    dwError         : u32,
    dwFlags         : u32,
    ppCtl           : ^PCCTL_CONTEXT,
    dwCtlEntryIndex : u32,
    ppSigner        : ^PCCERT_CONTEXT,
    dwSignerIndex   : u32,
 };

 CERT_REVOCATION_CRL_INFO :: struct {
    cbSize           : u32,
    pBaseCrlContext  : PCCRL_CONTEXT,
    pDeltaCrlContext : PCCRL_CONTEXT,
    pCrlEntry        : PCRL_ENTRY,
    fDeltaCrlEntry   : BOOL,
 };
 PCERT_REVOCATION_CRL_INFO :: ^struct {
    cbSize           : u32,
    pBaseCrlContext  : PCCRL_CONTEXT,
    pDeltaCrlContext : PCCRL_CONTEXT,
    pCrlEntry        : PCRL_ENTRY,
    fDeltaCrlEntry   : BOOL,
 };

 CERT_REVOCATION_CHAIN_PARA :: struct {};

 PCERT_REVOCATION_CHAIN_PARA :: ^CERT_REVOCATION_CHAIN_PARA;

 CERT_REVOCATION_PARA :: struct {
    cbSize       : u32,
    pIssuerCert  : PCCERT_CONTEXT,
    cCertStore   : u32,
    rgCertStore  : ^HCERTSTORE,
    hCrlStore    : HCERTSTORE,
    pftTimeToUse : LPFILETIME,
 };
 PCERT_REVOCATION_PARA :: ^struct {
    cbSize       : u32,
    pIssuerCert  : PCCERT_CONTEXT,
    cCertStore   : u32,
    rgCertStore  : ^HCERTSTORE,
    hCrlStore    : HCERTSTORE,
    pftTimeToUse : LPFILETIME,
 };

 CERT_REVOCATION_STATUS :: struct {
    cbSize            : u32,
    dwIndex           : u32,
    dwError           : u32,
    dwReason          : u32,
    fHasFreshnessTime : BOOL,
    dwFreshnessTime   : u32,
 };
 PCERT_REVOCATION_STATUS :: ^struct {
    cbSize            : u32,
    dwIndex           : u32,
    dwError           : u32,
    dwReason          : u32,
    fHasFreshnessTime : BOOL,
    dwFreshnessTime   : u32,
 };

 CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO :: struct {
    CertSignHashCNGAlgPropData        : CRYPT_DATA_BLOB,
    CertIssuerPubKeyBitLengthPropData : CRYPT_DATA_BLOB,
 };
 PCRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO :: ^struct {
    CertSignHashCNGAlgPropData        : CRYPT_DATA_BLOB,
    CertIssuerPubKeyBitLengthPropData : CRYPT_DATA_BLOB,
 };

 CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO :: struct {
    cCNGHashAlgid      : u32,
    rgpwszCNGHashAlgid : ^PCWSTR,
    dwWeakIndex        : u32,
 };
 PCRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO :: ^struct {
    cCNGHashAlgid      : u32,
    rgpwszCNGHashAlgid : ^PCWSTR,
    dwWeakIndex        : u32,
 };

 PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC :: (proc(dwCertEncodingType : u32, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, ppvDecodedSignPara : ^rawptr, ppwszCNGHashAlgid : ^LPWSTR) -> BOOL);

 PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC :: (proc(hKey : NCRYPT_KEY_HANDLE, dwCertEncodingType : u32, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara : rawptr, pwszCNGPubKeyAlgid : LPCWSTR, pwszCNGHashAlgid : LPCWSTR, pbComputedHash : ^BYTE, cbComputedHash : u32, pbSignature : ^BYTE, pcbSignature : ^u32) -> BOOL);

 PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC :: (proc(dwCertEncodingType : u32, pPubKeyInfo : PCERT_PUBLIC_KEY_INFO, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara : rawptr, pwszCNGPubKeyAlgid : LPCWSTR, pwszCNGHashAlgid : LPCWSTR, pbComputedHash : ^BYTE, cbComputedHash : u32, pbSignature : ^BYTE, cbSignature : u32) -> BOOL);

 HCRYPTDEFAULTCONTEXT :: rawptr;

 CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA :: struct {
    cOID     : u32,
    rgpszOID : ^LPSTR,
 };
 PCRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA :: ^struct {
    cOID     : u32,
    rgpszOID : ^LPSTR,
 };

 PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC :: (proc(hNCryptKey : NCRYPT_KEY_HANDLE, dwCertEncodingType : u32, pszPublicKeyObjId : LPSTR, dwFlags : u32, pvAuxInfo : rawptr, pInfo : PCERT_PUBLIC_KEY_INFO, pcbInfo : ^u32) -> BOOL);

 PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC :: (proc(hBCryptKey : BCRYPT_KEY_HANDLE, dwCertEncodingType : u32, pszPublicKeyObjId : LPSTR, dwFlags : u32, pvAuxInfo : rawptr, pInfo : PCERT_PUBLIC_KEY_INFO, pcbInfo : ^u32) -> BOOL);

 PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC :: (proc(dwCertEncodingType : u32, pInfo : PCERT_PUBLIC_KEY_INFO, dwFlags : u32, pvAuxInfo : rawptr, phKey : ^BCRYPT_KEY_HANDLE) -> BOOL);

 PFN_IMPORT_PRIV_KEY_FUNC :: (proc(hCryptProv : HCRYPTPROV, pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, dwFlags : u32, pvAuxInfo : rawptr) -> BOOL);

 PFN_EXPORT_PRIV_KEY_FUNC :: (proc(hCryptProv : HCRYPTPROV, dwKeySpec : u32, pszPrivateKeyObjId : LPSTR, dwFlags : u32, pvAuxInfo : rawptr, pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, pcbPrivateKeyInfo : ^u32) -> BOOL);

 PFN_CRYPT_GET_SIGNER_CERTIFICATE :: (proc(pvGetArg : rawptr, dwCertEncodingType : u32, pSignerId : PCERT_INFO, hMsgCertStore : HCERTSTORE) -> PCCERT_CONTEXT);

 CRYPT_SIGN_MESSAGE_PARA :: struct {
    cbSize             : u32,
    dwMsgEncodingType  : u32,
    pSigningCert       : PCCERT_CONTEXT,
    HashAlgorithm      : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo      : rawptr,
    cMsgCert           : u32,
    rgpMsgCert         : ^PCCERT_CONTEXT,
    cMsgCrl            : u32,
    rgpMsgCrl          : ^PCCRL_CONTEXT,
    cAuthAttr          : u32,
    rgAuthAttr         : PCRYPT_ATTRIBUTE,
    cUnauthAttr        : u32,
    rgUnauthAttr       : PCRYPT_ATTRIBUTE,
    dwFlags            : u32,
    dwInnerContentType : u32,
 };
 PCRYPT_SIGN_MESSAGE_PARA :: ^struct {
    cbSize             : u32,
    dwMsgEncodingType  : u32,
    pSigningCert       : PCCERT_CONTEXT,
    HashAlgorithm      : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo      : rawptr,
    cMsgCert           : u32,
    rgpMsgCert         : ^PCCERT_CONTEXT,
    cMsgCrl            : u32,
    rgpMsgCrl          : ^PCCRL_CONTEXT,
    cAuthAttr          : u32,
    rgAuthAttr         : PCRYPT_ATTRIBUTE,
    cUnauthAttr        : u32,
    rgUnauthAttr       : PCRYPT_ATTRIBUTE,
    dwFlags            : u32,
    dwInnerContentType : u32,
 };

 CRYPT_VERIFY_MESSAGE_PARA :: struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    hCryptProv               : HCRYPTPROV_LEGACY,
    pfnGetSignerCertificate  : PFN_CRYPT_GET_SIGNER_CERTIFICATE,
    pvGetArg                 : rawptr,
 };
 PCRYPT_VERIFY_MESSAGE_PARA :: ^struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    hCryptProv               : HCRYPTPROV_LEGACY,
    pfnGetSignerCertificate  : PFN_CRYPT_GET_SIGNER_CERTIFICATE,
    pvGetArg                 : rawptr,
 };

 CRYPT_ENCRYPT_MESSAGE_PARA :: struct {
    cbSize                     : u32,
    dwMsgEncodingType          : u32,
    hCryptProv                 : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
    dwFlags                    : u32,
    dwInnerContentType         : u32,
 };
 PCRYPT_ENCRYPT_MESSAGE_PARA :: ^struct {
    cbSize                     : u32,
    dwMsgEncodingType          : u32,
    hCryptProv                 : HCRYPTPROV_LEGACY,
    ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER,
    pvEncryptionAuxInfo        : rawptr,
    dwFlags                    : u32,
    dwInnerContentType         : u32,
 };

 CRYPT_DECRYPT_MESSAGE_PARA :: struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    cCertStore               : u32,
    rghCertStore             : ^HCERTSTORE,
 };
 PCRYPT_DECRYPT_MESSAGE_PARA :: ^struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    cCertStore               : u32,
    rghCertStore             : ^HCERTSTORE,
 };

 CRYPT_HASH_MESSAGE_PARA :: struct {
    cbSize            : u32,
    dwMsgEncodingType : u32,
    hCryptProv        : HCRYPTPROV_LEGACY,
    HashAlgorithm     : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo     : rawptr,
 };
 PCRYPT_HASH_MESSAGE_PARA :: ^struct {
    cbSize            : u32,
    dwMsgEncodingType : u32,
    hCryptProv        : HCRYPTPROV_LEGACY,
    HashAlgorithm     : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo     : rawptr,
 };

 CRYPT_KEY_SIGN_MESSAGE_PARA :: struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec                : u32,
    HashAlgorithm            : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo            : rawptr,
    PubKeyAlgorithm          : CRYPT_ALGORITHM_IDENTIFIER,
 };
 PCRYPT_KEY_SIGN_MESSAGE_PARA :: ^struct {
    cbSize                   : u32,
    dwMsgAndCertEncodingType : u32,
    u : struct #raw_union {
        hCryptProv : HCRYPTPROV,
        hNCryptKey : NCRYPT_KEY_HANDLE,
    },
    dwKeySpec                : u32,
    HashAlgorithm            : CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo            : rawptr,
    PubKeyAlgorithm          : CRYPT_ALGORITHM_IDENTIFIER,
 };

 CRYPT_KEY_VERIFY_MESSAGE_PARA :: struct {
    cbSize            : u32,
    dwMsgEncodingType : u32,
    hCryptProv        : HCRYPTPROV_LEGACY,
 };
 PCRYPT_KEY_VERIFY_MESSAGE_PARA :: ^struct {
    cbSize            : u32,
    dwMsgEncodingType : u32,
    hCryptProv        : HCRYPTPROV_LEGACY,
 };

 CERT_CHAIN :: struct {
    cCerts         : u32,
    certs          : PCERT_BLOB,
    keyLocatorInfo : CRYPT_KEY_PROV_INFO,
 };
 PCERT_CHAIN :: ^struct {
    cCerts         : u32,
    certs          : PCERT_BLOB,
    keyLocatorInfo : CRYPT_KEY_PROV_INFO,
 };

 HCRYPTASYNC :: HANDLE;
 PHCRYPTASYNC :: ^HANDLE;

 PFN_CRYPT_ASYNC_PARAM_FREE_FUNC :: proc(pszParamOid : LPSTR, pvParam : LPVOID);

 CRYPT_BLOB_ARRAY :: struct {
    cBlob  : u32,
    rgBlob : PCRYPT_DATA_BLOB,
 };
 PCRYPT_BLOB_ARRAY :: ^struct {
    cBlob  : u32,
    rgBlob : PCRYPT_DATA_BLOB,
 };

 CRYPT_CREDENTIALS :: struct {
    cbSize            : u32,
    pszCredentialsOid : LPCSTR,
    pvCredentials     : LPVOID,
 };
 PCRYPT_CREDENTIALS :: ^struct {
    cbSize            : u32,
    pszCredentialsOid : LPCSTR,
    pvCredentials     : LPVOID,
 };

 CRYPT_PASSWORD_CREDENTIALSA :: struct {
    cbSize      : u32,
    pszUsername : LPSTR,
    pszPassword : LPSTR,
 };
 PCRYPT_PASSWORD_CREDENTIALSA :: ^struct {
    cbSize      : u32,
    pszUsername : LPSTR,
    pszPassword : LPSTR,
 };

 CRYPT_PASSWORD_CREDENTIALSW :: struct {
    cbSize      : u32,
    pszUsername : LPWSTR,
    pszPassword : LPWSTR,
 };
 PCRYPT_PASSWORD_CREDENTIALSW :: ^struct {
    cbSize      : u32,
    pszUsername : LPWSTR,
    pszPassword : LPWSTR,
 };

 CRYPT_PASSWORD_CREDENTIALS :: CRYPT_PASSWORD_CREDENTIALSA;

 PCRYPT_PASSWORD_CREDENTIALS :: PCRYPT_PASSWORD_CREDENTIALSA;

 PFN_FREE_ENCODED_OBJECT_FUNC :: proc(pszObjectOid : LPCSTR, pObject : PCRYPT_BLOB_ARRAY, pvFreeContext : LPVOID);

 CRYPTNET_URL_CACHE_PRE_FETCH_INFO :: struct {
    cbSize         : u32,
    dwObjectType   : u32,
    dwError        : u32,
    dwReserved     : u32,
    ThisUpdateTime : FILETIME,
    NextUpdateTime : FILETIME,
    PublishTime    : FILETIME,
 };
 PCRYPTNET_URL_CACHE_PRE_FETCH_INFO :: ^struct {
    cbSize         : u32,
    dwObjectType   : u32,
    dwError        : u32,
    dwReserved     : u32,
    ThisUpdateTime : FILETIME,
    NextUpdateTime : FILETIME,
    PublishTime    : FILETIME,
 };

 CRYPTNET_URL_CACHE_FLUSH_INFO :: struct {
    cbSize          : u32,
    dwExemptSeconds : u32,
    ExpireTime      : FILETIME,
 };
 PCRYPTNET_URL_CACHE_FLUSH_INFO :: ^struct {
    cbSize          : u32,
    dwExemptSeconds : u32,
    ExpireTime      : FILETIME,
 };

 CRYPTNET_URL_CACHE_RESPONSE_INFO :: struct {
    cbSize           : u32,
    wResponseType    : u16,
    wResponseFlags   : u16,
    LastModifiedTime : FILETIME,
    dwMaxAge         : u32,
    pwszETag         : LPCWSTR,
    dwProxyId        : u32,
 };
 PCRYPTNET_URL_CACHE_RESPONSE_INFO :: ^struct {
    cbSize           : u32,
    wResponseType    : u16,
    wResponseFlags   : u16,
    LastModifiedTime : FILETIME,
    dwMaxAge         : u32,
    pwszETag         : LPCWSTR,
    dwProxyId        : u32,
 };

 CRYPT_RETRIEVE_AUX_INFO :: struct {
    cbSize                     : u32,
    pLastSyncTime              : ^FILETIME,
    dwMaxUrlRetrievalByteCount : u32,
    pPreFetchInfo              : PCRYPTNET_URL_CACHE_PRE_FETCH_INFO,
    pFlushInfo                 : PCRYPTNET_URL_CACHE_FLUSH_INFO,
    ppResponseInfo             : ^PCRYPTNET_URL_CACHE_RESPONSE_INFO,
    pwszCacheFileNamePrefix    : LPWSTR,
    pftCacheResync             : LPFILETIME,
    fProxyCacheRetrieval       : BOOL,
    dwHttpStatusCode           : u32,
    ppwszErrorResponseHeaders  : ^LPWSTR,
    ppErrorContentBlob         : ^PCRYPT_DATA_BLOB,
 };
 PCRYPT_RETRIEVE_AUX_INFO :: ^struct {
    cbSize                     : u32,
    pLastSyncTime              : ^FILETIME,
    dwMaxUrlRetrievalByteCount : u32,
    pPreFetchInfo              : PCRYPTNET_URL_CACHE_PRE_FETCH_INFO,
    pFlushInfo                 : PCRYPTNET_URL_CACHE_FLUSH_INFO,
    ppResponseInfo             : ^PCRYPTNET_URL_CACHE_RESPONSE_INFO,
    pwszCacheFileNamePrefix    : LPWSTR,
    pftCacheResync             : LPFILETIME,
    fProxyCacheRetrieval       : BOOL,
    dwHttpStatusCode           : u32,
    ppwszErrorResponseHeaders  : ^LPWSTR,
    ppErrorContentBlob         : ^PCRYPT_DATA_BLOB,
 };

 PFN_CRYPT_CANCEL_RETRIEVAL :: (proc(dwFlags : u32, pvArg : rawptr) -> BOOL);

 PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC :: proc(pvCompletion : LPVOID, dwCompletionCode : u32, pszUrl : LPCSTR, pszObjectOid : LPSTR, pvObject : LPVOID);

 CRYPT_ASYNC_RETRIEVAL_COMPLETION :: struct {
    pfnCompletion : PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC,
    pvCompletion  : LPVOID,
 };
 PCRYPT_ASYNC_RETRIEVAL_COMPLETION :: ^struct {
    pfnCompletion : PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC,
    pvCompletion  : LPVOID,
 };

 PFN_CANCEL_ASYNC_RETRIEVAL_FUNC :: (proc(hAsyncRetrieve : HCRYPTASYNC) -> BOOL);

 CRYPT_URL_ARRAY :: struct {
    cUrl     : u32,
    rgwszUrl : ^LPWSTR,
 };
 PCRYPT_URL_ARRAY :: ^struct {
    cUrl     : u32,
    rgwszUrl : ^LPWSTR,
 };

 CRYPT_URL_INFO :: struct {
    cbSize          : u32,
    dwSyncDeltaTime : u32,
    cGroup          : u32,
    rgcGroupEntry   : ^u32,
 };
 PCRYPT_URL_INFO :: ^struct {
    cbSize          : u32,
    dwSyncDeltaTime : u32,
    cGroup          : u32,
    rgcGroupEntry   : ^u32,
 };

 CERT_CRL_CONTEXT_PAIR :: struct {
    pCertContext : PCCERT_CONTEXT,
    pCrlContext  : PCCRL_CONTEXT,
 };
 PCERT_CRL_CONTEXT_PAIR :: ^struct {
    pCertContext : PCCERT_CONTEXT,
    pCrlContext  : PCCRL_CONTEXT,
 };

 PCCERT_CRL_CONTEXT_PAIR :: ^CERT_CRL_CONTEXT_PAIR;

 CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO :: struct {
    cbSize             : u32,
    iDeltaCrlIndicator : i32,
    pftCacheResync     : LPFILETIME,
    pLastSyncTime      : LPFILETIME,
    pMaxAgeTime        : LPFILETIME,
    pChainPara         : PCERT_REVOCATION_CHAIN_PARA,
    pDeltaCrlIndicator : PCRYPT_INTEGER_BLOB,
 };
 PCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO :: ^struct {
    cbSize             : u32,
    iDeltaCrlIndicator : i32,
    pftCacheResync     : LPFILETIME,
    pLastSyncTime      : LPFILETIME,
    pMaxAgeTime        : LPFILETIME,
    pChainPara         : PCERT_REVOCATION_CHAIN_PARA,
    pDeltaCrlIndicator : PCRYPT_INTEGER_BLOB,
 };

 PFN_CRYPT_ENUM_KEYID_PROP :: (proc(pKeyIdentifier : ^CRYPT_HASH_BLOB, dwFlags : u32, pvReserved : rawptr, pvArg : rawptr, cProp : u32, rgdwPropId : ^u32, rgpvData : ^rawptr, rgcbData : ^u32) -> BOOL);

 HCERTCHAINENGINE :: HANDLE;

 CERT_CHAIN_ENGINE_CONFIG :: struct {
    cbSize                    : u32,
    hRestrictedRoot           : HCERTSTORE,
    hRestrictedTrust          : HCERTSTORE,
    hRestrictedOther          : HCERTSTORE,
    cAdditionalStore          : u32,
    rghAdditionalStore        : ^HCERTSTORE,
    dwFlags                   : u32,
    dwUrlRetrievalTimeout     : u32,
    MaximumCachedCertificates : u32,
    CycleDetectionModulus     : u32,
    hExclusiveRoot            : HCERTSTORE,
    hExclusiveTrustedPeople   : HCERTSTORE,
    dwExclusiveFlags          : u32,
 };
 PCERT_CHAIN_ENGINE_CONFIG :: ^struct {
    cbSize                    : u32,
    hRestrictedRoot           : HCERTSTORE,
    hRestrictedTrust          : HCERTSTORE,
    hRestrictedOther          : HCERTSTORE,
    cAdditionalStore          : u32,
    rghAdditionalStore        : ^HCERTSTORE,
    dwFlags                   : u32,
    dwUrlRetrievalTimeout     : u32,
    MaximumCachedCertificates : u32,
    CycleDetectionModulus     : u32,
    hExclusiveRoot            : HCERTSTORE,
    hExclusiveTrustedPeople   : HCERTSTORE,
    dwExclusiveFlags          : u32,
 };

 CERT_TRUST_STATUS :: struct {
    dwErrorStatus : u32,
    dwInfoStatus  : u32,
 };
 PCERT_TRUST_STATUS :: ^struct {
    dwErrorStatus : u32,
    dwInfoStatus  : u32,
 };

 CERT_REVOCATION_INFO :: struct {
    cbSize             : u32,
    dwRevocationResult : u32,
    pszRevocationOid   : LPCSTR,
    pvOidSpecificInfo  : LPVOID,
    fHasFreshnessTime  : BOOL,
    dwFreshnessTime    : u32,
    pCrlInfo           : PCERT_REVOCATION_CRL_INFO,
 };
 PCERT_REVOCATION_INFO :: ^struct {
    cbSize             : u32,
    dwRevocationResult : u32,
    pszRevocationOid   : LPCSTR,
    pvOidSpecificInfo  : LPVOID,
    fHasFreshnessTime  : BOOL,
    dwFreshnessTime    : u32,
    pCrlInfo           : PCERT_REVOCATION_CRL_INFO,
 };

 CERT_TRUST_LIST_INFO :: struct {
    cbSize      : u32,
    pCtlEntry   : PCTL_ENTRY,
    pCtlContext : PCCTL_CONTEXT,
 };
 PCERT_TRUST_LIST_INFO :: ^struct {
    cbSize      : u32,
    pCtlEntry   : PCTL_ENTRY,
    pCtlContext : PCCTL_CONTEXT,
 };

 CERT_CHAIN_ELEMENT :: struct {
    cbSize                : u32,
    pCertContext          : PCCERT_CONTEXT,
    TrustStatus           : CERT_TRUST_STATUS,
    pRevocationInfo       : PCERT_REVOCATION_INFO,
    pIssuanceUsage        : PCERT_ENHKEY_USAGE,
    pApplicationUsage     : PCERT_ENHKEY_USAGE,
    pwszExtendedErrorInfo : LPCWSTR,
 };
 PCERT_CHAIN_ELEMENT :: ^struct {
    cbSize                : u32,
    pCertContext          : PCCERT_CONTEXT,
    TrustStatus           : CERT_TRUST_STATUS,
    pRevocationInfo       : PCERT_REVOCATION_INFO,
    pIssuanceUsage        : PCERT_ENHKEY_USAGE,
    pApplicationUsage     : PCERT_ENHKEY_USAGE,
    pwszExtendedErrorInfo : LPCWSTR,
 };

 PCCERT_CHAIN_ELEMENT :: ^CERT_CHAIN_ELEMENT;

 CERT_SIMPLE_CHAIN :: struct {
    cbSize                      : u32,
    TrustStatus                 : CERT_TRUST_STATUS,
    cElement                    : u32,
    rgpElement                  : ^PCERT_CHAIN_ELEMENT,
    pTrustListInfo              : PCERT_TRUST_LIST_INFO,
    fHasRevocationFreshnessTime : BOOL,
    dwRevocationFreshnessTime   : u32,
 };
 PCERT_SIMPLE_CHAIN :: ^struct {
    cbSize                      : u32,
    TrustStatus                 : CERT_TRUST_STATUS,
    cElement                    : u32,
    rgpElement                  : ^PCERT_CHAIN_ELEMENT,
    pTrustListInfo              : PCERT_TRUST_LIST_INFO,
    fHasRevocationFreshnessTime : BOOL,
    dwRevocationFreshnessTime   : u32,
 };

 PCCERT_SIMPLE_CHAIN :: ^CERT_SIMPLE_CHAIN;

 CERT_CHAIN_CONTEXT :: struct {};

 PCERT_CHAIN_CONTEXT :: ^CERT_CHAIN_CONTEXT;

 PCCERT_CHAIN_CONTEXT :: ^CERT_CHAIN_CONTEXT;

 CERT_CHAIN_CONTEXT :: struct {
    cbSize                      : u32,
    TrustStatus                 : CERT_TRUST_STATUS,
    cChain                      : u32,
    rgpChain                    : ^PCERT_SIMPLE_CHAIN,
    cLowerQualityChainContext   : u32,
    rgpLowerQualityChainContext : ^PCCERT_CHAIN_CONTEXT,
    fHasRevocationFreshnessTime : BOOL,
    dwRevocationFreshnessTime   : u32,
    dwCreateFlags               : u32,
    ChainId                     : GUID,
 };

 CERT_USAGE_MATCH :: struct {
    dwType : u32,
    Usage  : CERT_ENHKEY_USAGE,
 };
 PCERT_USAGE_MATCH :: ^struct {
    dwType : u32,
    Usage  : CERT_ENHKEY_USAGE,
 };

 CTL_USAGE_MATCH :: struct {
    dwType : u32,
    Usage  : CTL_USAGE,
 };
 PCTL_USAGE_MATCH :: ^struct {
    dwType : u32,
    Usage  : CTL_USAGE,
 };

 CERT_CHAIN_PARA :: struct {
    cbSize         : u32,
    RequestedUsage : CERT_USAGE_MATCH,
 };
 PCERT_CHAIN_PARA :: ^struct {
    cbSize         : u32,
    RequestedUsage : CERT_USAGE_MATCH,
 };

 CERT_REVOCATION_CHAIN_PARA :: struct {
    cbSize                     : u32,
    hChainEngine               : HCERTCHAINENGINE,
    hAdditionalStore           : HCERTSTORE,
    dwChainFlags               : u32,
    dwUrlRetrievalTimeout      : u32,
    pftCurrentTime             : LPFILETIME,
    pftCacheResync             : LPFILETIME,
    cbMaxUrlRetrievalByteCount : u32,
 };

 CRL_REVOCATION_INFO :: struct {
    pCrlEntry       : PCRL_ENTRY,
    pCrlContext     : PCCRL_CONTEXT,
    pCrlIssuerChain : PCCERT_CHAIN_CONTEXT,
 };
 PCRL_REVOCATION_INFO :: ^struct {
    pCrlEntry       : PCRL_ENTRY,
    pCrlContext     : PCCRL_CONTEXT,
    pCrlIssuerChain : PCCERT_CHAIN_CONTEXT,
 };

 PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK :: (proc(pCert : PCCERT_CONTEXT, pvFindArg : rawptr) -> BOOL);

 CERT_CHAIN_FIND_ISSUER_PARA :: struct {
    cbSize                   : u32,
    pszUsageIdentifier       : LPCSTR,
    dwKeySpec                : u32,
    dwAcquirePrivateKeyFlags : u32,
    cIssuer                  : u32,
    rgIssuer                 : ^CERT_NAME_BLOB,
    pfnFindCallback          : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
    pvFindArg                : rawptr,
 };
 PCERT_CHAIN_FIND_ISSUER_PARA :: ^struct {
    cbSize                   : u32,
    pszUsageIdentifier       : LPCSTR,
    dwKeySpec                : u32,
    dwAcquirePrivateKeyFlags : u32,
    cIssuer                  : u32,
    rgIssuer                 : ^CERT_NAME_BLOB,
    pfnFindCallback          : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
    pvFindArg                : rawptr,
 };
 CERT_CHAIN_FIND_BY_ISSUER_PARA :: struct {
    cbSize                   : u32,
    pszUsageIdentifier       : LPCSTR,
    dwKeySpec                : u32,
    dwAcquirePrivateKeyFlags : u32,
    cIssuer                  : u32,
    rgIssuer                 : ^CERT_NAME_BLOB,
    pfnFindCallback          : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
    pvFindArg                : rawptr,
 };
 PCERT_CHAIN_FIND_BY_ISSUER_PARA :: ^struct {
    cbSize                   : u32,
    pszUsageIdentifier       : LPCSTR,
    dwKeySpec                : u32,
    dwAcquirePrivateKeyFlags : u32,
    cIssuer                  : u32,
    rgIssuer                 : ^CERT_NAME_BLOB,
    pfnFindCallback          : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
    pvFindArg                : rawptr,
 };

 CERT_CHAIN_POLICY_PARA :: struct {
    cbSize            : u32,
    dwFlags           : u32,
    pvExtraPolicyPara : rawptr,
 };
 PCERT_CHAIN_POLICY_PARA :: ^struct {
    cbSize            : u32,
    dwFlags           : u32,
    pvExtraPolicyPara : rawptr,
 };

 CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize              : u32,
    dwError             : u32,
    lChainIndex         : LONG,
    lElementIndex       : LONG,
    pvExtraPolicyStatus : rawptr,
 };
 PCERT_CHAIN_POLICY_STATUS :: ^struct {
    cbSize              : u32,
    dwError             : u32,
    lChainIndex         : LONG,
    lElementIndex       : LONG,
    pvExtraPolicyStatus : rawptr,
 };

 AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize              : u32,
    dwRegPolicySettings : u32,
    pSignerInfo         : PCMSG_SIGNER_INFO,
 };
 PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA :: ^struct {
    cbSize              : u32,
    dwRegPolicySettings : u32,
    pSignerInfo         : PCMSG_SIGNER_INFO,
 };

 AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize      : u32,
    fCommercial : BOOL,
 };
 PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^struct {
    cbSize      : u32,
    fCommercial : BOOL,
 };

 AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize              : u32,
    dwRegPolicySettings : u32,
    fCommercial         : BOOL,
 };
 PAUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA :: ^struct {
    cbSize              : u32,
    dwRegPolicySettings : u32,
    fCommercial         : BOOL,
 };

 HTTPSPolicyCallbackData :: struct {
    u : struct #raw_union {
        cbStruct : u32,
        cbSize   : u32,
    },
    dwAuthType     : u32,
    fdwChecks      : u32,
    pwszServerName : ^WCHAR,
 };
 PHTTPSPolicyCallbackData :: ^struct {
    u : struct #raw_union {
        cbStruct : u32,
        cbSize   : u32,
    },
    dwAuthType     : u32,
    fdwChecks      : u32,
    pwszServerName : ^WCHAR,
 };
 SSL_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    u : struct #raw_union {
        cbStruct : u32,
        cbSize   : u32,
    },
    dwAuthType     : u32,
    fdwChecks      : u32,
    pwszServerName : ^WCHAR,
 };
 PSSL_EXTRA_CERT_CHAIN_POLICY_PARA :: ^struct {
    u : struct #raw_union {
        cbStruct : u32,
        cbSize   : u32,
    },
    dwAuthType     : u32,
    fdwChecks      : u32,
    pwszServerName : ^WCHAR,
 };

 EV_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize                      : u32,
    dwRootProgramQualifierFlags : u32,
 };
 PEV_EXTRA_CERT_CHAIN_POLICY_PARA :: ^struct {
    cbSize                      : u32,
    dwRootProgramQualifierFlags : u32,
 };

 EV_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize               : u32,
    dwQualifiers         : u32,
    dwIssuanceUsageIndex : u32,
 };
 PEV_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^struct {
    cbSize               : u32,
    dwQualifiers         : u32,
    dwIssuanceUsageIndex : u32,
 };

 SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize          : u32,
    dwErrorLevel    : u32,
    dwErrorCategory : u32,
    dwReserved      : u32,
    wszErrorText    : [256]WCHAR,
 };
 PSSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^struct {
    cbSize          : u32,
    dwErrorLevel    : u32,
    dwErrorCategory : u32,
    dwReserved      : u32,
    wszErrorText    : [256]WCHAR,
 };

 SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize         : u32,
    dwReserved     : u32,
    pwszServerName : LPWSTR,
    rgpszHpkpValue : [2]LPSTR,
 };
 PSSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA :: ^struct {
    cbSize         : u32,
    dwReserved     : u32,
    pwszServerName : LPWSTR,
    rgpszHpkpValue : [2]LPSTR,
 };

 SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA :: struct {
    cbSize         : u32,
    dwReserved     : u32,
    pwszServerName : PCWSTR,
 };
 PSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA :: ^struct {
    cbSize         : u32,
    dwReserved     : u32,
    pwszServerName : PCWSTR,
 };

 SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct {
    cbSize       : u32,
    lError       : LONG,
    wszErrorText : [512]WCHAR,
 };
 PSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^struct {
    cbSize       : u32,
    lError       : LONG,
    wszErrorText : [512]WCHAR,
 };

 CRYPT_PKCS12_PBE_PARAMS :: struct {
    iIterations : i32,
    cbSalt      : ULONG,
 };

 PKCS12_PBES2_EXPORT_PARAMS :: struct {
    dwSize            : u32,
    hNcryptDescriptor : PVOID,
    pwszPbes2Alg      : LPWSTR,
 };
 PPKCS12_PBES2_EXPORT_PARAMS :: ^struct {
    dwSize            : u32,
    hNcryptDescriptor : PVOID,
    pwszPbes2Alg      : LPWSTR,
 };

 HCERT_SERVER_OCSP_RESPONSE :: rawptr;

 CERT_SERVER_OCSP_RESPONSE_CONTEXT :: struct {};

 PCERT_SERVER_OCSP_RESPONSE_CONTEXT :: ^CERT_SERVER_OCSP_RESPONSE_CONTEXT;

 PCCERT_SERVER_OCSP_RESPONSE_CONTEXT :: ^CERT_SERVER_OCSP_RESPONSE_CONTEXT;

 CERT_SERVER_OCSP_RESPONSE_CONTEXT :: struct {
    cbSize                : u32,
    pbEncodedOcspResponse : ^BYTE,
    cbEncodedOcspResponse : u32,
 };

 PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK :: proc(pChainContext : PCCERT_CHAIN_CONTEXT, pServerOcspResponseContext : PCCERT_SERVER_OCSP_RESPONSE_CONTEXT, pNewCrlContext : PCCRL_CONTEXT, pPrevCrlContext : PCCRL_CONTEXT, pvArg : PVOID, dwWriteOcspFileError : u32);

 CERT_SERVER_OCSP_RESPONSE_OPEN_PARA :: struct {
    cbSize              : u32,
    dwFlags             : u32,
    pcbUsedSize         : ^u32,
    pwszOcspDirectory   : PWSTR,
    pfnUpdateCallback   : PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK,
    pvUpdateCallbackArg : PVOID,
 };
 PCERT_SERVER_OCSP_RESPONSE_OPEN_PARA :: ^struct {
    cbSize              : u32,
    dwFlags             : u32,
    pcbUsedSize         : ^u32,
    pwszOcspDirectory   : PWSTR,
    pfnUpdateCallback   : PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK,
    pvUpdateCallbackArg : PVOID,
 };

 CERT_SELECT_CHAIN_PARA :: struct {
    hChainEngine     : HCERTCHAINENGINE,
    pTime            : PFILETIME,
    hAdditionalStore : HCERTSTORE,
    pChainPara       : PCERT_CHAIN_PARA,
    dwFlags          : u32,
 };
 PCERT_SELECT_CHAIN_PARA :: ^struct {
    hChainEngine     : HCERTCHAINENGINE,
    pTime            : PFILETIME,
    hAdditionalStore : HCERTSTORE,
    pChainPara       : PCERT_CHAIN_PARA,
    dwFlags          : u32,
 };

 PCCERT_SELECT_CHAIN_PARA :: ^CERT_SELECT_CHAIN_PARA;

 CERT_SELECT_CRITERIA :: struct {
    dwType : u32,
    cPara  : u32,
    ppPara : ^rawptr,
 };
 PCERT_SELECT_CRITERIA :: ^struct {
    dwType : u32,
    cPara  : u32,
    ppPara : ^rawptr,
 };

 PCCERT_SELECT_CRITERIA :: ^CERT_SELECT_CRITERIA;

 CRYPT_TIMESTAMP_REQUEST :: struct {
    dwVersion      : u32,
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    HashedMessage  : CRYPT_DER_BLOB,
    pszTSAPolicyId : LPSTR,
    Nonce          : CRYPT_INTEGER_BLOB,
    fCertReq       : BOOL,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };
 PCRYPT_TIMESTAMP_REQUEST :: ^struct {
    dwVersion      : u32,
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    HashedMessage  : CRYPT_DER_BLOB,
    pszTSAPolicyId : LPSTR,
    Nonce          : CRYPT_INTEGER_BLOB,
    fCertReq       : BOOL,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };

 CRYPT_TIMESTAMP_RESPONSE :: struct {
    dwStatus    : u32,
    cFreeText   : u32,
    rgFreeText  : ^LPWSTR,
    FailureInfo : CRYPT_BIT_BLOB,
    ContentInfo : CRYPT_DER_BLOB,
 };
 PCRYPT_TIMESTAMP_RESPONSE :: ^struct {
    dwStatus    : u32,
    cFreeText   : u32,
    rgFreeText  : ^LPWSTR,
    FailureInfo : CRYPT_BIT_BLOB,
    ContentInfo : CRYPT_DER_BLOB,
 };

 CRYPT_TIMESTAMP_ACCURACY :: struct {
    dwSeconds : u32,
    dwMillis  : u32,
    dwMicros  : u32,
 };
 PCRYPT_TIMESTAMP_ACCURACY :: ^struct {
    dwSeconds : u32,
    dwMillis  : u32,
    dwMicros  : u32,
 };

 CRYPT_TIMESTAMP_INFO :: struct {
    dwVersion      : u32,
    pszTSAPolicyId : LPSTR,
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    HashedMessage  : CRYPT_DER_BLOB,
    SerialNumber   : CRYPT_INTEGER_BLOB,
    ftTime         : FILETIME,
    pvAccuracy     : PCRYPT_TIMESTAMP_ACCURACY,
    fOrdering      : BOOL,
    Nonce          : CRYPT_DER_BLOB,
    Tsa            : CRYPT_DER_BLOB,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };
 PCRYPT_TIMESTAMP_INFO :: ^struct {
    dwVersion      : u32,
    pszTSAPolicyId : LPSTR,
    HashAlgorithm  : CRYPT_ALGORITHM_IDENTIFIER,
    HashedMessage  : CRYPT_DER_BLOB,
    SerialNumber   : CRYPT_INTEGER_BLOB,
    ftTime         : FILETIME,
    pvAccuracy     : PCRYPT_TIMESTAMP_ACCURACY,
    fOrdering      : BOOL,
    Nonce          : CRYPT_DER_BLOB,
    Tsa            : CRYPT_DER_BLOB,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };

 CRYPT_TIMESTAMP_CONTEXT :: struct {
    cbEncoded  : u32,
    pbEncoded  : ^BYTE,
    pTimeStamp : PCRYPT_TIMESTAMP_INFO,
 };
 PCRYPT_TIMESTAMP_CONTEXT :: ^struct {
    cbEncoded  : u32,
    pbEncoded  : ^BYTE,
    pTimeStamp : PCRYPT_TIMESTAMP_INFO,
 };

 CRYPT_TIMESTAMP_PARA :: struct {
    pszTSAPolicyId : LPCSTR,
    fRequestCerts  : BOOL,
    Nonce          : CRYPT_INTEGER_BLOB,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };
 PCRYPT_TIMESTAMP_PARA :: ^struct {
    pszTSAPolicyId : LPCSTR,
    fRequestCerts  : BOOL,
    Nonce          : CRYPT_INTEGER_BLOB,
    cExtension     : u32,
    rgExtension    : PCERT_EXTENSION,
 };

 PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH :: (proc(pContext : LPVOID, rgIdentifierOrNameList : ^PCERT_NAME_BLOB, dwIdentifierOrNameListCount : u32) -> BOOL);

 PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET :: (proc(pPluginContext : LPVOID, pIdentifier : PCRYPT_DATA_BLOB, dwNameType : u32, pNameBlob : PCERT_NAME_BLOB, ppbContent : ^PBYTE, pcbContent : ^u32, ppwszPassword : ^PCWSTR, ppIdentifier : ^PCRYPT_DATA_BLOB) -> BOOL);

 PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE :: proc(dwReason : u32, pPluginContext : LPVOID);

 PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD :: proc(pPluginContext : LPVOID, pwszPassword : PCWSTR);

 PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE :: proc(pPluginContext : LPVOID, pbData : PBYTE);

 PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER :: proc(pPluginContext : LPVOID, pIdentifier : PCRYPT_DATA_BLOB);

 CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE :: struct {
    cbSize            : u32,
    pfnGet            : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET,
    pfnRelease        : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE,
    pfnFreePassword   : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD,
    pfnFree           : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE,
    pfnFreeIdentifier : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER,
 };
 PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE :: ^struct {
    cbSize            : u32,
    pfnGet            : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET,
    pfnRelease        : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE,
    pfnFreePassword   : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD,
    pfnFree           : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE,
    pfnFreeIdentifier : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER,
 };

 PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE :: (proc(pfnFlush : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH, pContext : LPVOID, pdwExpectedObjectCount : ^u32, ppFuncTable : ^PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE, ppPluginContext : ^rawptr) -> BOOL);

 PFN_CERT_IS_WEAK_HASH :: (proc(dwHashUseType : u32, pwszCNGHashAlgid : LPCWSTR, dwChainFlags : u32, pSignerChainContext : PCCERT_CHAIN_CONTEXT, pTimeStamp : LPFILETIME, pwszFileName : LPCWSTR) -> BOOL);

 CRYPTPROTECT_PROMPTSTRUCT :: struct {
    cbSize        : u32,
    dwPromptFlags : u32,
    hwndApp       : HWND,
    szPrompt      : LPCWSTR,
 };
 PCRYPTPROTECT_PROMPTSTRUCT :: ^struct {
    cbSize        : u32,
    dwPromptFlags : u32,
    hwndApp       : HWND,
    szPrompt      : LPCWSTR,
 };

 EFS_CERTIFICATE_BLOB :: struct {
    dwCertEncodingType : u32,
    cbData             : u32,
    pbData             : PBYTE,
 };
 PEFS_CERTIFICATE_BLOB :: ^struct {
    dwCertEncodingType : u32,
    cbData             : u32,
    pbData             : PBYTE,
 };

 EFS_HASH_BLOB :: struct {
    cbData : u32,
    pbData : PBYTE,
 };
 PEFS_HASH_BLOB :: ^struct {
    cbData : u32,
    pbData : PBYTE,
 };

 EFS_RPC_BLOB :: struct {
    cbData : u32,
    pbData : PBYTE,
 };
 PEFS_RPC_BLOB :: ^struct {
    cbData : u32,
    pbData : PBYTE,
 };

 EFS_PIN_BLOB :: struct {
    cbPadding : u32,
    cbData    : u32,
    pbData    : PBYTE,
 };
 PEFS_PIN_BLOB :: ^struct {
    cbPadding : u32,
    cbData    : u32,
    pbData    : PBYTE,
 };

 EFS_KEY_INFO :: struct {
    dwVersion : u32,
    Entropy   : ULONG,
    Algorithm : ALG_ID,
    KeyLength : ULONG,
 };
 PEFS_KEY_INFO :: ^struct {
    dwVersion : u32,
    Entropy   : ULONG,
    Algorithm : ALG_ID,
    KeyLength : ULONG,
 };

 EFS_COMPATIBILITY_INFO :: struct {
    EfsVersion : u32,
 };
 PEFS_COMPATIBILITY_INFO :: ^struct {
    EfsVersion : u32,
 };

 EFS_VERSION_INFO :: struct {
    EfsVersion : u32,
    SubVersion : u32,
 };
 PEFS_VERSION_INFO :: ^struct {
    EfsVersion : u32,
    SubVersion : u32,
 };

 EFS_DECRYPTION_STATUS_INFO :: struct {
    dwDecryptionError : u32,
    dwHashOffset      : u32,
    cbHash            : u32,
 };
 PEFS_DECRYPTION_STATUS_INFO :: ^struct {
    dwDecryptionError : u32,
    dwHashOffset      : u32,
    cbHash            : u32,
 };

 EFS_ENCRYPTION_STATUS_INFO :: struct {
    bHasCurrentKey    : BOOL,
    dwEncryptionError : u32,
 };
 PEFS_ENCRYPTION_STATUS_INFO :: ^struct {
    bHasCurrentKey    : BOOL,
    dwEncryptionError : u32,
 };

 ENCRYPTION_CERTIFICATE :: struct {
    cbTotalLength : u32,
    pUserSid      : ^SID,
    pCertBlob     : PEFS_CERTIFICATE_BLOB,
 };
 PENCRYPTION_CERTIFICATE :: ^struct {
    cbTotalLength : u32,
    pUserSid      : ^SID,
    pCertBlob     : PEFS_CERTIFICATE_BLOB,
 };

 ENCRYPTION_CERTIFICATE_HASH :: struct {
    cbTotalLength        : u32,
    pUserSid             : ^SID,
    pHash                : PEFS_HASH_BLOB,
    lpDisplayInformation : LPWSTR,
 };
 PENCRYPTION_CERTIFICATE_HASH :: ^struct {
    cbTotalLength        : u32,
    pUserSid             : ^SID,
    pHash                : PEFS_HASH_BLOB,
    lpDisplayInformation : LPWSTR,
 };

 ENCRYPTION_CERTIFICATE_HASH_LIST :: struct {
    nCert_Hash : u32,
    pUsers     : ^PENCRYPTION_CERTIFICATE_HASH,
 };
 PENCRYPTION_CERTIFICATE_HASH_LIST :: ^struct {
    nCert_Hash : u32,
    pUsers     : ^PENCRYPTION_CERTIFICATE_HASH,
 };

 ENCRYPTION_CERTIFICATE_LIST :: struct {
    nUsers : u32,
    pUsers : ^PENCRYPTION_CERTIFICATE,
 };
 PENCRYPTION_CERTIFICATE_LIST :: ^struct {
    nUsers : u32,
    pUsers : ^PENCRYPTION_CERTIFICATE,
 };

 ENCRYPTED_FILE_METADATA_SIGNATURE :: struct {
    dwEfsAccessType        : u32,
    pCertificatesAdded     : PENCRYPTION_CERTIFICATE_HASH_LIST,
    pEncryptionCertificate : PENCRYPTION_CERTIFICATE,
    pEfsStreamSignature    : PEFS_RPC_BLOB,
 };
 PENCRYPTED_FILE_METADATA_SIGNATURE :: ^struct {
    dwEfsAccessType        : u32,
    pCertificatesAdded     : PENCRYPTION_CERTIFICATE_HASH_LIST,
    pEncryptionCertificate : PENCRYPTION_CERTIFICATE,
    pEfsStreamSignature    : PEFS_RPC_BLOB,
 };

 ENCRYPTION_PROTECTOR :: struct {
    cbTotalLength         : u32,
    pUserSid              : ^SID,
    lpProtectorDescriptor : LPWSTR,
 };
 PENCRYPTION_PROTECTOR :: ^struct {
    cbTotalLength         : u32,
    pUserSid              : ^SID,
    lpProtectorDescriptor : LPWSTR,
 };

 ENCRYPTION_PROTECTOR_LIST :: struct {
    nProtectors : u32,
    pProtectors : ^PENCRYPTION_PROTECTOR,
 };
 PENCRYPTION_PROTECTOR_LIST :: ^struct {
    nProtectors : u32,
    pProtectors : ^PENCRYPTION_PROTECTOR,
 };

 RPC_IMPORT_CONTEXT_P :: struct {
    LookupContext  : RPC_NS_HANDLE,
    ProposedHandle : RPC_BINDING_HANDLE,
    Bindings       : ^RPC_BINDING_VECTOR,
 };
 PRPC_IMPORT_CONTEXT_P :: ^struct {
    LookupContext  : RPC_NS_HANDLE,
    ProposedHandle : RPC_BINDING_HANDLE,
    Bindings       : ^RPC_BINDING_VECTOR,
 };

 byte :: u8;

 cs_byte :: byte;

 boolean :: u8;

 hyper :: f64;

 MIDL_uhyper :: f64;

 NDR_CCONTEXT :: rawptr;

 NDR_SCONTEXT :: ^struct {
    pad         : [2]rawptr,
    userContext : rawptr,
 };

 NDR_RUNDOWN :: proc(context_ : rawptr);

 NDR_NOTIFY_ROUTINE :: proc(void);

 NDR_NOTIFY2_ROUTINE :: proc(flag : boolean);

 SCONTEXT_QUEUE :: struct {
    NumberOfObjects : u64,
    ArrayOfObjects  : ^NDR_SCONTEXT,
 };
 PSCONTEXT_QUEUE :: ^struct {
    NumberOfObjects : u64,
    ArrayOfObjects  : ^NDR_SCONTEXT,
 };

 error_status_t :: u64;

 RPC_BUFPTR :: cstring;

 RPC_LENGTH :: u64;

 EXPR_EVAL :: proc(^MIDL_STUB_MESSAGE);

 PFORMAT_STRING :: cstring;

 ARRAY_INFO :: struct {
    Dimension             : i64,
    BufferConformanceMark : ^u64,
    BufferVarianceMark    : ^u64,
    MaxCountArray         : ^u64,
    OffsetArray           : ^u64,
    ActualCountArray      : ^u64,
 };
 PARRAY_INFO :: ^struct {
    Dimension             : i64,
    BufferConformanceMark : ^u64,
    BufferVarianceMark    : ^u64,
    MaxCountArray         : ^u64,
    OffsetArray           : ^u64,
    ActualCountArray      : ^u64,
 };

 _NDR_ASYNC_MESSAGE :: struct {};

 PNDR_ASYNC_MESSAGE :: ^_NDR_ASYNC_MESSAGE;

 _NDR_CORRELATION_INFO :: struct {};

 PNDR_CORRELATION_INFO :: ^_NDR_CORRELATION_INFO;

 PFORMAT_STRING :: cstring;

 MIDL_SYNTAX_INFO :: struct {};

 PMIDL_SYNTAX_INFO :: ^MIDL_SYNTAX_INFO;

 NDR_ALLOC_ALL_NODES_CONTEXT :: struct {};

 NDR_POINTER_QUEUE_STATE :: struct {};

 _NDR_PROC_CONTEXT :: struct {};

 MIDL_STUB_MESSAGE :: struct {
    RpcMsg                     : PRPC_MESSAGE,
    Buffer                     : cstring,
    BufferStart                : cstring,
    BufferEnd                  : cstring,
    BufferMark                 : cstring,
    BufferLength               : u64,
    MemorySize                 : u64,
    Memory                     : cstring,
    IsClient                   : u8,
    Pad                        : u8,
    uFlags2                    : u16,
    ReuseBuffer                : i32,
    pAllocAllNodesContext      : ^NDR_ALLOC_ALL_NODES_CONTEXT,
    pPointerQueueState         : ^NDR_POINTER_QUEUE_STATE,
    IgnoreEmbeddedPointers     : i32,
    PointerBufferMark          : cstring,
    CorrDespIncrement          : u8,
    uFlags                     : u8,
    UniquePtrCount             : u16,
    MaxCount                   : ULONG_PTR,
    Offset                     : u64,
    ActualCount                : u64,
    pfnAllocate                : (proc(uint) -> rawptr),
    pfnFree                    : proc(rawptr),
    StackTop                   : cstring,
    pPresentedType             : cstring,
    pTransmitType              : cstring,
    SavedHandle                : handle_t,
    StubDesc                   : ^MIDL_STUB_DESC,
    FullPtrXlatTables          : ^FULL_PTR_XLAT_TABLES,
    FullPtrRefId               : u64,
    PointerLength              : u64,
    fInDontFree                : ,
    fDontCallFreeInst          : ,
    fUnused1                   : ,
    fHasReturn                 : ,
    fHasExtensions             : ,
    fHasNewCorrDesc            : ,
    fIsIn                      : ,
    fIsOut                     : ,
    fIsOicf                    : ,
    fBufferValid               : ,
    fHasMemoryValidateCallback : ,
    fInFree                    : ,
    fNeedMCCP                  : ,
    fUnused2                   : ,
    fUnused3                   : ,
    dwDestContext              : u64,
    pvDestContext              : rawptr,
    SavedContextHandles        : ^NDR_SCONTEXT,
    ParamNumber                : i64,
    pRpcChannelBuffer          : ^IRpcChannelBuffer,
    pArrayInfo                 : PARRAY_INFO,
    SizePtrCountArray          : ^u64,
    SizePtrOffsetArray         : ^u64,
    SizePtrLengthArray         : ^u64,
    pArgQueue                  : rawptr,
    dwStubPhase                : u64,
    LowStackMark               : rawptr,
    pAsyncMsg                  : PNDR_ASYNC_MESSAGE,
    pCorrInfo                  : PNDR_CORRELATION_INFO,
    pCorrMemory                : cstring,
    pMemoryList                : rawptr,
    pCSInfo                    : INT_PTR,
    ConformanceMark            : cstring,
    VarianceMark               : cstring,
    Unused                     : INT_PTR,
    pContext                   : ^_NDR_PROC_CONTEXT,
    ContextHandleHash          : rawptr,
    pUserMarshalList           : rawptr,
    Reserved51_3               : INT_PTR,
    Reserved51_4               : INT_PTR,
    Reserved51_5               : INT_PTR,
 };
 PMIDL_STUB_MESSAGE :: ^struct {
    RpcMsg                     : PRPC_MESSAGE,
    Buffer                     : cstring,
    BufferStart                : cstring,
    BufferEnd                  : cstring,
    BufferMark                 : cstring,
    BufferLength               : u64,
    MemorySize                 : u64,
    Memory                     : cstring,
    IsClient                   : u8,
    Pad                        : u8,
    uFlags2                    : u16,
    ReuseBuffer                : i32,
    pAllocAllNodesContext      : ^NDR_ALLOC_ALL_NODES_CONTEXT,
    pPointerQueueState         : ^NDR_POINTER_QUEUE_STATE,
    IgnoreEmbeddedPointers     : i32,
    PointerBufferMark          : cstring,
    CorrDespIncrement          : u8,
    uFlags                     : u8,
    UniquePtrCount             : u16,
    MaxCount                   : ULONG_PTR,
    Offset                     : u64,
    ActualCount                : u64,
    pfnAllocate                : (proc(uint) -> rawptr),
    pfnFree                    : proc(rawptr),
    StackTop                   : cstring,
    pPresentedType             : cstring,
    pTransmitType              : cstring,
    SavedHandle                : handle_t,
    StubDesc                   : ^MIDL_STUB_DESC,
    FullPtrXlatTables          : ^FULL_PTR_XLAT_TABLES,
    FullPtrRefId               : u64,
    PointerLength              : u64,
    fInDontFree                : ,
    fDontCallFreeInst          : ,
    fUnused1                   : ,
    fHasReturn                 : ,
    fHasExtensions             : ,
    fHasNewCorrDesc            : ,
    fIsIn                      : ,
    fIsOut                     : ,
    fIsOicf                    : ,
    fBufferValid               : ,
    fHasMemoryValidateCallback : ,
    fInFree                    : ,
    fNeedMCCP                  : ,
    fUnused2                   : ,
    fUnused3                   : ,
    dwDestContext              : u64,
    pvDestContext              : rawptr,
    SavedContextHandles        : ^NDR_SCONTEXT,
    ParamNumber                : i64,
    pRpcChannelBuffer          : ^IRpcChannelBuffer,
    pArrayInfo                 : PARRAY_INFO,
    SizePtrCountArray          : ^u64,
    SizePtrOffsetArray         : ^u64,
    SizePtrLengthArray         : ^u64,
    pArgQueue                  : rawptr,
    dwStubPhase                : u64,
    LowStackMark               : rawptr,
    pAsyncMsg                  : PNDR_ASYNC_MESSAGE,
    pCorrInfo                  : PNDR_CORRELATION_INFO,
    pCorrMemory                : cstring,
    pMemoryList                : rawptr,
    pCSInfo                    : INT_PTR,
    ConformanceMark            : cstring,
    VarianceMark               : cstring,
    Unused                     : INT_PTR,
    pContext                   : ^_NDR_PROC_CONTEXT,
    ContextHandleHash          : rawptr,
    pUserMarshalList           : rawptr,
    Reserved51_3               : INT_PTR,
    Reserved51_4               : INT_PTR,
    Reserved51_5               : INT_PTR,
 };

 MIDL_STUB_MESSAGE :: struct {};

 PMIDL_STUB_MESSAGE :: ^MIDL_STUB_MESSAGE;

 GENERIC_BINDING_ROUTINE :: (proc(rawptr) -> rawptr);

 GENERIC_UNBIND_ROUTINE :: proc(rawptr, cstring);

 GENERIC_BINDING_ROUTINE_PAIR :: struct {
    pfnBind   : GENERIC_BINDING_ROUTINE,
    pfnUnbind : GENERIC_UNBIND_ROUTINE,
 };
 PGENERIC_BINDING_ROUTINE_PAIR :: ^struct {
    pfnBind   : GENERIC_BINDING_ROUTINE,
    pfnUnbind : GENERIC_UNBIND_ROUTINE,
 };

 GENERIC_BINDING_INFO :: struct {
    pObj      : rawptr,
    Size      : u32,
    pfnBind   : GENERIC_BINDING_ROUTINE,
    pfnUnbind : GENERIC_UNBIND_ROUTINE,
 };
 PGENERIC_BINDING_INFO :: ^struct {
    pObj      : rawptr,
    Size      : u32,
    pfnBind   : GENERIC_BINDING_ROUTINE,
    pfnUnbind : GENERIC_UNBIND_ROUTINE,
 };

 XMIT_HELPER_ROUTINE :: proc(PMIDL_STUB_MESSAGE);

 XMIT_ROUTINE_QUINTUPLE :: struct {
    pfnTranslateToXmit   : XMIT_HELPER_ROUTINE,
    pfnTranslateFromXmit : XMIT_HELPER_ROUTINE,
    pfnFreeXmit          : XMIT_HELPER_ROUTINE,
    pfnFreeInst          : XMIT_HELPER_ROUTINE,
 };
 PXMIT_ROUTINE_QUINTUPLE :: ^struct {
    pfnTranslateToXmit   : XMIT_HELPER_ROUTINE,
    pfnTranslateFromXmit : XMIT_HELPER_ROUTINE,
    pfnFreeXmit          : XMIT_HELPER_ROUTINE,
    pfnFreeInst          : XMIT_HELPER_ROUTINE,
 };

 USER_MARSHAL_SIZING_ROUTINE :: (proc(^u64, u64, rawptr) -> u64);

 USER_MARSHAL_MARSHALLING_ROUTINE :: (proc(^u64, cstring, rawptr) -> cstring);

 USER_MARSHAL_UNMARSHALLING_ROUTINE :: (proc(^u64, cstring, rawptr) -> cstring);

 USER_MARSHAL_FREEING_ROUTINE :: proc(^u64, rawptr);

 USER_MARSHAL_ROUTINE_QUADRUPLE :: struct {
    pfnBufferSize : USER_MARSHAL_SIZING_ROUTINE,
    pfnMarshall   : USER_MARSHAL_MARSHALLING_ROUTINE,
    pfnUnmarshall : USER_MARSHAL_UNMARSHALLING_ROUTINE,
    pfnFree       : USER_MARSHAL_FREEING_ROUTINE,
 };

 USER_MARSHAL_CB_TYPE :: enum {
    USER_MARSHAL_CB_BUFFER_SIZE,
    USER_MARSHAL_CB_MARSHALL,
    USER_MARSHAL_CB_UNMARSHALL,
    USER_MARSHAL_CB_FREE,
 };

 USER_MARSHAL_CB :: struct {
    Flags       : u64,
    pStubMsg    : PMIDL_STUB_MESSAGE,
    pReserve    : PFORMAT_STRING,
    Signature   : u64,
    CBType      : USER_MARSHAL_CB_TYPE,
    pFormat     : PFORMAT_STRING,
    pTypeFormat : PFORMAT_STRING,
 };

 MALLOC_FREE_STRUCT :: struct {
    pfnAllocate : (proc(uint) -> rawptr),
    pfnFree     : proc(rawptr),
 };

 COMM_FAULT_OFFSETS :: struct {
    CommOffset  : i16,
    FaultOffset : i16,
 };

 IDL_CS_CONVERT :: enum {
    IDL_CS_NO_CONVERT,
    IDL_CS_IN_PLACE_CONVERT,
    IDL_CS_NEW_BUFFER_CONVERT,
 };

 CS_TYPE_NET_SIZE_ROUTINE :: proc(hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : u64, ulLocalBufferSize : u64, conversionType : ^IDL_CS_CONVERT, pulNetworkBufferSize : ^u64, pStatus : ^error_status_t);

 CS_TYPE_LOCAL_SIZE_ROUTINE :: proc(hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : u64, ulNetworkBufferSize : u64, conversionType : ^IDL_CS_CONVERT, pulLocalBufferSize : ^u64, pStatus : ^error_status_t);

 CS_TYPE_TO_NETCS_ROUTINE :: proc(hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : u64, pLocalData : rawptr, ulLocalDataLength : u64, pNetworkData : ^byte, pulNetworkDataLength : ^u64, pStatus : ^error_status_t);

 CS_TYPE_FROM_NETCS_ROUTINE :: proc(hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : u64, pNetworkData : ^byte, ulNetworkDataLength : u64, ulLocalBufferSize : u64, pLocalData : rawptr, pulLocalDataLength : ^u64, pStatus : ^error_status_t);

 CS_TAG_GETTING_ROUTINE :: proc(hBinding : RPC_BINDING_HANDLE, fServerSide : i32, pulSendingTag : ^u64, pulDesiredReceivingTag : ^u64, pulReceivingTag : ^u64, pStatus : ^error_status_t);

 NDR_CS_SIZE_CONVERT_ROUTINES :: struct {
    pfnNetSize   : CS_TYPE_NET_SIZE_ROUTINE,
    pfnToNetCs   : CS_TYPE_TO_NETCS_ROUTINE,
    pfnLocalSize : CS_TYPE_LOCAL_SIZE_ROUTINE,
    pfnFromNetCs : CS_TYPE_FROM_NETCS_ROUTINE,
 };

 NDR_CS_ROUTINES :: struct {
    pSizeConvertRoutines : ^NDR_CS_SIZE_CONVERT_ROUTINES,
    pTagGettingRoutines  : ^CS_TAG_GETTING_ROUTINE,
 };

 NDR_EXPR_DESC :: struct {
    pOffset     : ^u16,
    pFormatExpr : PFORMAT_STRING,
 };

 MIDL_STUB_DESC :: struct {
    RpcInterfaceInformation     : rawptr,
    pfnAllocate                 : (proc(uint) -> rawptr),
    pfnFree                     : proc(rawptr),
    IMPLICIT_HANDLE_INFO : struct #raw_union {
        pAutoHandle         : ^handle_t,
        pPrimitiveHandle    : ^handle_t,
        pGenericBindingInfo : PGENERIC_BINDING_INFO,
    },
    apfnNdrRundownRoutines      : ^NDR_RUNDOWN,
    aGenericBindingRoutinePairs : ^GENERIC_BINDING_ROUTINE_PAIR,
    apfnExprEval                : ^EXPR_EVAL,
    aXmitQuintuple              : ^XMIT_ROUTINE_QUINTUPLE,
    pFormatTypes                : cstring,
    fCheckBounds                : i32,
    Version                     : u64,
    pMallocFreeStruct           : ^MALLOC_FREE_STRUCT,
    MIDLVersion                 : i64,
    CommFaultOffsets            : ^COMM_FAULT_OFFSETS,
    aUserMarshalQuadruple       : ^USER_MARSHAL_ROUTINE_QUADRUPLE,
    NotifyRoutineTable          : ^NDR_NOTIFY_ROUTINE,
    mFlags                      : ULONG_PTR,
    CsRoutineTables             : ^NDR_CS_ROUTINES,
    ProxyServerInfo             : rawptr,
    pExprInfo                   : ^NDR_EXPR_DESC,
 };

 PMIDL_STUB_DESC :: ^MIDL_STUB_DESC;

 PMIDL_XMIT_TYPE :: rawptr;

 STUB_THUNK :: proc(PMIDL_STUB_MESSAGE);

 SERVER_ROUTINE :: (proc() -> i64);

 MIDL_METHOD_PROPERTY :: struct {
    Id    : u64,
    Value : ULONG_PTR,
 };
 PMIDL_METHOD_PROPERTY :: ^struct {
    Id    : u64,
    Value : ULONG_PTR,
 };

 MIDL_METHOD_PROPERTY_MAP :: struct {
    Count      : u64,
    Properties : ^MIDL_METHOD_PROPERTY,
 };
 PMIDL_METHOD_PROPERTY_MAP :: ^struct {
    Count      : u64,
    Properties : ^MIDL_METHOD_PROPERTY,
 };

 MIDL_INTERFACE_METHOD_PROPERTIES :: struct {
    MethodCount      : u16,
    MethodProperties : ^^MIDL_METHOD_PROPERTY_MAP,
 };

 MIDL_SERVER_INFO :: struct {
    pStubDesc       : PMIDL_STUB_DESC,
    DispatchTable   : ^SERVER_ROUTINE,
    ProcString      : PFORMAT_STRING,
    FmtStringOffset : ^u16,
    ThunkTable      : ^STUB_THUNK,
    pTransferSyntax : PRPC_SYNTAX_IDENTIFIER,
    nCount          : ULONG_PTR,
    pSyntaxInfo     : PMIDL_SYNTAX_INFO,
 };
 PMIDL_SERVER_INFO :: ^struct {
    pStubDesc       : PMIDL_STUB_DESC,
    DispatchTable   : ^SERVER_ROUTINE,
    ProcString      : PFORMAT_STRING,
    FmtStringOffset : ^u16,
    ThunkTable      : ^STUB_THUNK,
    pTransferSyntax : PRPC_SYNTAX_IDENTIFIER,
    nCount          : ULONG_PTR,
    pSyntaxInfo     : PMIDL_SYNTAX_INFO,
 };

 MIDL_STUBLESS_PROXY_INFO :: struct {
    pStubDesc          : PMIDL_STUB_DESC,
    ProcFormatString   : PFORMAT_STRING,
    FormatStringOffset : ^u16,
    pTransferSyntax    : PRPC_SYNTAX_IDENTIFIER,
    nCount             : ULONG_PTR,
    pSyntaxInfo        : PMIDL_SYNTAX_INFO,
 };

 PMIDL_STUBLESS_PROXY_INFO :: ^MIDL_STUBLESS_PROXY_INFO;

 MIDL_SYNTAX_INFO :: struct {
    TransferSyntax        : RPC_SYNTAX_IDENTIFIER,
    DispatchTable         : ^RPC_DISPATCH_TABLE,
    ProcString            : PFORMAT_STRING,
    FmtStringOffset       : ^u16,
    TypeString            : PFORMAT_STRING,
    aUserMarshalQuadruple : rawptr,
    pMethodProperties     : ^MIDL_INTERFACE_METHOD_PROPERTIES,
    pReserved2            : ULONG_PTR,
 };
 PMIDL_SYNTAX_INFO :: ^struct {
    TransferSyntax        : RPC_SYNTAX_IDENTIFIER,
    DispatchTable         : ^RPC_DISPATCH_TABLE,
    ProcString            : PFORMAT_STRING,
    FmtStringOffset       : ^u16,
    TypeString            : PFORMAT_STRING,
    aUserMarshalQuadruple : rawptr,
    pMethodProperties     : ^MIDL_INTERFACE_METHOD_PROPERTIES,
    pReserved2            : ULONG_PTR,
 };

 PARAM_OFFSETTABLE :: ^u16;
 PPARAM_OFFSETTABLE :: ^u16;

 CLIENT_CALL_RETURN :: struct #raw_union {
    Pointer : rawptr,
    Simple  : LONG_PTR,
 };

 XLAT_SIDE :: enum {
    XLAT_SERVER = 1,
    XLAT_CLIENT,
 };

 FULL_PTR_XLAT_TABLES :: struct {
    RefIdToPointer : rawptr,
    PointerToRefId : rawptr,
    NextRefId      : u64,
    XlatSide       : XLAT_SIDE,
 };
 PFULL_PTR_XLAT_TABLES :: ^struct {
    RefIdToPointer : rawptr,
    PointerToRefId : rawptr,
    NextRefId      : u64,
    XlatSide       : XLAT_SIDE,
 };

 system_handle_t :: enum {
    SYSTEM_HANDLE_FILE = 0,
    SYSTEM_HANDLE_SEMAPHORE = 1,
    SYSTEM_HANDLE_EVENT = 2,
    SYSTEM_HANDLE_MUTEX = 3,
    SYSTEM_HANDLE_PROCESS = 4,
    SYSTEM_HANDLE_TOKEN = 5,
    SYSTEM_HANDLE_SECTION = 6,
    SYSTEM_HANDLE_REG_KEY = 7,
    SYSTEM_HANDLE_THREAD = 8,
    SYSTEM_HANDLE_COMPOSITION_OBJECT = 9,
    SYSTEM_HANDLE_SOCKET = 10,
    SYSTEM_HANDLE_JOB = 11,
    SYSTEM_HANDLE_PIPE = 12,
    SYSTEM_HANDLE_MAX = 12,
    SYSTEM_HANDLE_INVALID = 0xFF,
 };

 _ :: enum #export {enum {
    MidlInterceptionInfoVersionOne = 1,
 };

 _ :: enum #export {enum {
    MidlWinrtTypeSerializationInfoVersionOne = 1,
 };

 MIDL_INTERCEPTION_INFO :: struct {
    Version               : u64,
    ProcString            : PFORMAT_STRING,
    ProcFormatOffsetTable : ^u16,
    ProcCount             : u64,
    TypeString            : PFORMAT_STRING,
 };
 PMIDL_INTERCEPTION_INFO :: ^struct {
    Version               : u64,
    ProcString            : PFORMAT_STRING,
    ProcFormatOffsetTable : ^u16,
    ProcCount             : u64,
    TypeString            : PFORMAT_STRING,
 };

 MIDL_WINRT_TYPE_SERIALIZATION_INFO :: struct {
    Version          : u64,
    TypeFormatString : PFORMAT_STRING,
    FormatStringSize : u16,
    TypeOffset       : u16,
    StubDesc         : PMIDL_STUB_DESC,
 };
 PMIDL_WINRT_TYPE_SERIALIZATION_INFO :: ^struct {
    Version          : u64,
    TypeFormatString : PFORMAT_STRING,
    FormatStringSize : u16,
    TypeOffset       : u16,
    StubDesc         : PMIDL_STUB_DESC,
 };

 STUB_PHASE :: enum {
    STUB_UNMARSHAL,
    STUB_CALL_SERVER,
    STUB_MARSHAL,
    STUB_CALL_SERVER_NO_HRESULT,
 };

 PROXY_PHASE :: enum {
    PROXY_CALCSIZE,
    PROXY_GETBUFFER,
    PROXY_MARSHAL,
    PROXY_SENDRECEIVE,
    PROXY_UNMARSHAL,
 };

 IRpcStubBuffer :: struct {};

 RPC_SS_THREAD_HANDLE :: rawptr;

 RPC_CLIENT_ALLOC :: #type (proc(Size : uint) -> rawptr);

 RPC_CLIENT_FREE :: #type proc(Ptr : rawptr);

 NDR_USER_MARSHAL_INFO_LEVEL1 :: struct {
    Buffer            : rawptr,
    BufferSize        : u64,
    pfnAllocate       : (proc(uint) -> rawptr),
    pfnFree           : proc(rawptr),
    pRpcChannelBuffer : ^IRpcChannelBuffer,
    Reserved          : [5]ULONG_PTR,
 };

 NDR_USER_MARSHAL_INFO :: struct {
    InformationLevel : u64,
    u : struct #raw_union {
        Level1 : NDR_USER_MARSHAL_INFO_LEVEL1,
    },
 };

 OLECHAR :: WCHAR;

 LPOLESTR :: ^OLECHAR;

 LPCOLESTR :: ^OLECHAR;

 UCHAR :: u8;

 SHORT :: i16;

 USHORT :: u16;

 ULONG :: u32;

 DOUBLE :: f64;

 COAUTHIDENTITY :: struct {
    User           : ^USHORT,
    UserLength     : ULONG,
    Domain         : ^USHORT,
    DomainLength   : ULONG,
    Password       : ^USHORT,
    PasswordLength : ULONG,
    Flags          : ULONG,
 };

 COAUTHINFO :: struct {
    dwAuthnSvc           : u32,
    dwAuthzSvc           : u32,
    pwszServerPrincName  : LPWSTR,
    dwAuthnLevel         : u32,
    dwImpersonationLevel : u32,
    pAuthIdentityData    : ^COAUTHIDENTITY,
    dwCapabilities       : u32,
 };

 SCODE :: LONG;

 PSCODE :: ^SCODE;

 MEMCTX :: enum {
    MEMCTX_TASK = 1,
    MEMCTX_SHARED = 2,
    MEMCTX_MACSYSTEM = 3,
    MEMCTX_UNKNOWN = -1,
    MEMCTX_SAME = -2,
 };

 CLSCTX :: enum {
    CLSCTX_INPROC_SERVER = 0x1,
    CLSCTX_INPROC_HANDLER = 0x2,
    CLSCTX_LOCAL_SERVER = 0x4,
    CLSCTX_INPROC_SERVER16 = 0x8,
    CLSCTX_REMOTE_SERVER = 0x10,
    CLSCTX_INPROC_HANDLER16 = 0x20,
    CLSCTX_RESERVED1 = 0x40,
    CLSCTX_RESERVED2 = 0x80,
    CLSCTX_RESERVED3 = 0x100,
    CLSCTX_RESERVED4 = 0x200,
    CLSCTX_NO_CODE_DOWNLOAD = 0x400,
    CLSCTX_RESERVED5 = 0x800,
    CLSCTX_NO_CUSTOM_MARSHAL = 0x1000,
    CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000,
    CLSCTX_NO_FAILURE_LOG = 0x4000,
    CLSCTX_DISABLE_AAA = 0x8000,
    CLSCTX_ENABLE_AAA = 0x10000,
    CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000,
    CLSCTX_ACTIVATE_X86_SERVER = 0x40000,
    CLSCTX_ACTIVATE_32_BIT_SERVER =     CLSCTX_ACTIVATE_X86_SERVER,
    CLSCTX_ACTIVATE_64_BIT_SERVER = 0x80000,
    CLSCTX_ENABLE_CLOAKING = 0x100000,
    CLSCTX_APPCONTAINER = 0x400000,
    CLSCTX_ACTIVATE_AAA_AS_IU = 0x800000,
    CLSCTX_RESERVED6 = 0x1000000,
    CLSCTX_ACTIVATE_ARM32_SERVER = 0x2000000,
    CLSCTX_PS_DLL = 0x80000000,
 };

 MSHLFLAGS :: enum {
    MSHLFLAGS_NORMAL = 0,
    MSHLFLAGS_TABLESTRONG = 1,
    MSHLFLAGS_TABLEWEAK = 2,
    MSHLFLAGS_NOPING = 4,
    MSHLFLAGS_RESERVED1 = 8,
    MSHLFLAGS_RESERVED2 = 16,
    MSHLFLAGS_RESERVED3 = 32,
    MSHLFLAGS_RESERVED4 = 64,
 };

 MSHCTX :: enum {
    MSHCTX_LOCAL = 0,
    MSHCTX_NOSHAREDMEM = 1,
    MSHCTX_DIFFERENTMACHINE = 2,
    MSHCTX_INPROC = 3,
    MSHCTX_CROSSCTX = 4,
    MSHCTX_RESERVED1 = 5,
 };

 BYTE_BLOB :: struct {
    clSize : ULONG,
    abData : [1]byte,
 };

 UP_BYTE_BLOB :: ^BYTE_BLOB;

 WORD_BLOB :: struct {
    clSize : ULONG,
    asData : [1]u16,
 };

 UP_WORD_BLOB :: ^WORD_BLOB;

 DWORD_BLOB :: struct {
    clSize : ULONG,
    alData : [1]ULONG,
 };

 UP_DWORD_BLOB :: ^DWORD_BLOB;

 FLAGGED_BYTE_BLOB :: struct {
    fFlags : ULONG,
    clSize : ULONG,
    abData : [1]byte,
 };

 UP_FLAGGED_BYTE_BLOB :: ^FLAGGED_BYTE_BLOB;

 FLAGGED_WORD_BLOB :: struct {
    fFlags : ULONG,
    clSize : ULONG,
    asData : [1]u16,
 };

 UP_FLAGGED_WORD_BLOB :: ^FLAGGED_WORD_BLOB;

 BYTE_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^byte,
 };

 WORD_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^u16,
 };

 DWORD_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^ULONG,
 };

 HYPER_SIZEDARR :: struct {
    clSize : ULONG,
    pData  : ^hyper,
 };

 BOOLEAN :: boolean;

 BLOB :: struct {
    cbSize    : ULONG,
    pBlobData : ^BYTE,
 };

 LPBLOB :: ^BLOB;

 RemHGLOBAL :: struct {
    fNullHGlobal : LONG,
    cbData       : ULONG,
    data         : [1]byte,
 };

 RemHMETAFILEPICT :: struct {
    mm     : LONG,
    xExt   : LONG,
    yExt   : LONG,
    cbData : ULONG,
    data   : [1]byte,
 };

 RemHENHMETAFILE :: struct {
    cbData : ULONG,
    data   : [1]byte,
 };

 RemHBITMAP :: struct {
    cbData : ULONG,
    data   : [1]byte,
 };

 RemHPALETTE :: struct {
    cbData : ULONG,
    data   : [1]byte,
 };

 RemHBRUSH :: struct {
    cbData : ULONG,
    data   : [1]byte,
 };

 DVASPECT :: enum {
    DVASPECT_CONTENT = 1,
    DVASPECT_THUMBNAIL = 2,
    DVASPECT_ICON = 4,
    DVASPECT_DOCPRINT = 8,
 };

 STGC :: enum {
    STGC_DEFAULT = 0,
    STGC_OVERWRITE = 1,
    STGC_ONLYIFCURRENT = 2,
    STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE = 4,
    STGC_CONSOLIDATE = 8,
 };

 STGMOVE :: enum {
    STGMOVE_MOVE = 0,
    STGMOVE_COPY = 1,
    STGMOVE_SHALLOWCOPY = 2,
 };

 STATFLAG :: enum {
    STATFLAG_DEFAULT = 0,
    STATFLAG_NONAME = 1,
    STATFLAG_NOOPEN = 2,
 };

 HCONTEXT :: rawptr;

 LCID :: u32;

 LANGID :: USHORT;

 userCLIPFORMAT :: struct {
    fContext : LONG,
    u : struct #raw_union {
        dwValue  : u32,
        pwszName : ^u16,
    },
 };

 wireCLIPFORMAT :: ^userCLIPFORMAT;

 CLIPFORMAT :: u16;

 GDI_NONREMOTE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc : LONG,
        hRemote : ^DWORD_BLOB,
    },
 };

 userHGLOBAL :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^FLAGGED_BYTE_BLOB,
        hInproc64 : i64,
    },
 };

 wireHGLOBAL :: ^userHGLOBAL;

 userHMETAFILE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^BYTE_BLOB,
        hInproc64 : i64,
    },
 };

 remoteMETAFILEPICT :: struct {
    mm   : LONG,
    xExt : LONG,
    yExt : LONG,
    hMF  : ^userHMETAFILE,
 };

 userHMETAFILEPICT :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^remoteMETAFILEPICT,
        hInproc64 : i64,
    },
 };

 userHENHMETAFILE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^BYTE_BLOB,
        hInproc64 : i64,
    },
 };

 userBITMAP :: struct {
    bmType       : LONG,
    bmWidth      : LONG,
    bmHeight     : LONG,
    bmWidthBytes : LONG,
    bmPlanes     : u16,
    bmBitsPixel  : u16,
    cbSize       : ULONG,
    pBuffer      : [1]byte,
 };

 userHBITMAP :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^userBITMAP,
        hInproc64 : i64,
    },
 };

 userHPALETTE :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc   : LONG,
        hRemote   : ^LOGPALETTE,
        hInproc64 : i64,
    },
 };

 RemotableHandle :: struct {
    fContext : LONG,
    u : struct #raw_union {
        hInproc : LONG,
        hRemote : LONG,
    },
 };

 wireHWND :: ^RemotableHandle;

 wireHMENU :: ^RemotableHandle;

 wireHACCEL :: ^RemotableHandle;

 wireHBRUSH :: ^RemotableHandle;

 wireHFONT :: ^RemotableHandle;

 wireHDC :: ^RemotableHandle;

 wireHICON :: ^RemotableHandle;

 wireHRGN :: ^RemotableHandle;

 wireHMONITOR :: ^RemotableHandle;

 wireHBITMAP :: ^userHBITMAP;

 wireHPALETTE :: ^userHPALETTE;

 wireHENHMETAFILE :: ^userHENHMETAFILE;

 wireHMETAFILE :: ^userHMETAFILE;

 wireHMETAFILEPICT :: ^userHMETAFILEPICT;

 HMETAFILEPICT :: rawptr;

 DATE :: f64;

 CY :: struct #raw_union {
    s : struct {
        Lo : ULONG,
        Hi : LONG,
    },
    int64 : LONGLONG,
 };

 LPCY :: ^CY;

 DECIMAL :: struct {
    wReserved : USHORT,
    u : struct #raw_union {
        s : struct {
            scale : BYTE,
            sign  : BYTE,
        },
        signscale : USHORT,
    },
    Hi32      : ULONG,
    u2 : struct #raw_union {
        s2 : struct {
            Lo32  : ULONG,
            Mid32 : ULONG,
        },
        Lo64 : ULONGLONG,
    },
 };

 LPDECIMAL :: ^DECIMAL;

 wireBSTR :: ^FLAGGED_WORD_BLOB;

 BSTR :: ^OLECHAR;

 LPBSTR :: ^BSTR;

 VARIANT_BOOL :: i16;

 BSTRBLOB :: struct {
    cbSize : ULONG,
    pData  : ^BYTE,
 };

 LPBSTRBLOB :: ^BSTRBLOB;

 CLIPDATA :: struct {
    cbSize    : ULONG,
    ulClipFmt : LONG,
    pClipData : ^BYTE,
 };

 VARTYPE :: u16;

 VARENUM :: enum {
    VT_EMPTY = 0,
    VT_NULL = 1,
    VT_I2 = 2,
    VT_I4 = 3,
    VT_R4 = 4,
    VT_R8 = 5,
    VT_CY = 6,
    VT_DATE = 7,
    VT_BSTR = 8,
    VT_DISPATCH = 9,
    VT_ERROR = 10,
    VT_BOOL = 11,
    VT_VARIANT = 12,
    VT_UNKNOWN = 13,
    VT_DECIMAL = 14,
    VT_I1 = 16,
    VT_UI1 = 17,
    VT_UI2 = 18,
    VT_UI4 = 19,
    VT_I8 = 20,
    VT_UI8 = 21,
    VT_INT = 22,
    VT_UINT = 23,
    VT_VOID = 24,
    VT_HRESULT = 25,
    VT_PTR = 26,
    VT_SAFEARRAY = 27,
    VT_CARRAY = 28,
    VT_USERDEFINED = 29,
    VT_LPSTR = 30,
    VT_LPWSTR = 31,
    VT_RECORD = 36,
    VT_INT_PTR = 37,
    VT_UINT_PTR = 38,
    VT_FILETIME = 64,
    VT_BLOB = 65,
    VT_STREAM = 66,
    VT_STORAGE = 67,
    VT_STREAMED_OBJECT = 68,
    VT_STORED_OBJECT = 69,
    VT_BLOB_OBJECT = 70,
    VT_CF = 71,
    VT_CLSID = 72,
    VT_VERSIONED_STREAM = 73,
    VT_BSTR_BLOB = 0xfff,
    VT_VECTOR = 0x1000,
    VT_ARRAY = 0x2000,
    VT_BYREF = 0x4000,
    VT_RESERVED = 0x8000,
    VT_ILLEGAL = 0xffff,
    VT_ILLEGALMASKED = 0xfff,
    VT_TYPEMASK = 0xfff,
 };

 PROPID :: ULONG;

 PROPERTYKEY :: struct {
    fmtid : GUID,
    pid   : u32,
 };

 CSPLATFORM :: struct {
    dwPlatformId    : u32,
    dwVersionHi     : u32,
    dwVersionLo     : u32,
    dwProcessorArch : u32,
 };

 QUERYCONTEXT :: struct {
    dwContext   : u32,
    Platform    : CSPLATFORM,
    Locale      : LCID,
    dwVersionHi : u32,
    dwVersionLo : u32,
 };

 TYSPEC :: enum {
    TYSPEC_CLSID = 0,
    TYSPEC_FILEEXT = (TYSPEC_CLSID + 1),
    TYSPEC_MIMETYPE = (TYSPEC_FILEEXT + 1),
    TYSPEC_FILENAME = (TYSPEC_MIMETYPE + 1),
    TYSPEC_PROGID = (TYSPEC_FILENAME + 1),
    TYSPEC_PACKAGENAME = (TYSPEC_PROGID + 1),
    TYSPEC_OBJECTID = (TYSPEC_PACKAGENAME + 1),
 };

 uCLSSPEC :: struct {
    tyspec       : u32,
    tagged_union : struct #raw_union {
        clsid      : CLSID,
        pFileExt   : LPOLESTR,
        pMimeType  : LPOLESTR,
        pProgId    : LPOLESTR,
        pFileName  : LPOLESTR,
        ByName : struct {
            pPackageName : LPOLESTR,
            PolicyId     : GUID,
        },
        ByObjectId : struct {
            ObjectId : GUID,
            PolicyId : GUID,
        },
    },
 };

 STORAGE_HOTPLUG_INFO :: struct {
    Size                     : u32,
    MediaRemovable           : BOOLEAN,
    MediaHotplug             : BOOLEAN,
    DeviceHotplug            : BOOLEAN,
    WriteCacheEnableOverride : BOOLEAN,
 };
 PSTORAGE_HOTPLUG_INFO :: ^struct {
    Size                     : u32,
    MediaRemovable           : BOOLEAN,
    MediaHotplug             : BOOLEAN,
    DeviceHotplug            : BOOLEAN,
    WriteCacheEnableOverride : BOOLEAN,
 };

 STORAGE_DEVICE_NUMBER :: struct {
    DeviceType      : u32,
    DeviceNumber    : u32,
    PartitionNumber : u32,
 };
 PSTORAGE_DEVICE_NUMBER :: ^struct {
    DeviceType      : u32,
    DeviceNumber    : u32,
    PartitionNumber : u32,
 };

 STORAGE_DEVICE_NUMBERS :: struct {
    Version         : u32,
    Size            : u32,
    NumberOfDevices : u32,
    Devices         : [1]STORAGE_DEVICE_NUMBER,
 };
 PSTORAGE_DEVICE_NUMBERS :: ^struct {
    Version         : u32,
    Size            : u32,
    NumberOfDevices : u32,
    Devices         : [1]STORAGE_DEVICE_NUMBER,
 };

 STORAGE_DEVICE_NUMBER_EX :: struct {
    Version         : u32,
    Size            : u32,
    Flags           : u32,
    DeviceType      : u32,
    DeviceNumber    : u32,
    DeviceGuid      : GUID,
    PartitionNumber : u32,
 };
 PSTORAGE_DEVICE_NUMBER_EX :: ^struct {
    Version         : u32,
    Size            : u32,
    Flags           : u32,
    DeviceType      : u32,
    DeviceNumber    : u32,
    DeviceGuid      : GUID,
    PartitionNumber : u32,
 };

 STORAGE_BUS_RESET_REQUEST :: struct {
    PathId : BYTE,
 };
 PSTORAGE_BUS_RESET_REQUEST :: ^struct {
    PathId : BYTE,
 };

 STORAGE_BREAK_RESERVATION_REQUEST :: struct {
    Length   : u32,
    _unused  : BYTE,
    PathId   : BYTE,
    TargetId : BYTE,
    Lun      : BYTE,
 };
 PSTORAGE_BREAK_RESERVATION_REQUEST :: ^struct {
    Length   : u32,
    _unused  : BYTE,
    PathId   : BYTE,
    TargetId : BYTE,
    Lun      : BYTE,
 };

 PREVENT_MEDIA_REMOVAL :: struct {
    PreventMediaRemoval : BOOLEAN,
 };
 PPREVENT_MEDIA_REMOVAL :: ^struct {
    PreventMediaRemoval : BOOLEAN,
 };

 CLASS_MEDIA_CHANGE_CONTEXT :: struct {
    MediaChangeCount : u32,
    NewState         : u32,
 };
 PCLASS_MEDIA_CHANGE_CONTEXT :: ^struct {
    MediaChangeCount : u32,
    NewState         : u32,
 };

 TAPE_STATISTICS :: struct {
    Version                : u32,
    Flags                  : u32,
    RecoveredWrites        : LARGE_INTEGER,
    UnrecoveredWrites      : LARGE_INTEGER,
    RecoveredReads         : LARGE_INTEGER,
    UnrecoveredReads       : LARGE_INTEGER,
    CompressionRatioReads  : BYTE,
    CompressionRatioWrites : BYTE,
 };
 PTAPE_STATISTICS :: ^struct {
    Version                : u32,
    Flags                  : u32,
    RecoveredWrites        : LARGE_INTEGER,
    UnrecoveredWrites      : LARGE_INTEGER,
    RecoveredReads         : LARGE_INTEGER,
    UnrecoveredReads       : LARGE_INTEGER,
    CompressionRatioReads  : BYTE,
    CompressionRatioWrites : BYTE,
 };

 TAPE_GET_STATISTICS :: struct {
    Operation : u32,
 };
 PTAPE_GET_STATISTICS :: ^struct {
    Operation : u32,
 };

 STORAGE_MEDIA_TYPE :: enum {
    DDS_4mm = 0x20,
    MiniQic,
    Travan,
    QIC,
    MP_8mm,
    AME_8mm,
    AIT1_8mm,
    DLT,
    NCTP,
    IBM_3480,
    IBM_3490E,
    IBM_Magstar_3590,
    IBM_Magstar_MP,
    STK_DATA_D3,
    SONY_DTF,
    DV_6mm,
    DMI,
    SONY_D2,
    CLEANER_CARTRIDGE,
    CD_ROM,
    CD_R,
    CD_RW,
    DVD_ROM,
    DVD_R,
    DVD_RW,
    MO_3_RW,
    MO_5_WO,
    MO_5_RW,
    MO_5_LIMDOW,
    PC_5_WO,
    PC_5_RW,
    PD_5_RW,
    ABL_5_WO,
    PINNACLE_APEX_5_RW,
    SONY_12_WO,
    PHILIPS_12_WO,
    HITACHI_12_WO,
    CYGNET_12_WO,
    KODAK_14_WO,
    MO_NFR_525,
    NIKON_12_RW,
    IOMEGA_ZIP,
    IOMEGA_JAZ,
    SYQUEST_EZ135,
    SYQUEST_EZFLYER,
    SYQUEST_SYJET,
    AVATAR_F2,
    MP2_8mm,
    DST_S,
    DST_M,
    DST_L,
    VXATape_1,
    VXATape_2,
    STK_9840,
    LTO_Ultrium,
    LTO_Accelis,
    DVD_RAM,
    AIT_8mm,
    ADR_1,
    ADR_2,
    STK_9940,
    SAIT,
    VXATape,
 };
 PSTORAGE_MEDIA_TYPE :: ^enum {
    DDS_4mm = 0x20,
    MiniQic,
    Travan,
    QIC,
    MP_8mm,
    AME_8mm,
    AIT1_8mm,
    DLT,
    NCTP,
    IBM_3480,
    IBM_3490E,
    IBM_Magstar_3590,
    IBM_Magstar_MP,
    STK_DATA_D3,
    SONY_DTF,
    DV_6mm,
    DMI,
    SONY_D2,
    CLEANER_CARTRIDGE,
    CD_ROM,
    CD_R,
    CD_RW,
    DVD_ROM,
    DVD_R,
    DVD_RW,
    MO_3_RW,
    MO_5_WO,
    MO_5_RW,
    MO_5_LIMDOW,
    PC_5_WO,
    PC_5_RW,
    PD_5_RW,
    ABL_5_WO,
    PINNACLE_APEX_5_RW,
    SONY_12_WO,
    PHILIPS_12_WO,
    HITACHI_12_WO,
    CYGNET_12_WO,
    KODAK_14_WO,
    MO_NFR_525,
    NIKON_12_RW,
    IOMEGA_ZIP,
    IOMEGA_JAZ,
    SYQUEST_EZ135,
    SYQUEST_EZFLYER,
    SYQUEST_SYJET,
    AVATAR_F2,
    MP2_8mm,
    DST_S,
    DST_M,
    DST_L,
    VXATape_1,
    VXATape_2,
    STK_9840,
    LTO_Ultrium,
    LTO_Accelis,
    DVD_RAM,
    AIT_8mm,
    ADR_1,
    ADR_2,
    STK_9940,
    SAIT,
    VXATape,
 };

 STORAGE_BUS_TYPE :: enum {
    BusTypeUnknown = 0x00,
    BusTypeScsi,
    BusTypeAtapi,
    BusTypeAta,
    BusType1394,
    BusTypeSsa,
    BusTypeFibre,
    BusTypeUsb,
    BusTypeRAID,
    BusTypeiScsi,
    BusTypeSas,
    BusTypeSata,
    BusTypeSd,
    BusTypeMmc,
    BusTypeVirtual,
    BusTypeFileBackedVirtual,
    BusTypeSpaces,
    BusTypeNvme,
    BusTypeSCM,
    BusTypeUfs,
    BusTypeMax,
    BusTypeMaxReserved = 0x7F,
 };
 PSTORAGE_BUS_TYPE :: ^enum {
    BusTypeUnknown = 0x00,
    BusTypeScsi,
    BusTypeAtapi,
    BusTypeAta,
    BusType1394,
    BusTypeSsa,
    BusTypeFibre,
    BusTypeUsb,
    BusTypeRAID,
    BusTypeiScsi,
    BusTypeSas,
    BusTypeSata,
    BusTypeSd,
    BusTypeMmc,
    BusTypeVirtual,
    BusTypeFileBackedVirtual,
    BusTypeSpaces,
    BusTypeNvme,
    BusTypeSCM,
    BusTypeUfs,
    BusTypeMax,
    BusTypeMaxReserved = 0x7F,
 };

 DEVICE_MEDIA_INFO :: struct {
    DeviceSpecific : struct #raw_union {
        DiskInfo : struct {
            Cylinders            : LARGE_INTEGER,
            MediaType            : STORAGE_MEDIA_TYPE,
            TracksPerCylinder    : u32,
            SectorsPerTrack      : u32,
            BytesPerSector       : u32,
            NumberMediaSides     : u32,
            MediaCharacteristics : u32,
        },
        RemovableDiskInfo : struct {
            Cylinders            : LARGE_INTEGER,
            MediaType            : STORAGE_MEDIA_TYPE,
            TracksPerCylinder    : u32,
            SectorsPerTrack      : u32,
            BytesPerSector       : u32,
            NumberMediaSides     : u32,
            MediaCharacteristics : u32,
        },
        TapeInfo : struct {
            MediaType            : STORAGE_MEDIA_TYPE,
            MediaCharacteristics : u32,
            CurrentBlockSize     : u32,
            BusType              : STORAGE_BUS_TYPE,
            BusSpecificData : struct #raw_union {
                ScsiInformation : struct {
                    MediumType  : BYTE,
                    DensityCode : BYTE,
                },
            },
        },
    },
 };
 PDEVICE_MEDIA_INFO :: ^struct {
    DeviceSpecific : struct #raw_union {
        DiskInfo : struct {
            Cylinders            : LARGE_INTEGER,
            MediaType            : STORAGE_MEDIA_TYPE,
            TracksPerCylinder    : u32,
            SectorsPerTrack      : u32,
            BytesPerSector       : u32,
            NumberMediaSides     : u32,
            MediaCharacteristics : u32,
        },
        RemovableDiskInfo : struct {
            Cylinders            : LARGE_INTEGER,
            MediaType            : STORAGE_MEDIA_TYPE,
            TracksPerCylinder    : u32,
            SectorsPerTrack      : u32,
            BytesPerSector       : u32,
            NumberMediaSides     : u32,
            MediaCharacteristics : u32,
        },
        TapeInfo : struct {
            MediaType            : STORAGE_MEDIA_TYPE,
            MediaCharacteristics : u32,
            CurrentBlockSize     : u32,
            BusType              : STORAGE_BUS_TYPE,
            BusSpecificData : struct #raw_union {
                ScsiInformation : struct {
                    MediumType  : BYTE,
                    DensityCode : BYTE,
                },
            },
        },
    },
 };

 GET_MEDIA_TYPES :: struct {
    DeviceType     : u32,
    MediaInfoCount : u32,
    MediaInfo      : [1]DEVICE_MEDIA_INFO,
 };
 PGET_MEDIA_TYPES :: ^struct {
    DeviceType     : u32,
    MediaInfoCount : u32,
    MediaInfo      : [1]DEVICE_MEDIA_INFO,
 };

 STORAGE_PREDICT_FAILURE :: struct {
    PredictFailure : u32,
    VendorSpecific : [512]BYTE,
 };
 PSTORAGE_PREDICT_FAILURE :: ^struct {
    PredictFailure : u32,
    VendorSpecific : [512]BYTE,
 };

 STORAGE_FAILURE_PREDICTION_CONFIG :: struct {
    Version  : u32,
    Size     : u32,
    Set      : BOOLEAN,
    Enabled  : BOOLEAN,
    Reserved : u16,
 };
 PSTORAGE_FAILURE_PREDICTION_CONFIG :: ^struct {
    Version  : u32,
    Size     : u32,
    Set      : BOOLEAN,
    Enabled  : BOOLEAN,
    Reserved : u16,
 };

 STORAGE_QUERY_TYPE :: enum {
    PropertyStandardQuery = 0,
    PropertyExistsQuery,
    PropertyMaskQuery,
    PropertyQueryMaxDefined,
 };
 PSTORAGE_QUERY_TYPE :: ^enum {
    PropertyStandardQuery = 0,
    PropertyExistsQuery,
    PropertyMaskQuery,
    PropertyQueryMaxDefined,
 };

 STORAGE_SET_TYPE :: enum {
    PropertyStandardSet = 0,
    PropertyExistsSet,
    PropertySetMaxDefined,
 };
 PSTORAGE_SET_TYPE :: ^enum {
    PropertyStandardSet = 0,
    PropertyExistsSet,
    PropertySetMaxDefined,
 };

 STORAGE_PROPERTY_ID :: enum {
    StorageDeviceProperty = 0,
    StorageAdapterProperty,
    StorageDeviceIdProperty,
    StorageDeviceUniqueIdProperty,
    StorageDeviceWriteCacheProperty,
    StorageMiniportProperty,
    StorageAccessAlignmentProperty,
    StorageDeviceSeekPenaltyProperty,
    StorageDeviceTrimProperty,
    StorageDeviceWriteAggregationProperty,
    StorageDeviceDeviceTelemetryProperty,
    StorageDeviceLBProvisioningProperty,
    StorageDevicePowerProperty,
    StorageDeviceCopyOffloadProperty,
    StorageDeviceResiliencyProperty,
    StorageDeviceMediumProductType,
    StorageAdapterRpmbProperty,
    StorageAdapterCryptoProperty,
    StorageDeviceIoCapabilityProperty = 48,
    StorageAdapterProtocolSpecificProperty,
    StorageDeviceProtocolSpecificProperty,
    StorageAdapterTemperatureProperty,
    StorageDeviceTemperatureProperty,
    StorageAdapterPhysicalTopologyProperty,
    StorageDevicePhysicalTopologyProperty,
    StorageDeviceAttributesProperty,
    StorageDeviceManagementStatus,
    StorageAdapterSerialNumberProperty,
    StorageDeviceLocationProperty,
    StorageDeviceNumaProperty,
    StorageDeviceZonedDeviceProperty,
    StorageDeviceUnsafeShutdownCount,
    StorageDeviceEnduranceProperty,
 };
 PSTORAGE_PROPERTY_ID :: ^enum {
    StorageDeviceProperty = 0,
    StorageAdapterProperty,
    StorageDeviceIdProperty,
    StorageDeviceUniqueIdProperty,
    StorageDeviceWriteCacheProperty,
    StorageMiniportProperty,
    StorageAccessAlignmentProperty,
    StorageDeviceSeekPenaltyProperty,
    StorageDeviceTrimProperty,
    StorageDeviceWriteAggregationProperty,
    StorageDeviceDeviceTelemetryProperty,
    StorageDeviceLBProvisioningProperty,
    StorageDevicePowerProperty,
    StorageDeviceCopyOffloadProperty,
    StorageDeviceResiliencyProperty,
    StorageDeviceMediumProductType,
    StorageAdapterRpmbProperty,
    StorageAdapterCryptoProperty,
    StorageDeviceIoCapabilityProperty = 48,
    StorageAdapterProtocolSpecificProperty,
    StorageDeviceProtocolSpecificProperty,
    StorageAdapterTemperatureProperty,
    StorageDeviceTemperatureProperty,
    StorageAdapterPhysicalTopologyProperty,
    StorageDevicePhysicalTopologyProperty,
    StorageDeviceAttributesProperty,
    StorageDeviceManagementStatus,
    StorageAdapterSerialNumberProperty,
    StorageDeviceLocationProperty,
    StorageDeviceNumaProperty,
    StorageDeviceZonedDeviceProperty,
    StorageDeviceUnsafeShutdownCount,
    StorageDeviceEnduranceProperty,
 };

 STORAGE_PROPERTY_QUERY :: struct {
    PropertyId           : STORAGE_PROPERTY_ID,
    QueryType            : STORAGE_QUERY_TYPE,
    AdditionalParameters : [1]BYTE,
 };
 PSTORAGE_PROPERTY_QUERY :: ^struct {
    PropertyId           : STORAGE_PROPERTY_ID,
    QueryType            : STORAGE_QUERY_TYPE,
    AdditionalParameters : [1]BYTE,
 };

 STORAGE_PROPERTY_SET :: struct {
    PropertyId           : STORAGE_PROPERTY_ID,
    SetType              : STORAGE_SET_TYPE,
    AdditionalParameters : [1]BYTE,
 };
 PSTORAGE_PROPERTY_SET :: ^struct {
    PropertyId           : STORAGE_PROPERTY_ID,
    SetType              : STORAGE_SET_TYPE,
    AdditionalParameters : [1]BYTE,
 };

 STORAGE_DESCRIPTOR_HEADER :: struct {
    Version : u32,
    Size    : u32,
 };
 PSTORAGE_DESCRIPTOR_HEADER :: ^struct {
    Version : u32,
    Size    : u32,
 };

 STORAGE_DEVICE_DESCRIPTOR :: struct {
    Version               : u32,
    Size                  : u32,
    DeviceType            : BYTE,
    DeviceTypeModifier    : BYTE,
    RemovableMedia        : BOOLEAN,
    CommandQueueing       : BOOLEAN,
    VendorIdOffset        : u32,
    ProductIdOffset       : u32,
    ProductRevisionOffset : u32,
    SerialNumberOffset    : u32,
    BusType               : STORAGE_BUS_TYPE,
    RawPropertiesLength   : u32,
    RawDeviceProperties   : [1]BYTE,
 };
 PSTORAGE_DEVICE_DESCRIPTOR :: ^struct {
    Version               : u32,
    Size                  : u32,
    DeviceType            : BYTE,
    DeviceTypeModifier    : BYTE,
    RemovableMedia        : BOOLEAN,
    CommandQueueing       : BOOLEAN,
    VendorIdOffset        : u32,
    ProductIdOffset       : u32,
    ProductRevisionOffset : u32,
    SerialNumberOffset    : u32,
    BusType               : STORAGE_BUS_TYPE,
    RawPropertiesLength   : u32,
    RawDeviceProperties   : [1]BYTE,
 };

 STORAGE_ADAPTER_DESCRIPTOR :: struct {
    Version               : u32,
    Size                  : u32,
    MaximumTransferLength : u32,
    MaximumPhysicalPages  : u32,
    AlignmentMask         : u32,
    AdapterUsesPio        : BOOLEAN,
    AdapterScansDown      : BOOLEAN,
    CommandQueueing       : BOOLEAN,
    AcceleratedTransfer   : BOOLEAN,
    BusType               : BYTE,
    BusMajorVersion       : u16,
    BusMinorVersion       : u16,
    SrbType               : BYTE,
    AddressType           : BYTE,
 };
 PSTORAGE_ADAPTER_DESCRIPTOR :: ^struct {
    Version               : u32,
    Size                  : u32,
    MaximumTransferLength : u32,
    MaximumPhysicalPages  : u32,
    AlignmentMask         : u32,
    AdapterUsesPio        : BOOLEAN,
    AdapterScansDown      : BOOLEAN,
    CommandQueueing       : BOOLEAN,
    AcceleratedTransfer   : BOOLEAN,
    BusType               : BYTE,
    BusMajorVersion       : u16,
    BusMinorVersion       : u16,
    SrbType               : BYTE,
    AddressType           : BYTE,
 };

 STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR :: struct {
    Version                       : u32,
    Size                          : u32,
    BytesPerCacheLine             : u32,
    BytesOffsetForCacheAlignment  : u32,
    BytesPerLogicalSector         : u32,
    BytesPerPhysicalSector        : u32,
    BytesOffsetForSectorAlignment : u32,
 };
 PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR :: ^struct {
    Version                       : u32,
    Size                          : u32,
    BytesPerCacheLine             : u32,
    BytesOffsetForCacheAlignment  : u32,
    BytesPerLogicalSector         : u32,
    BytesPerPhysicalSector        : u32,
    BytesOffsetForSectorAlignment : u32,
 };

 STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR :: struct {
    Version           : u32,
    Size              : u32,
    MediumProductType : u32,
 };
 PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR :: ^struct {
    Version           : u32,
    Size              : u32,
    MediumProductType : u32,
 };

 STORAGE_PORT_CODE_SET :: enum {
    StoragePortCodeSetReserved = 0,
    StoragePortCodeSetStorport = 1,
    StoragePortCodeSetSCSIport = 2,
    StoragePortCodeSetSpaceport = 3,
    StoragePortCodeSetATAport = 4,
    StoragePortCodeSetUSBport = 5,
    StoragePortCodeSetSBP2port = 6,
    StoragePortCodeSetSDport = 7,
 };
 PSTORAGE_PORT_CODE_SET :: ^enum {
    StoragePortCodeSetReserved = 0,
    StoragePortCodeSetStorport = 1,
    StoragePortCodeSetSCSIport = 2,
    StoragePortCodeSetSpaceport = 3,
    StoragePortCodeSetATAport = 4,
    StoragePortCodeSetUSBport = 5,
    StoragePortCodeSetSBP2port = 6,
    StoragePortCodeSetSDport = 7,
 };

 STORAGE_MINIPORT_DESCRIPTOR :: struct {
    Version              : u32,
    Size                 : u32,
    Portdriver           : STORAGE_PORT_CODE_SET,
    LUNResetSupported    : BOOLEAN,
    TargetResetSupported : BOOLEAN,
    IoTimeoutValue       : u16,
    ExtraIoInfoSupported : BOOLEAN,
    Reserved0            : [3]BYTE,
    Reserved1            : u32,
 };
 PSTORAGE_MINIPORT_DESCRIPTOR :: ^struct {
    Version              : u32,
    Size                 : u32,
    Portdriver           : STORAGE_PORT_CODE_SET,
    LUNResetSupported    : BOOLEAN,
    TargetResetSupported : BOOLEAN,
    IoTimeoutValue       : u16,
    ExtraIoInfoSupported : BOOLEAN,
    Reserved0            : [3]BYTE,
    Reserved1            : u32,
 };

 STORAGE_IDENTIFIER_CODE_SET :: enum {
    StorageIdCodeSetReserved = 0,
    StorageIdCodeSetBinary = 1,
    StorageIdCodeSetAscii = 2,
    StorageIdCodeSetUtf8 = 3,
 };
 PSTORAGE_IDENTIFIER_CODE_SET :: ^enum {
    StorageIdCodeSetReserved = 0,
    StorageIdCodeSetBinary = 1,
    StorageIdCodeSetAscii = 2,
    StorageIdCodeSetUtf8 = 3,
 };

 STORAGE_IDENTIFIER_TYPE :: enum {
    StorageIdTypeVendorSpecific = 0,
    StorageIdTypeVendorId = 1,
    StorageIdTypeEUI64 = 2,
    StorageIdTypeFCPHName = 3,
    StorageIdTypePortRelative = 4,
    StorageIdTypeTargetPortGroup = 5,
    StorageIdTypeLogicalUnitGroup = 6,
    StorageIdTypeMD5LogicalUnitIdentifier = 7,
    StorageIdTypeScsiNameString = 8,
 };
 PSTORAGE_IDENTIFIER_TYPE :: ^enum {
    StorageIdTypeVendorSpecific = 0,
    StorageIdTypeVendorId = 1,
    StorageIdTypeEUI64 = 2,
    StorageIdTypeFCPHName = 3,
    StorageIdTypePortRelative = 4,
    StorageIdTypeTargetPortGroup = 5,
    StorageIdTypeLogicalUnitGroup = 6,
    StorageIdTypeMD5LogicalUnitIdentifier = 7,
    StorageIdTypeScsiNameString = 8,
 };

 STORAGE_ID_NAA_FORMAT :: enum {
    StorageIdNAAFormatIEEEExtended = 2,
    StorageIdNAAFormatIEEERegistered = 3,
    StorageIdNAAFormatIEEEERegisteredExtended = 5,
 };
 PSTORAGE_ID_NAA_FORMAT :: ^enum {
    StorageIdNAAFormatIEEEExtended = 2,
    StorageIdNAAFormatIEEERegistered = 3,
    StorageIdNAAFormatIEEEERegisteredExtended = 5,
 };

 STORAGE_ASSOCIATION_TYPE :: enum {
    StorageIdAssocDevice = 0,
    StorageIdAssocPort = 1,
    StorageIdAssocTarget = 2,
 };
 PSTORAGE_ASSOCIATION_TYPE :: ^enum {
    StorageIdAssocDevice = 0,
    StorageIdAssocPort = 1,
    StorageIdAssocTarget = 2,
 };

 STORAGE_IDENTIFIER :: struct {
    CodeSet        : STORAGE_IDENTIFIER_CODE_SET,
    Type           : STORAGE_IDENTIFIER_TYPE,
    IdentifierSize : u16,
    NextOffset     : u16,
    Association    : STORAGE_ASSOCIATION_TYPE,
    Identifier     : [1]BYTE,
 };
 PSTORAGE_IDENTIFIER :: ^struct {
    CodeSet        : STORAGE_IDENTIFIER_CODE_SET,
    Type           : STORAGE_IDENTIFIER_TYPE,
    IdentifierSize : u16,
    NextOffset     : u16,
    Association    : STORAGE_ASSOCIATION_TYPE,
    Identifier     : [1]BYTE,
 };

 STORAGE_DEVICE_ID_DESCRIPTOR :: struct {
    Version             : u32,
    Size                : u32,
    NumberOfIdentifiers : u32,
    Identifiers         : [1]BYTE,
 };
 PSTORAGE_DEVICE_ID_DESCRIPTOR :: ^struct {
    Version             : u32,
    Size                : u32,
    NumberOfIdentifiers : u32,
    Identifiers         : [1]BYTE,
 };

 DEVICE_SEEK_PENALTY_DESCRIPTOR :: struct {
    Version           : u32,
    Size              : u32,
    IncursSeekPenalty : BOOLEAN,
 };
 PDEVICE_SEEK_PENALTY_DESCRIPTOR :: ^struct {
    Version           : u32,
    Size              : u32,
    IncursSeekPenalty : BOOLEAN,
 };

 DEVICE_WRITE_AGGREGATION_DESCRIPTOR :: struct {
    Version                      : u32,
    Size                         : u32,
    BenefitsFromWriteAggregation : BOOLEAN,
 };
 PDEVICE_WRITE_AGGREGATION_DESCRIPTOR :: ^struct {
    Version                      : u32,
    Size                         : u32,
    BenefitsFromWriteAggregation : BOOLEAN,
 };

 DEVICE_TRIM_DESCRIPTOR :: struct {
    Version     : u32,
    Size        : u32,
    TrimEnabled : BOOLEAN,
 };
 PDEVICE_TRIM_DESCRIPTOR :: ^struct {
    Version     : u32,
    Size        : u32,
    TrimEnabled : BOOLEAN,
 };

 DEVICE_LB_PROVISIONING_DESCRIPTOR :: struct {
    Version                        : u32,
    Size                           : u32,
    ThinProvisioningEnabled        : ,
    ThinProvisioningReadZeros      : ,
    AnchorSupported                : ,
    UnmapGranularityAlignmentValid : ,
    Reserved0                      : ,
    Reserved1                      : [7]BYTE,
    OptimalUnmapGranularity        : DWORDLONG,
    UnmapGranularityAlignment      : DWORDLONG,
    MaxUnmapLbaCount               : u32,
    MaxUnmapBlockDescriptorCount   : u32,
 };
 PDEVICE_LB_PROVISIONING_DESCRIPTOR :: ^struct {
    Version                        : u32,
    Size                           : u32,
    ThinProvisioningEnabled        : ,
    ThinProvisioningReadZeros      : ,
    AnchorSupported                : ,
    UnmapGranularityAlignmentValid : ,
    Reserved0                      : ,
    Reserved1                      : [7]BYTE,
    OptimalUnmapGranularity        : DWORDLONG,
    UnmapGranularityAlignment      : DWORDLONG,
    MaxUnmapLbaCount               : u32,
    MaxUnmapBlockDescriptorCount   : u32,
 };

 STORAGE_LB_PROVISIONING_MAP_RESOURCES :: struct {
    Size                           : u32,
    Version                        : u32,
    AvailableMappingResourcesValid : ,
    UsedMappingResourcesValid      : ,
    Reserved0                      : ,
    Reserved1                      : [3]BYTE,
    AvailableMappingResourcesScope : ,
    UsedMappingResourcesScope      : ,
    Reserved2                      : ,
    Reserved3                      : [3]BYTE,
    AvailableMappingResources      : DWORDLONG,
    UsedMappingResources           : DWORDLONG,
 };
 PSTORAGE_LB_PROVISIONING_MAP_RESOURCES :: ^struct {
    Size                           : u32,
    Version                        : u32,
    AvailableMappingResourcesValid : ,
    UsedMappingResourcesValid      : ,
    Reserved0                      : ,
    Reserved1                      : [3]BYTE,
    AvailableMappingResourcesScope : ,
    UsedMappingResourcesScope      : ,
    Reserved2                      : ,
    Reserved3                      : [3]BYTE,
    AvailableMappingResources      : DWORDLONG,
    UsedMappingResources           : DWORDLONG,
 };

 DEVICE_POWER_DESCRIPTOR :: struct {
    Version                           : u32,
    Size                              : u32,
    DeviceAttentionSupported          : BOOLEAN,
    AsynchronousNotificationSupported : BOOLEAN,
    IdlePowerManagementEnabled        : BOOLEAN,
    D3ColdEnabled                     : BOOLEAN,
    D3ColdSupported                   : BOOLEAN,
    NoVerifyDuringIdlePower           : BOOLEAN,
    Reserved                          : [2]BYTE,
    IdleTimeoutInMS                   : u32,
 };
 PDEVICE_POWER_DESCRIPTOR :: ^struct {
    Version                           : u32,
    Size                              : u32,
    DeviceAttentionSupported          : BOOLEAN,
    AsynchronousNotificationSupported : BOOLEAN,
    IdlePowerManagementEnabled        : BOOLEAN,
    D3ColdEnabled                     : BOOLEAN,
    D3ColdSupported                   : BOOLEAN,
    NoVerifyDuringIdlePower           : BOOLEAN,
    Reserved                          : [2]BYTE,
    IdleTimeoutInMS                   : u32,
 };

 DEVICE_COPY_OFFLOAD_DESCRIPTOR :: struct {
    Version                            : u32,
    Size                               : u32,
    MaximumTokenLifetime               : u32,
    DefaultTokenLifetime               : u32,
    MaximumTransferSize                : DWORDLONG,
    OptimalTransferCount               : DWORDLONG,
    MaximumDataDescriptors             : u32,
    MaximumTransferLengthPerDescriptor : u32,
    OptimalTransferLengthPerDescriptor : u32,
    OptimalTransferLengthGranularity   : u16,
    Reserved                           : [2]BYTE,
 };
 PDEVICE_COPY_OFFLOAD_DESCRIPTOR :: ^struct {
    Version                            : u32,
    Size                               : u32,
    MaximumTokenLifetime               : u32,
    DefaultTokenLifetime               : u32,
    MaximumTransferSize                : DWORDLONG,
    OptimalTransferCount               : DWORDLONG,
    MaximumDataDescriptors             : u32,
    MaximumTransferLengthPerDescriptor : u32,
    OptimalTransferLengthPerDescriptor : u32,
    OptimalTransferLengthGranularity   : u16,
    Reserved                           : [2]BYTE,
 };

 STORAGE_DEVICE_RESILIENCY_DESCRIPTOR :: struct {
    Version                : u32,
    Size                   : u32,
    NameOffset             : u32,
    NumberOfLogicalCopies  : u32,
    NumberOfPhysicalCopies : u32,
    PhysicalDiskRedundancy : u32,
    NumberOfColumns        : u32,
    Interleave             : u32,
 };
 PSTORAGE_DEVICE_RESILIENCY_DESCRIPTOR :: ^struct {
    Version                : u32,
    Size                   : u32,
    NameOffset             : u32,
    NumberOfLogicalCopies  : u32,
    NumberOfPhysicalCopies : u32,
    PhysicalDiskRedundancy : u32,
    NumberOfColumns        : u32,
    Interleave             : u32,
 };

 STORAGE_RPMB_FRAME_TYPE :: enum {
    StorageRpmbFrameTypeUnknown = 0,
    StorageRpmbFrameTypeStandard,
    StorageRpmbFrameTypeMax,
 };
 PSTORAGE_RPMB_FRAME_TYPE :: ^enum {
    StorageRpmbFrameTypeUnknown = 0,
    StorageRpmbFrameTypeStandard,
    StorageRpmbFrameTypeMax,
 };

 STORAGE_RPMB_DESCRIPTOR :: struct {
    Version                     : u32,
    Size                        : u32,
    SizeInBytes                 : u32,
    MaxReliableWriteSizeInBytes : u32,
    FrameFormat                 : STORAGE_RPMB_FRAME_TYPE,
 };
 PSTORAGE_RPMB_DESCRIPTOR :: ^struct {
    Version                     : u32,
    Size                        : u32,
    SizeInBytes                 : u32,
    MaxReliableWriteSizeInBytes : u32,
    FrameFormat                 : STORAGE_RPMB_FRAME_TYPE,
 };

 STORAGE_CRYPTO_ALGORITHM_ID :: enum {
    StorageCryptoAlgorithmUnknown = 0,
    StorageCryptoAlgorithmXTSAES = 1,
    StorageCryptoAlgorithmBitlockerAESCBC,
    StorageCryptoAlgorithmAESECB,
    StorageCryptoAlgorithmESSIVAESCBC,
    StorageCryptoAlgorithmMax,
 };
 PSTORAGE_CRYPTO_ALGORITHM_ID :: ^enum {
    StorageCryptoAlgorithmUnknown = 0,
    StorageCryptoAlgorithmXTSAES = 1,
    StorageCryptoAlgorithmBitlockerAESCBC,
    StorageCryptoAlgorithmAESECB,
    StorageCryptoAlgorithmESSIVAESCBC,
    StorageCryptoAlgorithmMax,
 };

 STORAGE_CRYPTO_KEY_SIZE :: enum {
    StorageCryptoKeySizeUnknown = 0,
    StorageCryptoKeySize128Bits = 1,
    StorageCryptoKeySize192Bits,
    StorageCryptoKeySize256Bits,
    StorageCryptoKeySize512Bits,
 };
 PSTORAGE_CRYPTO_KEY_SIZE :: ^enum {
    StorageCryptoKeySizeUnknown = 0,
    StorageCryptoKeySize128Bits = 1,
    StorageCryptoKeySize192Bits,
    StorageCryptoKeySize256Bits,
    StorageCryptoKeySize512Bits,
 };

 STORAGE_CRYPTO_CAPABILITY :: struct {
    Version               : u32,
    Size                  : u32,
    CryptoCapabilityIndex : u32,
    AlgorithmId           : STORAGE_CRYPTO_ALGORITHM_ID,
    KeySize               : STORAGE_CRYPTO_KEY_SIZE,
    DataUnitSizeBitmask   : u32,
 };
 PSTORAGE_CRYPTO_CAPABILITY :: ^struct {
    Version               : u32,
    Size                  : u32,
    CryptoCapabilityIndex : u32,
    AlgorithmId           : STORAGE_CRYPTO_ALGORITHM_ID,
    KeySize               : STORAGE_CRYPTO_KEY_SIZE,
    DataUnitSizeBitmask   : u32,
 };

 STORAGE_CRYPTO_DESCRIPTOR :: struct {
    Version               : u32,
    Size                  : u32,
    NumKeysSupported      : u32,
    NumCryptoCapabilities : u32,
    CryptoCapabilities    : [1]STORAGE_CRYPTO_CAPABILITY,
 };
 PSTORAGE_CRYPTO_DESCRIPTOR :: ^struct {
    Version               : u32,
    Size                  : u32,
    NumKeysSupported      : u32,
    NumCryptoCapabilities : u32,
    CryptoCapabilities    : [1]STORAGE_CRYPTO_CAPABILITY,
 };

 STORAGE_TIER_MEDIA_TYPE :: enum {
    StorageTierMediaTypeUnspecified = 0,
    StorageTierMediaTypeDisk = 1,
    StorageTierMediaTypeSsd = 2,
    StorageTierMediaTypeScm = 4,
    StorageTierMediaTypeMax,
 };
 PSTORAGE_TIER_MEDIA_TYPE :: ^enum {
    StorageTierMediaTypeUnspecified = 0,
    StorageTierMediaTypeDisk = 1,
    StorageTierMediaTypeSsd = 2,
    StorageTierMediaTypeScm = 4,
    StorageTierMediaTypeMax,
 };

 STORAGE_TIER_CLASS :: enum {
    StorageTierClassUnspecified = 0,
    StorageTierClassCapacity,
    StorageTierClassPerformance,
    StorageTierClassMax,
 };
 PSTORAGE_TIER_CLASS :: ^enum {
    StorageTierClassUnspecified = 0,
    StorageTierClassCapacity,
    StorageTierClassPerformance,
    StorageTierClassMax,
 };

 STORAGE_TIER :: struct {
    Id                  : GUID,
    Name                : [(256)]WCHAR,
    Description         : [(256)]WCHAR,
    Flags               : DWORDLONG,
    ProvisionedCapacity : DWORDLONG,
    MediaType           : STORAGE_TIER_MEDIA_TYPE,
    Class               : STORAGE_TIER_CLASS,
 };
 PSTORAGE_TIER :: ^struct {
    Id                  : GUID,
    Name                : [(256)]WCHAR,
    Description         : [(256)]WCHAR,
    Flags               : DWORDLONG,
    ProvisionedCapacity : DWORDLONG,
    MediaType           : STORAGE_TIER_MEDIA_TYPE,
    Class               : STORAGE_TIER_CLASS,
 };

 STORAGE_DEVICE_TIERING_DESCRIPTOR :: struct {
    Version               : u32,
    Size                  : u32,
    Flags                 : u32,
    TotalNumberOfTiers    : u32,
    NumberOfTiersReturned : u32,
    Tiers                 : [1]STORAGE_TIER,
 };
 PSTORAGE_DEVICE_TIERING_DESCRIPTOR :: ^struct {
    Version               : u32,
    Size                  : u32,
    Flags                 : u32,
    TotalNumberOfTiers    : u32,
    NumberOfTiersReturned : u32,
    Tiers                 : [1]STORAGE_TIER,
 };

 STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR :: struct {
    Version              : u32,
    Size                 : u32,
    NumberOfFaultDomains : u32,
    FaultDomainIds       : [1]GUID,
 };
 PSTORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR :: ^struct {
    Version              : u32,
    Size                 : u32,
    NumberOfFaultDomains : u32,
    FaultDomainIds       : [1]GUID,
 };

 STORAGE_PROTOCOL_TYPE :: enum {
    ProtocolTypeUnknown = 0x00,
    ProtocolTypeScsi,
    ProtocolTypeAta,
    ProtocolTypeNvme,
    ProtocolTypeSd,
    ProtocolTypeUfs,
    ProtocolTypeProprietary = 0x7E,
    ProtocolTypeMaxReserved = 0x7F,
 };
 PSTORAGE_PROTOCOL_TYPE :: ^enum {
    ProtocolTypeUnknown = 0x00,
    ProtocolTypeScsi,
    ProtocolTypeAta,
    ProtocolTypeNvme,
    ProtocolTypeSd,
    ProtocolTypeUfs,
    ProtocolTypeProprietary = 0x7E,
    ProtocolTypeMaxReserved = 0x7F,
 };

 STORAGE_PROTOCOL_NVME_DATA_TYPE :: enum {
    NVMeDataTypeUnknown = 0,
    NVMeDataTypeIdentify,
    NVMeDataTypeLogPage,
    NVMeDataTypeFeature,
 };
 PSTORAGE_PROTOCOL_NVME_DATA_TYPE :: ^enum {
    NVMeDataTypeUnknown = 0,
    NVMeDataTypeIdentify,
    NVMeDataTypeLogPage,
    NVMeDataTypeFeature,
 };

 STORAGE_PROTOCOL_ATA_DATA_TYPE :: enum {
    AtaDataTypeUnknown = 0,
    AtaDataTypeIdentify,
    AtaDataTypeLogPage,
 };
 PSTORAGE_PROTOCOL_ATA_DATA_TYPE :: ^enum {
    AtaDataTypeUnknown = 0,
    AtaDataTypeIdentify,
    AtaDataTypeLogPage,
 };

 STORAGE_PROTOCOL_UFS_DATA_TYPE :: enum {
    UfsDataTypeUnknown = 0,
    UfsDataTypeQueryDescriptor,
    UfsDataTypeMax,
 };
 PSTORAGE_PROTOCOL_UFS_DATA_TYPE :: ^enum {
    UfsDataTypeUnknown = 0,
    UfsDataTypeQueryDescriptor,
    UfsDataTypeMax,
 };

 STORAGE_PROTOCOL_SPECIFIC_DATA :: struct {
    ProtocolType                 : STORAGE_PROTOCOL_TYPE,
    DataType                     : u32,
    ProtocolDataRequestValue     : u32,
    ProtocolDataRequestSubValue  : u32,
    ProtocolDataOffset           : u32,
    ProtocolDataLength           : u32,
    FixedProtocolReturnData      : u32,
    ProtocolDataRequestSubValue2 : u32,
    ProtocolDataRequestSubValue3 : u32,
    Reserved                     : u32,
 };
 PSTORAGE_PROTOCOL_SPECIFIC_DATA :: ^struct {
    ProtocolType                 : STORAGE_PROTOCOL_TYPE,
    DataType                     : u32,
    ProtocolDataRequestValue     : u32,
    ProtocolDataRequestSubValue  : u32,
    ProtocolDataOffset           : u32,
    ProtocolDataLength           : u32,
    FixedProtocolReturnData      : u32,
    ProtocolDataRequestSubValue2 : u32,
    ProtocolDataRequestSubValue3 : u32,
    Reserved                     : u32,
 };

 STORAGE_PROTOCOL_SPECIFIC_DATA_EXT :: struct {
    ProtocolType            : STORAGE_PROTOCOL_TYPE,
    DataType                : u32,
    ProtocolDataValue       : u32,
    ProtocolDataSubValue    : u32,
    ProtocolDataOffset      : u32,
    ProtocolDataLength      : u32,
    FixedProtocolReturnData : u32,
    ProtocolDataSubValue2   : u32,
    ProtocolDataSubValue3   : u32,
    ProtocolDataSubValue4   : u32,
    ProtocolDataSubValue5   : u32,
    Reserved                : [5]u32,
 };
 PSTORAGE_PROTOCOL_SPECIFIC_DATA_EXT :: ^struct {
    ProtocolType            : STORAGE_PROTOCOL_TYPE,
    DataType                : u32,
    ProtocolDataValue       : u32,
    ProtocolDataSubValue    : u32,
    ProtocolDataOffset      : u32,
    ProtocolDataLength      : u32,
    FixedProtocolReturnData : u32,
    ProtocolDataSubValue2   : u32,
    ProtocolDataSubValue3   : u32,
    ProtocolDataSubValue4   : u32,
    ProtocolDataSubValue5   : u32,
    Reserved                : [5]u32,
 };

 STORAGE_PROTOCOL_DATA_DESCRIPTOR :: struct {
    Version              : u32,
    Size                 : u32,
    ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA,
 };
 PSTORAGE_PROTOCOL_DATA_DESCRIPTOR :: ^struct {
    Version              : u32,
    Size                 : u32,
    ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA,
 };

 STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT :: struct {
    Version              : u32,
    Size                 : u32,
    ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA_EXT,
 };
 PSTORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT :: ^struct {
    Version              : u32,
    Size                 : u32,
    ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA_EXT,
 };

 STORAGE_TEMPERATURE_INFO :: struct {
    Index                   : u16,
    Temperature             : SHORT,
    OverThreshold           : SHORT,
    UnderThreshold          : SHORT,
    OverThresholdChangable  : BOOLEAN,
    UnderThresholdChangable : BOOLEAN,
    EventGenerated          : BOOLEAN,
    Reserved0               : BYTE,
    Reserved1               : u32,
 };
 PSTORAGE_TEMPERATURE_INFO :: ^struct {
    Index                   : u16,
    Temperature             : SHORT,
    OverThreshold           : SHORT,
    UnderThreshold          : SHORT,
    OverThresholdChangable  : BOOLEAN,
    UnderThresholdChangable : BOOLEAN,
    EventGenerated          : BOOLEAN,
    Reserved0               : BYTE,
    Reserved1               : u32,
 };

 STORAGE_TEMPERATURE_DATA_DESCRIPTOR :: struct {
    Version             : u32,
    Size                : u32,
    CriticalTemperature : SHORT,
    WarningTemperature  : SHORT,
    InfoCount           : u16,
    Reserved0           : [2]BYTE,
    Reserved1           : [2]u32,
    TemperatureInfo     : [1]STORAGE_TEMPERATURE_INFO,
 };
 PSTORAGE_TEMPERATURE_DATA_DESCRIPTOR :: ^struct {
    Version             : u32,
    Size                : u32,
    CriticalTemperature : SHORT,
    WarningTemperature  : SHORT,
    InfoCount           : u16,
    Reserved0           : [2]BYTE,
    Reserved1           : [2]u32,
    TemperatureInfo     : [1]STORAGE_TEMPERATURE_INFO,
 };

 STORAGE_TEMPERATURE_THRESHOLD :: struct {
    Version       : u32,
    Size          : u32,
    Flags         : u16,
    Index         : u16,
    Threshold     : SHORT,
    OverThreshold : BOOLEAN,
    Reserved      : BYTE,
 };
 PSTORAGE_TEMPERATURE_THRESHOLD :: ^struct {
    Version       : u32,
    Size          : u32,
    Flags         : u16,
    Index         : u16,
    Threshold     : SHORT,
    OverThreshold : BOOLEAN,
    Reserved      : BYTE,
 };

 STORAGE_DEVICE_FORM_FACTOR :: enum {
    FormFactorUnknown = 0,
    FormFactor3_5,
    FormFactor2_5,
    FormFactor1_8,
    FormFactor1_8Less,
    FormFactorEmbedded,
    FormFactorMemoryCard,
    FormFactormSata,
    FormFactorM_2,
    FormFactorPCIeBoard,
    FormFactorDimm,
 };
 PSTORAGE_DEVICE_FORM_FACTOR :: ^enum {
    FormFactorUnknown = 0,
    FormFactor3_5,
    FormFactor2_5,
    FormFactor1_8,
    FormFactor1_8Less,
    FormFactorEmbedded,
    FormFactorMemoryCard,
    FormFactormSata,
    FormFactorM_2,
    FormFactorPCIeBoard,
    FormFactorDimm,
 };

 STORAGE_COMPONENT_HEALTH_STATUS :: enum {
    HealthStatusUnknown = 0,
    HealthStatusNormal,
    HealthStatusThrottled,
    HealthStatusWarning,
    HealthStatusDisabled,
    HealthStatusFailed,
 };
 PSTORAGE_COMPONENT_HEALTH_STATUS :: ^enum {
    HealthStatusUnknown = 0,
    HealthStatusNormal,
    HealthStatusThrottled,
    HealthStatusWarning,
    HealthStatusDisabled,
    HealthStatusFailed,
 };

 STORAGE_SPEC_VERSION :: struct #raw_union {
    s : struct {
        MinorVersion : struct #raw_union {
            s : struct {
                SubMinor : BYTE,
                Minor    : BYTE,
            },
            AsUshort : u16,
        },
        MajorVersion : u16,
    },
    AsUlong : u32,
 };
 PSTORAGE_SPEC_VERSION :: ^struct #raw_union {
    s : struct {
        MinorVersion : struct #raw_union {
            s : struct {
                SubMinor : BYTE,
                Minor    : BYTE,
            },
            AsUshort : u16,
        },
        MajorVersion : u16,
    },
    AsUlong : u32,
 };

 STORAGE_PHYSICAL_DEVICE_DATA :: struct {
    DeviceId         : u32,
    Role             : u32,
    HealthStatus     : STORAGE_COMPONENT_HEALTH_STATUS,
    CommandProtocol  : STORAGE_PROTOCOL_TYPE,
    SpecVersion      : STORAGE_SPEC_VERSION,
    FormFactor       : STORAGE_DEVICE_FORM_FACTOR,
    Vendor           : [8]BYTE,
    Model            : [40]BYTE,
    FirmwareRevision : [16]BYTE,
    Capacity         : DWORDLONG,
    PhysicalLocation : [32]BYTE,
    Reserved         : [2]u32,
 };
 PSTORAGE_PHYSICAL_DEVICE_DATA :: ^struct {
    DeviceId         : u32,
    Role             : u32,
    HealthStatus     : STORAGE_COMPONENT_HEALTH_STATUS,
    CommandProtocol  : STORAGE_PROTOCOL_TYPE,
    SpecVersion      : STORAGE_SPEC_VERSION,
    FormFactor       : STORAGE_DEVICE_FORM_FACTOR,
    Vendor           : [8]BYTE,
    Model            : [40]BYTE,
    FirmwareRevision : [16]BYTE,
    Capacity         : DWORDLONG,
    PhysicalLocation : [32]BYTE,
    Reserved         : [2]u32,
 };

 STORAGE_PHYSICAL_ADAPTER_DATA :: struct {
    AdapterId         : u32,
    HealthStatus      : STORAGE_COMPONENT_HEALTH_STATUS,
    CommandProtocol   : STORAGE_PROTOCOL_TYPE,
    SpecVersion       : STORAGE_SPEC_VERSION,
    Vendor            : [8]BYTE,
    Model             : [40]BYTE,
    FirmwareRevision  : [16]BYTE,
    PhysicalLocation  : [32]BYTE,
    ExpanderConnected : BOOLEAN,
    Reserved0         : [3]BYTE,
    Reserved1         : [3]u32,
 };
 PSTORAGE_PHYSICAL_ADAPTER_DATA :: ^struct {
    AdapterId         : u32,
    HealthStatus      : STORAGE_COMPONENT_HEALTH_STATUS,
    CommandProtocol   : STORAGE_PROTOCOL_TYPE,
    SpecVersion       : STORAGE_SPEC_VERSION,
    Vendor            : [8]BYTE,
    Model             : [40]BYTE,
    FirmwareRevision  : [16]BYTE,
    PhysicalLocation  : [32]BYTE,
    ExpanderConnected : BOOLEAN,
    Reserved0         : [3]BYTE,
    Reserved1         : [3]u32,
 };

 STORAGE_PHYSICAL_NODE_DATA :: struct {
    NodeId            : u32,
    AdapterCount      : u32,
    AdapterDataLength : u32,
    AdapterDataOffset : u32,
    DeviceCount       : u32,
    DeviceDataLength  : u32,
    DeviceDataOffset  : u32,
    Reserved          : [3]u32,
 };
 PSTORAGE_PHYSICAL_NODE_DATA :: ^struct {
    NodeId            : u32,
    AdapterCount      : u32,
    AdapterDataLength : u32,
    AdapterDataOffset : u32,
    DeviceCount       : u32,
    DeviceDataLength  : u32,
    DeviceDataOffset  : u32,
    Reserved          : [3]u32,
 };

 STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR :: struct {
    Version   : u32,
    Size      : u32,
    NodeCount : u32,
    Reserved  : u32,
    Node      : [1]STORAGE_PHYSICAL_NODE_DATA,
 };
 PSTORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR :: ^struct {
    Version   : u32,
    Size      : u32,
    NodeCount : u32,
    Reserved  : u32,
    Node      : [1]STORAGE_PHYSICAL_NODE_DATA,
 };

 STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR :: struct {
    Version           : u32,
    Size              : u32,
    LunMaxIoCount     : u32,
    AdapterMaxIoCount : u32,
 };
 PSTORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR :: ^struct {
    Version           : u32,
    Size              : u32,
    LunMaxIoCount     : u32,
    AdapterMaxIoCount : u32,
 };

 STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR :: struct {
    Version    : u32,
    Size       : u32,
    Attributes : DWORD64,
 };
 PSTORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR :: ^struct {
    Version    : u32,
    Size       : u32,
    Attributes : DWORD64,
 };

 STORAGE_DISK_HEALTH_STATUS :: enum {
    DiskHealthUnknown = 0,
    DiskHealthUnhealthy,
    DiskHealthWarning,
    DiskHealthHealthy,
    DiskHealthMax,
 };
 PSTORAGE_DISK_HEALTH_STATUS :: ^enum {
    DiskHealthUnknown = 0,
    DiskHealthUnhealthy,
    DiskHealthWarning,
    DiskHealthHealthy,
    DiskHealthMax,
 };

 STORAGE_DISK_OPERATIONAL_STATUS :: enum {
    DiskOpStatusNone = 0,
    DiskOpStatusUnknown,
    DiskOpStatusOk,
    DiskOpStatusPredictingFailure,
    DiskOpStatusInService,
    DiskOpStatusHardwareError,
    DiskOpStatusNotUsable,
    DiskOpStatusTransientError,
    DiskOpStatusMissing,
 };
 PSTORAGE_DISK_OPERATIONAL_STATUS :: ^enum {
    DiskOpStatusNone = 0,
    DiskOpStatusUnknown,
    DiskOpStatusOk,
    DiskOpStatusPredictingFailure,
    DiskOpStatusInService,
    DiskOpStatusHardwareError,
    DiskOpStatusNotUsable,
    DiskOpStatusTransientError,
    DiskOpStatusMissing,
 };

 STORAGE_OPERATIONAL_STATUS_REASON :: enum {
    DiskOpReasonUnknown = 0,
    DiskOpReasonScsiSenseCode,
    DiskOpReasonMedia,
    DiskOpReasonIo,
    DiskOpReasonThresholdExceeded,
    DiskOpReasonLostData,
    DiskOpReasonEnergySource,
    DiskOpReasonConfiguration,
    DiskOpReasonDeviceController,
    DiskOpReasonMediaController,
    DiskOpReasonComponent,
    DiskOpReasonNVDIMM_N,
    DiskOpReasonBackgroundOperation,
    DiskOpReasonInvalidFirmware,
    DiskOpReasonHealthCheck,
    DiskOpReasonLostDataPersistence,
    DiskOpReasonDisabledByPlatform,
    DiskOpReasonLostWritePersistence,
    DiskOpReasonDataPersistenceLossImminent,
    DiskOpReasonWritePersistenceLossImminent,
    DiskOpReasonMax,
 };
 PSTORAGE_OPERATIONAL_STATUS_REASON :: ^enum {
    DiskOpReasonUnknown = 0,
    DiskOpReasonScsiSenseCode,
    DiskOpReasonMedia,
    DiskOpReasonIo,
    DiskOpReasonThresholdExceeded,
    DiskOpReasonLostData,
    DiskOpReasonEnergySource,
    DiskOpReasonConfiguration,
    DiskOpReasonDeviceController,
    DiskOpReasonMediaController,
    DiskOpReasonComponent,
    DiskOpReasonNVDIMM_N,
    DiskOpReasonBackgroundOperation,
    DiskOpReasonInvalidFirmware,
    DiskOpReasonHealthCheck,
    DiskOpReasonLostDataPersistence,
    DiskOpReasonDisabledByPlatform,
    DiskOpReasonLostWritePersistence,
    DiskOpReasonDataPersistenceLossImminent,
    DiskOpReasonWritePersistenceLossImminent,
    DiskOpReasonMax,
 };

 STORAGE_OPERATIONAL_REASON :: struct {
    Version  : u32,
    Size     : u32,
    Reason   : STORAGE_OPERATIONAL_STATUS_REASON,
    RawBytes : struct #raw_union {
        ScsiSenseKey : struct {
            SenseKey : BYTE,
            ASC      : BYTE,
            ASCQ     : BYTE,
            Reserved : BYTE,
        },
        NVDIMM_N : struct {
            CriticalHealth       : BYTE,
            ModuleHealth         : [2]BYTE,
            ErrorThresholdStatus : BYTE,
        },
        AsUlong      : u32,
    },
 };
 PSTORAGE_OPERATIONAL_REASON :: ^struct {
    Version  : u32,
    Size     : u32,
    Reason   : STORAGE_OPERATIONAL_STATUS_REASON,
    RawBytes : struct #raw_union {
        ScsiSenseKey : struct {
            SenseKey : BYTE,
            ASC      : BYTE,
            ASCQ     : BYTE,
            Reserved : BYTE,
        },
        NVDIMM_N : struct {
            CriticalHealth       : BYTE,
            ModuleHealth         : [2]BYTE,
            ErrorThresholdStatus : BYTE,
        },
        AsUlong      : u32,
    },
 };

 STORAGE_DEVICE_MANAGEMENT_STATUS :: struct {
    Version                   : u32,
    Size                      : u32,
    Health                    : STORAGE_DISK_HEALTH_STATUS,
    NumberOfOperationalStatus : u32,
    NumberOfAdditionalReasons : u32,
    OperationalStatus         : [16]STORAGE_DISK_OPERATIONAL_STATUS,
    AdditionalReasons         : [1]STORAGE_OPERATIONAL_REASON,
 };
 PSTORAGE_DEVICE_MANAGEMENT_STATUS :: ^struct {
    Version                   : u32,
    Size                      : u32,
    Health                    : STORAGE_DISK_HEALTH_STATUS,
    NumberOfOperationalStatus : u32,
    NumberOfAdditionalReasons : u32,
    OperationalStatus         : [16]STORAGE_DISK_OPERATIONAL_STATUS,
    AdditionalReasons         : [1]STORAGE_OPERATIONAL_REASON,
 };

 STORAGE_ADAPTER_SERIAL_NUMBER :: struct {
    Version      : u32,
    Size         : u32,
    SerialNumber : [(128)]WCHAR,
 };
 PSTORAGE_ADAPTER_SERIAL_NUMBER :: ^struct {
    Version      : u32,
    Size         : u32,
    SerialNumber : [(128)]WCHAR,
 };

 STORAGE_ZONED_DEVICE_TYPES :: enum {
    ZonedDeviceTypeUnknown = 0,
    ZonedDeviceTypeHostManaged,
    ZonedDeviceTypeHostAware,
    ZonedDeviceTypeDeviceManaged,
 };
 PSTORAGE_ZONED_DEVICE_TYPES :: ^enum {
    ZonedDeviceTypeUnknown = 0,
    ZonedDeviceTypeHostManaged,
    ZonedDeviceTypeHostAware,
    ZonedDeviceTypeDeviceManaged,
 };

 STORAGE_ZONE_TYPES :: enum {
    ZoneTypeUnknown = 0,
    ZoneTypeConventional = 1,
    ZoneTypeSequentialWriteRequired = 2,
    ZoneTypeSequentialWritePreferred = 3,
    ZoneTypeMax,
 };
 PSTORAGE_ZONE_TYPES :: ^enum {
    ZoneTypeUnknown = 0,
    ZoneTypeConventional = 1,
    ZoneTypeSequentialWriteRequired = 2,
    ZoneTypeSequentialWritePreferred = 3,
    ZoneTypeMax,
 };

 STORAGE_ZONE_GROUP :: struct {
    ZoneCount : u32,
    ZoneType  : STORAGE_ZONE_TYPES,
    ZoneSize  : DWORDLONG,
 };
 PSTORAGE_ZONE_GROUP :: ^struct {
    ZoneCount : u32,
    ZoneType  : STORAGE_ZONE_TYPES,
    ZoneSize  : DWORDLONG,
 };

 STORAGE_ZONED_DEVICE_DESCRIPTOR :: struct {
    Version        : u32,
    Size           : u32,
    DeviceType     : STORAGE_ZONED_DEVICE_TYPES,
    ZoneCount      : u32,
    ZoneAttributes : struct #raw_union {
        SequentialRequiredZone : struct {
            MaxOpenZoneCount : u32,
            UnrestrictedRead : BOOLEAN,
            Reserved         : [3]BYTE,
        },
        SequentialPreferredZone : struct {
            OptimalOpenZoneCount : u32,
            Reserved             : u32,
        },
    },
    ZoneGroupCount : u32,
    ZoneGroup      : [1]STORAGE_ZONE_GROUP,
 };
 PSTORAGE_ZONED_DEVICE_DESCRIPTOR :: ^struct {
    Version        : u32,
    Size           : u32,
    DeviceType     : STORAGE_ZONED_DEVICE_TYPES,
    ZoneCount      : u32,
    ZoneAttributes : struct #raw_union {
        SequentialRequiredZone : struct {
            MaxOpenZoneCount : u32,
            UnrestrictedRead : BOOLEAN,
            Reserved         : [3]BYTE,
        },
        SequentialPreferredZone : struct {
            OptimalOpenZoneCount : u32,
            Reserved             : u32,
        },
    },
    ZoneGroupCount : u32,
    ZoneGroup      : [1]STORAGE_ZONE_GROUP,
 };

 DEVICE_LOCATION :: struct {
    Socket  : u32,
    Slot    : u32,
    Adapter : u32,
    Port    : u32,
    u : struct #raw_union {
        s : struct {
            Channel : u32,
            Device  : u32,
        },
        s2 : struct {
            Target : u32,
            Lun    : u32,
        },
    },
 };
 PDEVICE_LOCATION :: ^struct {
    Socket  : u32,
    Slot    : u32,
    Adapter : u32,
    Port    : u32,
    u : struct #raw_union {
        s : struct {
            Channel : u32,
            Device  : u32,
        },
        s2 : struct {
            Target : u32,
            Lun    : u32,
        },
    },
 };

 STORAGE_DEVICE_LOCATION_DESCRIPTOR :: struct {
    Version      : u32,
    Size         : u32,
    Location     : DEVICE_LOCATION,
    StringOffset : u32,
 };
 PSTORAGE_DEVICE_LOCATION_DESCRIPTOR :: ^struct {
    Version      : u32,
    Size         : u32,
    Location     : DEVICE_LOCATION,
    StringOffset : u32,
 };

 STORAGE_DEVICE_NUMA_PROPERTY :: struct {
    Version  : u32,
    Size     : u32,
    NumaNode : u32,
 };
 PSTORAGE_DEVICE_NUMA_PROPERTY :: ^struct {
    Version  : u32,
    Size     : u32,
    NumaNode : u32,
 };

 STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT :: struct {
    Version             : u32,
    Size                : u32,
    UnsafeShutdownCount : u32,
 };
 PSTORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT :: ^struct {
    Version             : u32,
    Size                : u32,
    UnsafeShutdownCount : u32,
 };

 STORAGE_HW_ENDURANCE_INFO :: struct {
    ValidFields    : u32,
    GroupId        : u32,
    Flags : struct {
        Shared   : ,
        Reserved : ,
    },
    LifePercentage : u32,
    BytesReadCount : [16]BYTE,
    ByteWriteCount : [16]BYTE,
 };
 PSTORAGE_HW_ENDURANCE_INFO :: ^struct {
    ValidFields    : u32,
    GroupId        : u32,
    Flags : struct {
        Shared   : ,
        Reserved : ,
    },
    LifePercentage : u32,
    BytesReadCount : [16]BYTE,
    ByteWriteCount : [16]BYTE,
 };

 STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR :: struct {
    Version       : u32,
    Size          : u32,
    EnduranceInfo : STORAGE_HW_ENDURANCE_INFO,
 };
 PSTORAGE_HW_ENDURANCE_DATA_DESCRIPTOR :: ^struct {
    Version       : u32,
    Size          : u32,
    EnduranceInfo : STORAGE_HW_ENDURANCE_INFO,
 };

 DEVICE_DATA_MANAGEMENT_SET_ACTION :: u32;
 DEVICE_DSM_ACTION :: u32;

 DEVICE_DATA_SET_RANGE :: struct {
    StartingOffset : LONGLONG,
    LengthInBytes  : DWORDLONG,
 };
 PDEVICE_DATA_SET_RANGE :: ^struct {
    StartingOffset : LONGLONG,
    LengthInBytes  : DWORDLONG,
 };
 DEVICE_DSM_RANGE :: struct {
    StartingOffset : LONGLONG,
    LengthInBytes  : DWORDLONG,
 };
 PDEVICE_DSM_RANGE :: ^struct {
    StartingOffset : LONGLONG,
    LengthInBytes  : DWORDLONG,
 };

 DEVICE_MANAGE_DATA_SET_ATTRIBUTES :: struct {
    Size                 : u32,
    Action               : DEVICE_DSM_ACTION,
    Flags                : u32,
    ParameterBlockOffset : u32,
    ParameterBlockLength : u32,
    DataSetRangesOffset  : u32,
    DataSetRangesLength  : u32,
 };
 PDEVICE_MANAGE_DATA_SET_ATTRIBUTES :: ^struct {
    Size                 : u32,
    Action               : DEVICE_DSM_ACTION,
    Flags                : u32,
    ParameterBlockOffset : u32,
    ParameterBlockLength : u32,
    DataSetRangesOffset  : u32,
    DataSetRangesLength  : u32,
 };
 DEVICE_DSM_INPUT :: struct {
    Size                 : u32,
    Action               : DEVICE_DSM_ACTION,
    Flags                : u32,
    ParameterBlockOffset : u32,
    ParameterBlockLength : u32,
    DataSetRangesOffset  : u32,
    DataSetRangesLength  : u32,
 };
 PDEVICE_DSM_INPUT :: ^struct {
    Size                 : u32,
    Action               : DEVICE_DSM_ACTION,
    Flags                : u32,
    ParameterBlockOffset : u32,
    ParameterBlockLength : u32,
    DataSetRangesOffset  : u32,
    DataSetRangesLength  : u32,
 };

 DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT :: struct {
    Size                : u32,
    Action              : DEVICE_DSM_ACTION,
    Flags               : u32,
    OperationStatus     : u32,
    ExtendedError       : u32,
    TargetDetailedError : u32,
    ReservedStatus      : u32,
    OutputBlockOffset   : u32,
    OutputBlockLength   : u32,
 };
 PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT :: ^struct {
    Size                : u32,
    Action              : DEVICE_DSM_ACTION,
    Flags               : u32,
    OperationStatus     : u32,
    ExtendedError       : u32,
    TargetDetailedError : u32,
    ReservedStatus      : u32,
    OutputBlockOffset   : u32,
    OutputBlockLength   : u32,
 };
 DEVICE_DSM_OUTPUT :: struct {
    Size                : u32,
    Action              : DEVICE_DSM_ACTION,
    Flags               : u32,
    OperationStatus     : u32,
    ExtendedError       : u32,
    TargetDetailedError : u32,
    ReservedStatus      : u32,
    OutputBlockOffset   : u32,
    OutputBlockLength   : u32,
 };
 PDEVICE_DSM_OUTPUT :: ^struct {
    Size                : u32,
    Action              : DEVICE_DSM_ACTION,
    Flags               : u32,
    OperationStatus     : u32,
    ExtendedError       : u32,
    TargetDetailedError : u32,
    ReservedStatus      : u32,
    OutputBlockOffset   : u32,
    OutputBlockLength   : u32,
 };

 DEVICE_DSM_DEFINITION :: struct {
    Action                  : DEVICE_DSM_ACTION,
    SingleRange             : BOOLEAN,
    ParameterBlockAlignment : u32,
    ParameterBlockLength    : u32,
    HasOutput               : BOOLEAN,
    OutputBlockAlignment    : u32,
    OutputBlockLength       : u32,
 };
 PDEVICE_DSM_DEFINITION :: ^struct {
    Action                  : DEVICE_DSM_ACTION,
    SingleRange             : BOOLEAN,
    ParameterBlockAlignment : u32,
    ParameterBlockLength    : u32,
    HasOutput               : BOOLEAN,
    OutputBlockAlignment    : u32,
    OutputBlockLength       : u32,
 };

 DEVICE_DSM_NOTIFICATION_PARAMETERS :: struct {
    Size           : u32,
    Flags          : u32,
    NumFileTypeIDs : u32,
    FileTypeID     : [1]GUID,
 };
 PDEVICE_DSM_NOTIFICATION_PARAMETERS :: ^struct {
    Size           : u32,
    Flags          : u32,
    NumFileTypeIDs : u32,
    FileTypeID     : [1]GUID,
 };

 STORAGE_OFFLOAD_TOKEN :: struct {
    TokenType     : [4]BYTE,
    Reserved      : [2]BYTE,
    TokenIdLength : [2]BYTE,
    u : struct #raw_union {
        StorageOffloadZeroDataToken : struct {
            Reserved2 : [0x1F8]BYTE,
        },
        Token                       : [0x1F8]BYTE,
    },
 };
 PSTORAGE_OFFLOAD_TOKEN :: ^struct {
    TokenType     : [4]BYTE,
    Reserved      : [2]BYTE,
    TokenIdLength : [2]BYTE,
    u : struct #raw_union {
        StorageOffloadZeroDataToken : struct {
            Reserved2 : [0x1F8]BYTE,
        },
        Token                       : [0x1F8]BYTE,
    },
 };

 DEVICE_DSM_OFFLOAD_READ_PARAMETERS :: struct {
    Flags      : u32,
    TimeToLive : u32,
    Reserved   : [2]u32,
 };
 PDEVICE_DSM_OFFLOAD_READ_PARAMETERS :: ^struct {
    Flags      : u32,
    TimeToLive : u32,
    Reserved   : [2]u32,
 };

 STORAGE_OFFLOAD_READ_OUTPUT :: struct {
    OffloadReadFlags : u32,
    Reserved         : u32,
    LengthProtected  : DWORDLONG,
    TokenLength      : u32,
    Token            : STORAGE_OFFLOAD_TOKEN,
 };
 PSTORAGE_OFFLOAD_READ_OUTPUT :: ^struct {
    OffloadReadFlags : u32,
    Reserved         : u32,
    LengthProtected  : DWORDLONG,
    TokenLength      : u32,
    Token            : STORAGE_OFFLOAD_TOKEN,
 };

 DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS :: struct {
    Flags       : u32,
    Reserved    : u32,
    TokenOffset : DWORDLONG,
    Token       : STORAGE_OFFLOAD_TOKEN,
 };
 PDEVICE_DSM_OFFLOAD_WRITE_PARAMETERS :: ^struct {
    Flags       : u32,
    Reserved    : u32,
    TokenOffset : DWORDLONG,
    Token       : STORAGE_OFFLOAD_TOKEN,
 };

 STORAGE_OFFLOAD_WRITE_OUTPUT :: struct {
    OffloadWriteFlags : u32,
    Reserved          : u32,
    LengthCopied      : DWORDLONG,
 };
 PSTORAGE_OFFLOAD_WRITE_OUTPUT :: ^struct {
    OffloadWriteFlags : u32,
    Reserved          : u32,
    LengthCopied      : DWORDLONG,
 };

 DEVICE_DATA_SET_LBP_STATE_PARAMETERS :: struct {
    Version       : u32,
    Size          : u32,
    Flags         : u32,
    OutputVersion : u32,
 };
 PDEVICE_DATA_SET_LBP_STATE_PARAMETERS :: ^struct {
    Version       : u32,
    Size          : u32,
    Flags         : u32,
    OutputVersion : u32,
 };
 DEVICE_DSM_ALLOCATION_PARAMETERS :: struct {
    Version       : u32,
    Size          : u32,
    Flags         : u32,
    OutputVersion : u32,
 };
 PDEVICE_DSM_ALLOCATION_PARAMETERS :: ^struct {
    Version       : u32,
    Size          : u32,
    Flags         : u32,
    OutputVersion : u32,
 };

 DEVICE_DATA_SET_LB_PROVISIONING_STATE :: struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : u32,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };
 PDEVICE_DATA_SET_LB_PROVISIONING_STATE :: ^struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : u32,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };
 DEVICE_DSM_ALLOCATION_OUTPUT :: struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : u32,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };
 PDEVICE_DSM_ALLOCATION_OUTPUT :: ^struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : u32,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };

 DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 :: struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORDLONG,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };
 PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 :: ^struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORDLONG,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };
 DEVICE_DSM_ALLOCATION_OUTPUT2 :: struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORDLONG,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };
 PDEVICE_DSM_ALLOCATION_OUTPUT2 :: ^struct {
    Size                         : u32,
    Version                      : u32,
    SlabSizeInBytes              : DWORDLONG,
    SlabOffsetDeltaInBytes       : DWORDLONG,
    SlabAllocationBitMapBitCount : u32,
    SlabAllocationBitMapLength   : u32,
    SlabAllocationBitMap         : [1]u32,
 };

 DEVICE_DATA_SET_REPAIR_PARAMETERS :: struct {
    NumberOfRepairCopies : u32,
    SourceCopy           : u32,
    RepairCopies         : [1]u32,
 };
 PDEVICE_DATA_SET_REPAIR_PARAMETERS :: ^struct {
    NumberOfRepairCopies : u32,
    SourceCopy           : u32,
    RepairCopies         : [1]u32,
 };
 DEVICE_DSM_REPAIR_PARAMETERS :: struct {
    NumberOfRepairCopies : u32,
    SourceCopy           : u32,
    RepairCopies         : [1]u32,
 };
 PDEVICE_DSM_REPAIR_PARAMETERS :: ^struct {
    NumberOfRepairCopies : u32,
    SourceCopy           : u32,
    RepairCopies         : [1]u32,
 };

 DEVICE_DATA_SET_REPAIR_OUTPUT :: struct {
    ParityExtent : DEVICE_DSM_RANGE,
 };
 PDEVICE_DATA_SET_REPAIR_OUTPUT :: ^struct {
    ParityExtent : DEVICE_DSM_RANGE,
 };
 DEVICE_DSM_REPAIR_OUTPUT :: struct {
    ParityExtent : DEVICE_DSM_RANGE,
 };
 PDEVICE_DSM_REPAIR_OUTPUT :: ^struct {
    ParityExtent : DEVICE_DSM_RANGE,
 };

 DEVICE_DATA_SET_SCRUB_OUTPUT :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
 };
 PDEVICE_DATA_SET_SCRUB_OUTPUT :: ^struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
 };
 DEVICE_DSM_SCRUB_OUTPUT :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
 };
 PDEVICE_DSM_SCRUB_OUTPUT :: ^struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
 };

 DEVICE_DATA_SET_SCRUB_EX_OUTPUT :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
    ParityExtent   : DEVICE_DSM_RANGE,
 };
 PDEVICE_DATA_SET_SCRUB_EX_OUTPUT :: ^struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
    ParityExtent   : DEVICE_DSM_RANGE,
 };
 DEVICE_DSM_SCRUB_OUTPUT2 :: struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
    ParityExtent   : DEVICE_DSM_RANGE,
 };
 PDEVICE_DSM_SCRUB_OUTPUT2 :: ^struct {
    BytesProcessed : DWORDLONG,
    BytesRepaired  : DWORDLONG,
    BytesFailed    : DWORDLONG,
    ParityExtent   : DEVICE_DSM_RANGE,
 };

 DEVICE_DSM_TIERING_QUERY_INPUT :: struct {
    Version         : u32,
    Size            : u32,
    Flags           : u32,
    NumberOfTierIds : u32,
    TierIds         : [1]GUID,
 };
 PDEVICE_DSM_TIERING_QUERY_INPUT :: ^struct {
    Version         : u32,
    Size            : u32,
    Flags           : u32,
    NumberOfTierIds : u32,
    TierIds         : [1]GUID,
 };
 DEVICE_DSM_TIERING_QUERY_PARAMETERS :: struct {
    Version         : u32,
    Size            : u32,
    Flags           : u32,
    NumberOfTierIds : u32,
    TierIds         : [1]GUID,
 };
 PDEVICE_DSM_TIERING_QUERY_PARAMETERS :: ^struct {
    Version         : u32,
    Size            : u32,
    Flags           : u32,
    NumberOfTierIds : u32,
    TierIds         : [1]GUID,
 };

 STORAGE_TIER_REGION :: struct {
    TierId : GUID,
    Offset : DWORDLONG,
    Length : DWORDLONG,
 };
 PSTORAGE_TIER_REGION :: ^struct {
    TierId : GUID,
    Offset : DWORDLONG,
    Length : DWORDLONG,
 };

 DEVICE_DSM_TIERING_QUERY_OUTPUT :: struct {
    Version                 : u32,
    Size                    : u32,
    Flags                   : u32,
    Reserved                : u32,
    Alignment               : DWORDLONG,
    TotalNumberOfRegions    : u32,
    NumberOfRegionsReturned : u32,
    Regions                 : [1]STORAGE_TIER_REGION,
 };
 PDEVICE_DSM_TIERING_QUERY_OUTPUT :: ^struct {
    Version                 : u32,
    Size                    : u32,
    Flags                   : u32,
    Reserved                : u32,
    Alignment               : DWORDLONG,
    TotalNumberOfRegions    : u32,
    NumberOfRegionsReturned : u32,
    Regions                 : [1]STORAGE_TIER_REGION,
 };

 DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS :: struct {
    Size           : u32,
    TargetPriority : BYTE,
    Reserved       : [3]BYTE,
 };
 PDEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS :: ^struct {
    Size           : u32,
    TargetPriority : BYTE,
    Reserved       : [3]BYTE,
 };

 DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT :: struct {
    TopologyRangeBytes : DWORDLONG,
    TopologyId         : [16]BYTE,
 };
 PDEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT :: ^struct {
    TopologyRangeBytes : DWORDLONG,
    TopologyId         : [16]BYTE,
 };
 DEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT :: struct {
    TopologyRangeBytes : DWORDLONG,
    TopologyId         : [16]BYTE,
 };
 PDEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT :: ^struct {
    TopologyRangeBytes : DWORDLONG,
    TopologyId         : [16]BYTE,
 };

 DEVICE_STORAGE_ADDRESS_RANGE :: struct {
    StartAddress  : LONGLONG,
    LengthInBytes : DWORDLONG,
 };
 PDEVICE_STORAGE_ADDRESS_RANGE :: ^struct {
    StartAddress  : LONGLONG,
    LengthInBytes : DWORDLONG,
 };

 DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT :: struct {
    Version                : u32,
    Flags                  : u32,
    TotalNumberOfRanges    : u32,
    NumberOfRangesReturned : u32,
    Ranges                 : [1]DEVICE_STORAGE_ADDRESS_RANGE,
 };
 PDEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT :: ^struct {
    Version                : u32,
    Flags                  : u32,
    TotalNumberOfRanges    : u32,
    NumberOfRangesReturned : u32,
    Ranges                 : [1]DEVICE_STORAGE_ADDRESS_RANGE,
 };

 DEVICE_DSM_REPORT_ZONES_PARAMETERS :: struct {
    Size         : u32,
    ReportOption : BYTE,
    Partial      : BYTE,
    Reserved     : [2]BYTE,
 };
 PDEVICE_DSM_REPORT_ZONES_PARAMETERS :: ^struct {
    Size         : u32,
    ReportOption : BYTE,
    Partial      : BYTE,
    Reserved     : [2]BYTE,
 };

 STORAGE_ZONES_ATTRIBUTES :: enum {
    ZonesAttributeTypeAndLengthMayDifferent = 0,
    ZonesAttributeTypeSameLengthSame = 1,
    ZonesAttributeTypeSameLastZoneLengthDifferent = 2,
    ZonesAttributeTypeMayDifferentLengthSame = 3,
 };
 PSTORAGE_ZONES_ATTRIBUTES :: ^enum {
    ZonesAttributeTypeAndLengthMayDifferent = 0,
    ZonesAttributeTypeSameLengthSame = 1,
    ZonesAttributeTypeSameLastZoneLengthDifferent = 2,
    ZonesAttributeTypeMayDifferentLengthSame = 3,
 };

 STORAGE_ZONE_CONDITION :: enum {
    ZoneConditionConventional = 0x00,
    ZoneConditionEmpty = 0x01,
    ZoneConditionImplicitlyOpened = 0x02,
    ZoneConditionExplicitlyOpened = 0x03,
    ZoneConditionClosed = 0x04,
    ZoneConditionReadOnly = 0x0D,
    ZoneConditionFull = 0x0E,
    ZoneConditionOffline = 0x0F,
 };
 PSTORAGE_ZONE_CONDITION :: ^enum {
    ZoneConditionConventional = 0x00,
    ZoneConditionEmpty = 0x01,
    ZoneConditionImplicitlyOpened = 0x02,
    ZoneConditionExplicitlyOpened = 0x03,
    ZoneConditionClosed = 0x04,
    ZoneConditionReadOnly = 0x0D,
    ZoneConditionFull = 0x0E,
    ZoneConditionOffline = 0x0F,
 };

 STORAGE_ZONE_DESCRIPTOR :: struct {
    Size                       : u32,
    ZoneType                   : STORAGE_ZONE_TYPES,
    ZoneCondition              : STORAGE_ZONE_CONDITION,
    ResetWritePointerRecommend : BOOLEAN,
    Reserved0                  : [3]BYTE,
    ZoneSize                   : DWORDLONG,
    WritePointerOffset         : DWORDLONG,
 };
 PSTORAGE_ZONE_DESCRIPTOR :: ^struct {
    Size                       : u32,
    ZoneType                   : STORAGE_ZONE_TYPES,
    ZoneCondition              : STORAGE_ZONE_CONDITION,
    ResetWritePointerRecommend : BOOLEAN,
    Reserved0                  : [3]BYTE,
    ZoneSize                   : DWORDLONG,
    WritePointerOffset         : DWORDLONG,
 };

 DEVICE_DSM_REPORT_ZONES_DATA :: struct {
    Size            : u32,
    ZoneCount       : u32,
    Attributes      : STORAGE_ZONES_ATTRIBUTES,
    Reserved0       : u32,
    ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR,
 };
 PDEVICE_DSM_REPORT_ZONES_DATA :: ^struct {
    Size            : u32,
    ZoneCount       : u32,
    Attributes      : STORAGE_ZONES_ATTRIBUTES,
    Reserved0       : u32,
    ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR,
 };
 DEVICE_DSM_REPORT_ZONES_OUTPUT :: struct {
    Size            : u32,
    ZoneCount       : u32,
    Attributes      : STORAGE_ZONES_ATTRIBUTES,
    Reserved0       : u32,
    ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR,
 };
 PDEVICE_DSM_REPORT_ZONES_OUTPUT :: ^struct {
    Size            : u32,
    ZoneCount       : u32,
    Attributes      : STORAGE_ZONES_ATTRIBUTES,
    Reserved0       : u32,
    ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR,
 };

 DEVICE_STORAGE_RANGE_ATTRIBUTES :: struct {
    LengthInBytes : DWORDLONG,
    using _ : struct #raw_union {
        AllFlags : u32,
        using _ : struct {
            IsRangeBad : ,
        },
    },
    Reserved      : u32,
 };
 PDEVICE_STORAGE_RANGE_ATTRIBUTES :: ^struct {
    LengthInBytes : DWORDLONG,
    using _ : struct #raw_union {
        AllFlags : u32,
        using _ : struct {
            IsRangeBad : ,
        },
    },
    Reserved      : u32,
 };

 DEVICE_DSM_RANGE_ERROR_INFO :: struct {
    Version                : u32,
    Flags                  : u32,
    TotalNumberOfRanges    : u32,
    NumberOfRangesReturned : u32,
    Ranges                 : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES,
 };
 PDEVICE_DSM_RANGE_ERROR_INFO :: ^struct {
    Version                : u32,
    Flags                  : u32,
    TotalNumberOfRanges    : u32,
    NumberOfRangesReturned : u32,
    Ranges                 : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES,
 };
 DEVICE_DSM_RANGE_ERROR_OUTPUT :: struct {
    Version                : u32,
    Flags                  : u32,
    TotalNumberOfRanges    : u32,
    NumberOfRangesReturned : u32,
    Ranges                 : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES,
 };
 PDEVICE_DSM_RANGE_ERROR_OUTPUT :: ^struct {
    Version                : u32,
    Flags                  : u32,
    TotalNumberOfRanges    : u32,
    NumberOfRangesReturned : u32,
    Ranges                 : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES,
 };

 DEVICE_DSM_LOST_QUERY_PARAMETERS :: struct {
    Version     : u32,
    Granularity : DWORDLONG,
 };
 PDEVICE_DSM_LOST_QUERY_PARAMETERS :: ^struct {
    Version     : u32,
    Granularity : DWORDLONG,
 };

 DEVICE_DSM_LOST_QUERY_OUTPUT :: struct {
    Version      : u32,
    Size         : u32,
    Alignment    : DWORDLONG,
    NumberOfBits : u32,
    BitMap       : [1]u32,
 };
 PDEVICE_DSM_LOST_QUERY_OUTPUT :: ^struct {
    Version      : u32,
    Size         : u32,
    Alignment    : DWORDLONG,
    NumberOfBits : u32,
    BitMap       : [1]u32,
 };

 DEVICE_DSM_FREE_SPACE_OUTPUT :: struct {
    Version   : u32,
    FreeSpace : DWORDLONG,
 };
 PDEVICE_DSM_FREE_SPACE_OUTPUT :: ^struct {
    Version   : u32,
    FreeSpace : DWORDLONG,
 };

 DEVICE_DSM_CONVERSION_OUTPUT :: struct {
    Version : u32,
    Source  : GUID,
 };
 PDEVICE_DSM_CONVERSION_OUTPUT :: ^struct {
    Version : u32,
    Source  : GUID,
 };

 STORAGE_GET_BC_PROPERTIES_OUTPUT :: struct {
    MaximumRequestsPerPeriod : u32,
    MinimumPeriod            : u32,
    MaximumRequestSize       : DWORDLONG,
    EstimatedTimePerRequest  : u32,
    NumOutStandingRequests   : u32,
    RequestSize              : DWORDLONG,
 };
 PSTORAGE_GET_BC_PROPERTIES_OUTPUT :: ^struct {
    MaximumRequestsPerPeriod : u32,
    MinimumPeriod            : u32,
    MaximumRequestSize       : DWORDLONG,
    EstimatedTimePerRequest  : u32,
    NumOutStandingRequests   : u32,
    RequestSize              : DWORDLONG,
 };

 STORAGE_ALLOCATE_BC_STREAM_INPUT :: struct {
    Version           : u32,
    RequestsPerPeriod : u32,
    Period            : u32,
    RetryFailures     : BOOLEAN,
    Discardable       : BOOLEAN,
    Reserved1         : [2]BOOLEAN,
    AccessType        : u32,
    AccessMode        : u32,
 };
 PSTORAGE_ALLOCATE_BC_STREAM_INPUT :: ^struct {
    Version           : u32,
    RequestsPerPeriod : u32,
    Period            : u32,
    RetryFailures     : BOOLEAN,
    Discardable       : BOOLEAN,
    Reserved1         : [2]BOOLEAN,
    AccessType        : u32,
    AccessMode        : u32,
 };

 STORAGE_ALLOCATE_BC_STREAM_OUTPUT :: struct {
    RequestSize            : DWORDLONG,
    NumOutStandingRequests : u32,
 };
 PSTORAGE_ALLOCATE_BC_STREAM_OUTPUT :: ^struct {
    RequestSize            : DWORDLONG,
    NumOutStandingRequests : u32,
 };

 STORAGE_PRIORITY_HINT_SUPPORT :: struct {
    SupportFlags : u32,
 };
 PSTORAGE_PRIORITY_HINT_SUPPORT :: ^struct {
    SupportFlags : u32,
 };

 STORAGE_DIAGNOSTIC_LEVEL :: enum {
    StorageDiagnosticLevelDefault = 0,
    StorageDiagnosticLevelMax,
 };
 PSTORAGE_DIAGNOSTIC_LEVEL :: ^enum {
    StorageDiagnosticLevelDefault = 0,
    StorageDiagnosticLevelMax,
 };

 STORAGE_DIAGNOSTIC_TARGET_TYPE :: enum {
    StorageDiagnosticTargetTypeUndefined = 0,
    StorageDiagnosticTargetTypePort,
    StorageDiagnosticTargetTypeMiniport,
    StorageDiagnosticTargetTypeHbaFirmware,
    StorageDiagnosticTargetTypeMax,
 };
 PSTORAGE_DIAGNOSTIC_TARGET_TYPE :: ^enum {
    StorageDiagnosticTargetTypeUndefined = 0,
    StorageDiagnosticTargetTypePort,
    StorageDiagnosticTargetTypeMiniport,
    StorageDiagnosticTargetTypeHbaFirmware,
    StorageDiagnosticTargetTypeMax,
 };

 STORAGE_DIAGNOSTIC_REQUEST :: struct {
    Version    : u32,
    Size       : u32,
    Reserved   : u32,
    TargetType : STORAGE_DIAGNOSTIC_TARGET_TYPE,
    Level      : STORAGE_DIAGNOSTIC_LEVEL,
 };
 PSTORAGE_DIAGNOSTIC_REQUEST :: ^struct {
    Version    : u32,
    Size       : u32,
    Reserved   : u32,
    TargetType : STORAGE_DIAGNOSTIC_TARGET_TYPE,
    Level      : STORAGE_DIAGNOSTIC_LEVEL,
 };

 STORAGE_DIAGNOSTIC_DATA :: struct {
    Version              : u32,
    Size                 : u32,
    ProviderId           : GUID,
    BufferSize           : u32,
    Reserved             : u32,
    DiagnosticDataBuffer : [1]BYTE,
 };
 PSTORAGE_DIAGNOSTIC_DATA :: ^struct {
    Version              : u32,
    Size                 : u32,
    ProviderId           : GUID,
    BufferSize           : u32,
    Reserved             : u32,
    DiagnosticDataBuffer : [1]BYTE,
 };

 PHYSICAL_ELEMENT_STATUS_REQUEST :: struct {
    Version         : u32,
    Size            : u32,
    StartingElement : u32,
    Filter          : BYTE,
    ReportType      : BYTE,
    Reserved        : [2]BYTE,
 };
 PPHYSICAL_ELEMENT_STATUS_REQUEST :: ^struct {
    Version         : u32,
    Size            : u32,
    StartingElement : u32,
    Filter          : BYTE,
    ReportType      : BYTE,
    Reserved        : [2]BYTE,
 };

 PHYSICAL_ELEMENT_STATUS_DESCRIPTOR :: struct {
    Version               : u32,
    Size                  : u32,
    ElementIdentifier     : u32,
    PhysicalElementType   : BYTE,
    PhysicalElementHealth : BYTE,
    Reserved1             : [2]BYTE,
    AssociatedCapacity    : DWORDLONG,
    Reserved2             : [4]u32,
 };
 PPHYSICAL_ELEMENT_STATUS_DESCRIPTOR :: ^struct {
    Version               : u32,
    Size                  : u32,
    ElementIdentifier     : u32,
    PhysicalElementType   : BYTE,
    PhysicalElementHealth : BYTE,
    Reserved1             : [2]BYTE,
    AssociatedCapacity    : DWORDLONG,
    Reserved2             : [4]u32,
 };

 PHYSICAL_ELEMENT_STATUS :: struct {
    Version                       : u32,
    Size                          : u32,
    DescriptorCount               : u32,
    ReturnedDescriptorCount       : u32,
    ElementIdentifierBeingDepoped : u32,
    Reserved                      : u32,
    Descriptors                   : [1]PHYSICAL_ELEMENT_STATUS_DESCRIPTOR,
 };
 PPHYSICAL_ELEMENT_STATUS :: ^struct {
    Version                       : u32,
    Size                          : u32,
    DescriptorCount               : u32,
    ReturnedDescriptorCount       : u32,
    ElementIdentifierBeingDepoped : u32,
    Reserved                      : u32,
    Descriptors                   : [1]PHYSICAL_ELEMENT_STATUS_DESCRIPTOR,
 };

 REMOVE_ELEMENT_AND_TRUNCATE_REQUEST :: struct {
    Version           : u32,
    Size              : u32,
    RequestCapacity   : DWORDLONG,
    ElementIdentifier : u32,
    Reserved          : u32,
 };
 PREMOVE_ELEMENT_AND_TRUNCATE_REQUEST :: ^struct {
    Version           : u32,
    Size              : u32,
    RequestCapacity   : DWORDLONG,
    ElementIdentifier : u32,
    Reserved          : u32,
 };

 STORAGE_READ_CAPACITY :: struct {
    Version        : u32,
    Size           : u32,
    BlockLength    : u32,
    NumberOfBlocks : LARGE_INTEGER,
    DiskLength     : LARGE_INTEGER,
 };
 PSTORAGE_READ_CAPACITY :: ^struct {
    Version        : u32,
    Size           : u32,
    BlockLength    : u32,
    NumberOfBlocks : LARGE_INTEGER,
    DiskLength     : LARGE_INTEGER,
 };

 WRITE_CACHE_TYPE :: enum {
    WriteCacheTypeUnknown,
    WriteCacheTypeNone,
    WriteCacheTypeWriteBack,
    WriteCacheTypeWriteThrough,
 };

 WRITE_CACHE_ENABLE :: enum {
    WriteCacheEnableUnknown,
    WriteCacheDisabled,
    WriteCacheEnabled,
 };

 WRITE_CACHE_CHANGE :: enum {
    WriteCacheChangeUnknown,
    WriteCacheNotChangeable,
    WriteCacheChangeable,
 };

 WRITE_THROUGH :: enum {
    WriteThroughUnknown,
    WriteThroughNotSupported,
    WriteThroughSupported,
 };

 STORAGE_WRITE_CACHE_PROPERTY :: struct {
    Version                    : u32,
    Size                       : u32,
    WriteCacheType             : WRITE_CACHE_TYPE,
    WriteCacheEnabled          : WRITE_CACHE_ENABLE,
    WriteCacheChangeable       : WRITE_CACHE_CHANGE,
    WriteThroughSupported      : WRITE_THROUGH,
    FlushCacheSupported        : BOOLEAN,
    UserDefinedPowerProtection : BOOLEAN,
    NVCacheEnabled             : BOOLEAN,
 };
 PSTORAGE_WRITE_CACHE_PROPERTY :: ^struct {
    Version                    : u32,
    Size                       : u32,
    WriteCacheType             : WRITE_CACHE_TYPE,
    WriteCacheEnabled          : WRITE_CACHE_ENABLE,
    WriteCacheChangeable       : WRITE_CACHE_CHANGE,
    WriteThroughSupported      : WRITE_THROUGH,
    FlushCacheSupported        : BOOLEAN,
    UserDefinedPowerProtection : BOOLEAN,
    NVCacheEnabled             : BOOLEAN,
 };

 DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE :: enum {
    TCCollectionBugCheck = 1,
    TCCollectionApplicationRequested,
    TCCollectionDeviceRequested,
 };
 PDEVICEDUMP_COLLECTION_TYPE :: ^enum {
    TCCollectionBugCheck = 1,
    TCCollectionApplicationRequested,
    TCCollectionDeviceRequested,
 };

 DEVICEDUMP_SUBSECTION_POINTER :: struct {
    dwSize   : u32,
    dwFlags  : u32,
    dwOffset : u32,
 };
 PDEVICEDUMP_SUBSECTION_POINTER :: ^struct {
    dwSize   : u32,
    dwFlags  : u32,
    dwOffset : u32,
 };

 DEVICEDUMP_STRUCTURE_VERSION :: struct {
    dwSignature : u32,
    dwVersion   : u32,
    dwSize      : u32,
 };
 PDEVICEDUMP_STRUCTURE_VERSION :: ^struct {
    dwSignature : u32,
    dwVersion   : u32,
    dwSize      : u32,
 };

 DEVICEDUMP_SECTION_HEADER :: struct {
    guidDeviceDataId              : GUID,
    sOrganizationID               : [16]BYTE,
    dwFirmwareRevision            : u32,
    sModelNumber                  : [32]BYTE,
    szDeviceManufacturingID       : [32]BYTE,
    dwFlags                       : u32,
    bRestrictedPrivateDataVersion : u32,
    dwFirmwareIssueId             : u32,
    szIssueDescriptionString      : [132]BYTE,
 };
 PDEVICEDUMP_SECTION_HEADER :: ^struct {
    guidDeviceDataId              : GUID,
    sOrganizationID               : [16]BYTE,
    dwFirmwareRevision            : u32,
    sModelNumber                  : [32]BYTE,
    szDeviceManufacturingID       : [32]BYTE,
    dwFlags                       : u32,
    bRestrictedPrivateDataVersion : u32,
    dwFirmwareIssueId             : u32,
    szIssueDescriptionString      : [132]BYTE,
 };

 GP_LOG_PAGE_DESCRIPTOR :: struct {
    LogAddress : u16,
    LogSectors : u16,
 };
 PGP_LOG_PAGE_DESCRIPTOR :: ^struct {
    LogAddress : u16,
    LogSectors : u16,
 };

 DEVICEDUMP_PUBLIC_SUBSECTION :: struct {
    dwFlags       : u32,
    GPLogTable    : [16]GP_LOG_PAGE_DESCRIPTOR,
    szDescription : [16]CHAR,
    bData         : [1]BYTE,
 };
 PDEVICEDUMP_PUBLIC_SUBSECTION :: ^struct {
    dwFlags       : u32,
    GPLogTable    : [16]GP_LOG_PAGE_DESCRIPTOR,
    szDescription : [16]CHAR,
    bData         : [1]BYTE,
 };

 DEVICEDUMP_RESTRICTED_SUBSECTION :: struct {
    bData : [1]BYTE,
 };
 PDEVICEDUMP_RESTRICTED_SUBSECTION :: ^struct {
    bData : [1]BYTE,
 };

 DEVICEDUMP_PRIVATE_SUBSECTION :: struct {
    dwFlags : u32,
    GPLogId : GP_LOG_PAGE_DESCRIPTOR,
    bData   : [1]BYTE,
 };
 PDEVICEDUMP_PRIVATE_SUBSECTION :: ^struct {
    dwFlags : u32,
    GPLogId : GP_LOG_PAGE_DESCRIPTOR,
    bData   : [1]BYTE,
 };

 DEVICEDUMP_STORAGEDEVICE_DATA :: struct {
    Descriptor            : DEVICEDUMP_STRUCTURE_VERSION,
    SectionHeader         : DEVICEDUMP_SECTION_HEADER,
    dwBufferSize          : u32,
    dwReasonForCollection : u32,
    PublicData            : DEVICEDUMP_SUBSECTION_POINTER,
    RestrictedData        : DEVICEDUMP_SUBSECTION_POINTER,
    PrivateData           : DEVICEDUMP_SUBSECTION_POINTER,
 };
 PDEVICEDUMP_STORAGEDEVICE_DATA :: ^struct {
    Descriptor            : DEVICEDUMP_STRUCTURE_VERSION,
    SectionHeader         : DEVICEDUMP_SECTION_HEADER,
    dwBufferSize          : u32,
    dwReasonForCollection : u32,
    PublicData            : DEVICEDUMP_SUBSECTION_POINTER,
    RestrictedData        : DEVICEDUMP_SUBSECTION_POINTER,
    PrivateData           : DEVICEDUMP_SUBSECTION_POINTER,
 };

 DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD :: struct {
    Cdb             : [16]BYTE,
    Command         : [16]BYTE,
    StartTime       : DWORDLONG,
    EndTime         : DWORDLONG,
    OperationStatus : u32,
    OperationError  : u32,
    StackSpecific : struct #raw_union {
        ExternalStack : struct {
            dwReserved : u32,
        },
        AtaPort : struct {
            dwAtaPortSpecific : u32,
        },
        StorPort : struct {
            SrbTag : u32,
        },
    },
 };
 PDEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD :: ^struct {
    Cdb             : [16]BYTE,
    Command         : [16]BYTE,
    StartTime       : DWORDLONG,
    EndTime         : DWORDLONG,
    OperationStatus : u32,
    OperationError  : u32,
    StackSpecific : struct #raw_union {
        ExternalStack : struct {
            dwReserved : u32,
        },
        AtaPort : struct {
            dwAtaPortSpecific : u32,
        },
        StorPort : struct {
            SrbTag : u32,
        },
    },
 };

 DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP :: struct {
    Descriptor            : DEVICEDUMP_STRUCTURE_VERSION,
    dwReasonForCollection : u32,
    cDriverName           : [16]BYTE,
    uiNumRecords          : u32,
    RecordArray           : [1]DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD,
 };
 PDEVICEDUMP_STORAGESTACK_PUBLIC_DUMP :: ^struct {
    Descriptor            : DEVICEDUMP_STRUCTURE_VERSION,
    dwReasonForCollection : u32,
    cDriverName           : [16]BYTE,
    uiNumRecords          : u32,
    RecordArray           : [1]DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD,
 };

 STORAGE_IDLE_POWER :: struct {
    Version         : u32,
    Size            : u32,
    WakeCapableHint : ,
    D3ColdSupported : ,
    Reserved        : ,
    D3IdleTimeout   : u32,
 };
 PSTORAGE_IDLE_POWER :: ^struct {
    Version         : u32,
    Size            : u32,
    WakeCapableHint : ,
    D3ColdSupported : ,
    Reserved        : ,
    D3IdleTimeout   : u32,
 };

 STORAGE_POWERUP_REASON_TYPE :: enum {
    StoragePowerupUnknown = 0,
    StoragePowerupIO,
    StoragePowerupDeviceAttention,
 };
 PSTORAGE_POWERUP_REASON_TYPE :: ^enum {
    StoragePowerupUnknown = 0,
    StoragePowerupIO,
    StoragePowerupDeviceAttention,
 };

 STORAGE_IDLE_POWERUP_REASON :: struct {
    Version       : u32,
    Size          : u32,
    PowerupReason : STORAGE_POWERUP_REASON_TYPE,
 };
 PSTORAGE_IDLE_POWERUP_REASON :: ^struct {
    Version       : u32,
    Size          : u32,
    PowerupReason : STORAGE_POWERUP_REASON_TYPE,
 };

 STORAGE_DEVICE_POWER_CAP_UNITS :: enum {
    StorageDevicePowerCapUnitsPercent,
    StorageDevicePowerCapUnitsMilliwatts,
 };
 PSTORAGE_DEVICE_POWER_CAP_UNITS :: ^enum {
    StorageDevicePowerCapUnitsPercent,
    StorageDevicePowerCapUnitsMilliwatts,
 };

 STORAGE_DEVICE_POWER_CAP :: struct {
    Version  : u32,
    Size     : u32,
    Units    : STORAGE_DEVICE_POWER_CAP_UNITS,
    MaxPower : DWORDLONG,
 };
 PSTORAGE_DEVICE_POWER_CAP :: ^struct {
    Version  : u32,
    Size     : u32,
    Units    : STORAGE_DEVICE_POWER_CAP_UNITS,
    MaxPower : DWORDLONG,
 };

 STORAGE_RPMB_DATA_FRAME :: struct {
    Stuff                 : [196]BYTE,
    KeyOrMAC              : [32]BYTE,
    Data                  : [256]BYTE,
    Nonce                 : [16]BYTE,
    WriteCounter          : [4]BYTE,
    Address               : [2]BYTE,
    BlockCount            : [2]BYTE,
    OperationResult       : [2]BYTE,
    RequestOrResponseType : [2]BYTE,
 };
 PSTORAGE_RPMB_DATA_FRAME :: ^struct {
    Stuff                 : [196]BYTE,
    KeyOrMAC              : [32]BYTE,
    Data                  : [256]BYTE,
    Nonce                 : [16]BYTE,
    WriteCounter          : [4]BYTE,
    Address               : [2]BYTE,
    BlockCount            : [2]BYTE,
    OperationResult       : [2]BYTE,
    RequestOrResponseType : [2]BYTE,
 };

 STORAGE_RPMB_COMMAND_TYPE :: enum {
    StorRpmbProgramAuthKey = 0x00000001,
    StorRpmbQueryWriteCounter = 0x00000002,
    StorRpmbAuthenticatedWrite = 0x00000003,
    StorRpmbAuthenticatedRead = 0x00000004,
    StorRpmbReadResultRequest = 0x00000005,
    StorRpmbAuthenticatedDeviceConfigWrite = 0x00000006,
    StorRpmbAuthenticatedDeviceConfigRead = 0x00000007,
 };
 PSTORAGE_RPMB_COMMAND_TYPE :: ^enum {
    StorRpmbProgramAuthKey = 0x00000001,
    StorRpmbQueryWriteCounter = 0x00000002,
    StorRpmbAuthenticatedWrite = 0x00000003,
    StorRpmbAuthenticatedRead = 0x00000004,
    StorRpmbReadResultRequest = 0x00000005,
    StorRpmbAuthenticatedDeviceConfigWrite = 0x00000006,
    StorRpmbAuthenticatedDeviceConfigRead = 0x00000007,
 };

 STORAGE_EVENT_NOTIFICATION :: struct {
    Version : u32,
    Size    : u32,
    Events  : DWORDLONG,
 };
 PSTORAGE_EVENT_NOTIFICATION :: ^struct {
    Version : u32,
    Size    : u32,
    Events  : DWORDLONG,
 };

 STORAGE_COUNTER_TYPE :: enum {
    StorageCounterTypeUnknown = 0,
    StorageCounterTypeTemperatureCelsius,
    StorageCounterTypeTemperatureCelsiusMax,
    StorageCounterTypeReadErrorsTotal,
    StorageCounterTypeReadErrorsCorrected,
    StorageCounterTypeReadErrorsUncorrected,
    StorageCounterTypeWriteErrorsTotal,
    StorageCounterTypeWriteErrorsCorrected,
    StorageCounterTypeWriteErrorsUncorrected,
    StorageCounterTypeManufactureDate,
    StorageCounterTypeStartStopCycleCount,
    StorageCounterTypeStartStopCycleCountMax,
    StorageCounterTypeLoadUnloadCycleCount,
    StorageCounterTypeLoadUnloadCycleCountMax,
    StorageCounterTypeWearPercentage,
    StorageCounterTypeWearPercentageWarning,
    StorageCounterTypeWearPercentageMax,
    StorageCounterTypePowerOnHours,
    StorageCounterTypeReadLatency100NSMax,
    StorageCounterTypeWriteLatency100NSMax,
    StorageCounterTypeFlushLatency100NSMax,
    StorageCounterTypeMax,
 };
 PSTORAGE_COUNTER_TYPE :: ^enum {
    StorageCounterTypeUnknown = 0,
    StorageCounterTypeTemperatureCelsius,
    StorageCounterTypeTemperatureCelsiusMax,
    StorageCounterTypeReadErrorsTotal,
    StorageCounterTypeReadErrorsCorrected,
    StorageCounterTypeReadErrorsUncorrected,
    StorageCounterTypeWriteErrorsTotal,
    StorageCounterTypeWriteErrorsCorrected,
    StorageCounterTypeWriteErrorsUncorrected,
    StorageCounterTypeManufactureDate,
    StorageCounterTypeStartStopCycleCount,
    StorageCounterTypeStartStopCycleCountMax,
    StorageCounterTypeLoadUnloadCycleCount,
    StorageCounterTypeLoadUnloadCycleCountMax,
    StorageCounterTypeWearPercentage,
    StorageCounterTypeWearPercentageWarning,
    StorageCounterTypeWearPercentageMax,
    StorageCounterTypePowerOnHours,
    StorageCounterTypeReadLatency100NSMax,
    StorageCounterTypeWriteLatency100NSMax,
    StorageCounterTypeFlushLatency100NSMax,
    StorageCounterTypeMax,
 };

 STORAGE_COUNTER :: struct {
    Type  : STORAGE_COUNTER_TYPE,
    Value : struct #raw_union {
        ManufactureDate : struct {
            Week : u32,
            Year : u32,
        },
        AsUlonglong     : DWORDLONG,
    },
 };
 PSTORAGE_COUNTER :: ^struct {
    Type  : STORAGE_COUNTER_TYPE,
    Value : struct #raw_union {
        ManufactureDate : struct {
            Week : u32,
            Year : u32,
        },
        AsUlonglong     : DWORDLONG,
    },
 };

 STORAGE_COUNTERS :: struct {
    Version          : u32,
    Size             : u32,
    NumberOfCounters : u32,
    Counters         : [1]STORAGE_COUNTER,
 };
 PSTORAGE_COUNTERS :: ^struct {
    Version          : u32,
    Size             : u32,
    NumberOfCounters : u32,
    Counters         : [1]STORAGE_COUNTER,
 };

 STORAGE_HW_FIRMWARE_INFO_QUERY :: struct {
    Version  : u32,
    Size     : u32,
    Flags    : u32,
    Reserved : u32,
 };
 PSTORAGE_HW_FIRMWARE_INFO_QUERY :: ^struct {
    Version  : u32,
    Size     : u32,
    Flags    : u32,
    Reserved : u32,
 };

 STORAGE_HW_FIRMWARE_SLOT_INFO :: struct {
    Version    : u32,
    Size       : u32,
    SlotNumber : BYTE,
    ReadOnly   : ,
    Reserved0  : ,
    Reserved1  : [6]BYTE,
    Revision   : [16]BYTE,
 };
 PSTORAGE_HW_FIRMWARE_SLOT_INFO :: ^struct {
    Version    : u32,
    Size       : u32,
    SlotNumber : BYTE,
    ReadOnly   : ,
    Reserved0  : ,
    Reserved1  : [6]BYTE,
    Revision   : [16]BYTE,
 };

 STORAGE_HW_FIRMWARE_INFO :: struct {
    Version               : u32,
    Size                  : u32,
    SupportUpgrade        : ,
    Reserved0             : ,
    SlotCount             : BYTE,
    ActiveSlot            : BYTE,
    PendingActivateSlot   : BYTE,
    FirmwareShared        : BOOLEAN,
    Reserved              : [3]BYTE,
    ImagePayloadAlignment : u32,
    ImagePayloadMaxSize   : u32,
    Slot                  : [1]STORAGE_HW_FIRMWARE_SLOT_INFO,
 };
 PSTORAGE_HW_FIRMWARE_INFO :: ^struct {
    Version               : u32,
    Size                  : u32,
    SupportUpgrade        : ,
    Reserved0             : ,
    SlotCount             : BYTE,
    ActiveSlot            : BYTE,
    PendingActivateSlot   : BYTE,
    FirmwareShared        : BOOLEAN,
    Reserved              : [3]BYTE,
    ImagePayloadAlignment : u32,
    ImagePayloadMaxSize   : u32,
    Slot                  : [1]STORAGE_HW_FIRMWARE_SLOT_INFO,
 };

 STORAGE_HW_FIRMWARE_DOWNLOAD :: struct {
    Version     : u32,
    Size        : u32,
    Flags       : u32,
    Slot        : BYTE,
    Reserved    : [3]BYTE,
    Offset      : DWORDLONG,
    BufferSize  : DWORDLONG,
    ImageBuffer : [1]BYTE,
 };
 PSTORAGE_HW_FIRMWARE_DOWNLOAD :: ^struct {
    Version     : u32,
    Size        : u32,
    Flags       : u32,
    Slot        : BYTE,
    Reserved    : [3]BYTE,
    Offset      : DWORDLONG,
    BufferSize  : DWORDLONG,
    ImageBuffer : [1]BYTE,
 };

 STORAGE_HW_FIRMWARE_DOWNLOAD_V2 :: struct {
    Version     : u32,
    Size        : u32,
    Flags       : u32,
    Slot        : BYTE,
    Reserved    : [3]BYTE,
    Offset      : DWORDLONG,
    BufferSize  : DWORDLONG,
    ImageSize   : u32,
    Reserved2   : u32,
    ImageBuffer : [1]BYTE,
 };
 PSTORAGE_HW_FIRMWARE_DOWNLOAD_V2 :: ^struct {
    Version     : u32,
    Size        : u32,
    Flags       : u32,
    Slot        : BYTE,
    Reserved    : [3]BYTE,
    Offset      : DWORDLONG,
    BufferSize  : DWORDLONG,
    ImageSize   : u32,
    Reserved2   : u32,
    ImageBuffer : [1]BYTE,
 };

 STORAGE_HW_FIRMWARE_ACTIVATE :: struct {
    Version   : u32,
    Size      : u32,
    Flags     : u32,
    Slot      : BYTE,
    Reserved0 : [3]BYTE,
 };
 PSTORAGE_HW_FIRMWARE_ACTIVATE :: ^struct {
    Version   : u32,
    Size      : u32,
    Flags     : u32,
    Slot      : BYTE,
    Reserved0 : [3]BYTE,
 };

 STORAGE_PROTOCOL_COMMAND :: struct {
    Version                      : u32,
    Length                       : u32,
    ProtocolType                 : STORAGE_PROTOCOL_TYPE,
    Flags                        : u32,
    ReturnStatus                 : u32,
    ErrorCode                    : u32,
    CommandLength                : u32,
    ErrorInfoLength              : u32,
    DataToDeviceTransferLength   : u32,
    DataFromDeviceTransferLength : u32,
    TimeOutValue                 : u32,
    ErrorInfoOffset              : u32,
    DataToDeviceBufferOffset     : u32,
    DataFromDeviceBufferOffset   : u32,
    CommandSpecific              : u32,
    Reserved0                    : u32,
    FixedProtocolReturnData      : u32,
    Reserved1                    : [3]u32,
    Command                      : [1]BYTE,
 };
 PSTORAGE_PROTOCOL_COMMAND :: ^struct {
    Version                      : u32,
    Length                       : u32,
    ProtocolType                 : STORAGE_PROTOCOL_TYPE,
    Flags                        : u32,
    ReturnStatus                 : u32,
    ErrorCode                    : u32,
    CommandLength                : u32,
    ErrorInfoLength              : u32,
    DataToDeviceTransferLength   : u32,
    DataFromDeviceTransferLength : u32,
    TimeOutValue                 : u32,
    ErrorInfoOffset              : u32,
    DataToDeviceBufferOffset     : u32,
    DataFromDeviceBufferOffset   : u32,
    CommandSpecific              : u32,
    Reserved0                    : u32,
    FixedProtocolReturnData      : u32,
    Reserved1                    : [3]u32,
    Command                      : [1]BYTE,
 };

 STORAGE_ATTRIBUTE_MGMT_ACTION :: enum {
    StorAttributeMgmt_ClearAttribute = 0,
    StorAttributeMgmt_SetAttribute = 1,
    StorAttributeMgmt_ResetAttribute = 2,
 };
 PSTORAGE_ATTRIBUTE_MGMT_ACTION :: ^enum {
    StorAttributeMgmt_ClearAttribute = 0,
    StorAttributeMgmt_SetAttribute = 1,
    StorAttributeMgmt_ResetAttribute = 2,
 };

 STORAGE_ATTRIBUTE_MGMT :: struct {
    Version   : u32,
    Size      : u32,
    Action    : STORAGE_ATTRIBUTE_MGMT_ACTION,
    Attribute : u32,
 };
 PSTORAGE_ATTRIBUTE_MGMT :: ^struct {
    Version   : u32,
    Size      : u32,
    Action    : STORAGE_ATTRIBUTE_MGMT_ACTION,
    Attribute : u32,
 };

 SCM_PD_HEALTH_NOTIFICATION_DATA :: struct {
    DeviceGuid : GUID,
 };
 PSCM_PD_HEALTH_NOTIFICATION_DATA :: ^struct {
    DeviceGuid : GUID,
 };

 SCM_LOGICAL_DEVICE_INSTANCE :: struct {
    Version      : u32,
    Size         : u32,
    DeviceGuid   : GUID,
    SymbolicLink : [256]WCHAR,
 };
 PSCM_LOGICAL_DEVICE_INSTANCE :: ^struct {
    Version      : u32,
    Size         : u32,
    DeviceGuid   : GUID,
    SymbolicLink : [256]WCHAR,
 };

 SCM_LOGICAL_DEVICES :: struct {
    Version     : u32,
    Size        : u32,
    DeviceCount : u32,
    Devices     : [1]SCM_LOGICAL_DEVICE_INSTANCE,
 };
 PSCM_LOGICAL_DEVICES :: ^struct {
    Version     : u32,
    Size        : u32,
    DeviceCount : u32,
    Devices     : [1]SCM_LOGICAL_DEVICE_INSTANCE,
 };

 SCM_PHYSICAL_DEVICE_INSTANCE :: struct {
    Version      : u32,
    Size         : u32,
    NfitHandle   : u32,
    SymbolicLink : [256]WCHAR,
 };
 PSCM_PHYSICAL_DEVICE_INSTANCE :: ^struct {
    Version      : u32,
    Size         : u32,
    NfitHandle   : u32,
    SymbolicLink : [256]WCHAR,
 };

 SCM_PHYSICAL_DEVICES :: struct {
    Version     : u32,
    Size        : u32,
    DeviceCount : u32,
    Devices     : [1]SCM_PHYSICAL_DEVICE_INSTANCE,
 };
 PSCM_PHYSICAL_DEVICES :: ^struct {
    Version     : u32,
    Size        : u32,
    DeviceCount : u32,
    Devices     : [1]SCM_PHYSICAL_DEVICE_INSTANCE,
 };

 SCM_REGION_FLAG :: enum {
    ScmRegionFlagNone = 0x0,
    ScmRegionFlagLabel = 0x1,
 };
 PSCM_REGION_FLAG :: ^enum {
    ScmRegionFlagNone = 0x0,
    ScmRegionFlagLabel = 0x1,
 };

 SCM_REGION :: struct {
    Version           : u32,
    Size              : u32,
    Flags             : u32,
    NfitHandle        : u32,
    LogicalDeviceGuid : GUID,
    AddressRangeType  : GUID,
    AssociatedId      : u32,
    Length            : DWORD64,
    StartingDPA       : DWORD64,
    BaseSPA           : DWORD64,
    SPAOffset         : DWORD64,
    RegionOffset      : DWORD64,
 };
 PSCM_REGION :: ^struct {
    Version           : u32,
    Size              : u32,
    Flags             : u32,
    NfitHandle        : u32,
    LogicalDeviceGuid : GUID,
    AddressRangeType  : GUID,
    AssociatedId      : u32,
    Length            : DWORD64,
    StartingDPA       : DWORD64,
    BaseSPA           : DWORD64,
    SPAOffset         : DWORD64,
    RegionOffset      : DWORD64,
 };

 SCM_REGIONS :: struct {
    Version     : u32,
    Size        : u32,
    RegionCount : u32,
    Regions     : [1]SCM_REGION,
 };
 PSCM_REGIONS :: ^struct {
    Version     : u32,
    Size        : u32,
    RegionCount : u32,
    Regions     : [1]SCM_REGION,
 };

 SCM_INTERLEAVED_PD_INFO :: struct {
    DeviceHandle : u32,
    DeviceGuid   : GUID,
 };
 PSCM_INTERLEAVED_PD_INFO :: ^struct {
    DeviceHandle : u32,
    DeviceGuid   : GUID,
 };

 SCM_LD_INTERLEAVE_SET_INFO :: struct {
    Version           : u32,
    Size              : u32,
    InterleaveSetSize : u32,
    InterleaveSet     : [1]SCM_INTERLEAVED_PD_INFO,
 };
 PSCM_LD_INTERLEAVE_SET_INFO :: ^struct {
    Version           : u32,
    Size              : u32,
    InterleaveSetSize : u32,
    InterleaveSet     : [1]SCM_INTERLEAVED_PD_INFO,
 };

 SCM_PD_QUERY_TYPE :: enum {
    ScmPhysicalDeviceQuery_Descriptor = 0,
    ScmPhysicalDeviceQuery_IsSupported,
    ScmPhysicalDeviceQuery_Max,
 };
 PSCM_PD_QUERY_TYPE :: ^enum {
    ScmPhysicalDeviceQuery_Descriptor = 0,
    ScmPhysicalDeviceQuery_IsSupported,
    ScmPhysicalDeviceQuery_Max,
 };

 SCM_PD_PROPERTY_ID :: enum {
    ScmPhysicalDeviceProperty_DeviceInfo = 0,
    ScmPhysicalDeviceProperty_ManagementStatus,
    ScmPhysicalDeviceProperty_FirmwareInfo,
    ScmPhysicalDeviceProperty_LocationString,
    ScmPhysicalDeviceProperty_DeviceSpecificInfo,
    ScmPhysicalDeviceProperty_DeviceHandle,
    ScmPhysicalDeviceProperty_Max,
 };
 PSCM_PD_PROPERTY_ID :: ^enum {
    ScmPhysicalDeviceProperty_DeviceInfo = 0,
    ScmPhysicalDeviceProperty_ManagementStatus,
    ScmPhysicalDeviceProperty_FirmwareInfo,
    ScmPhysicalDeviceProperty_LocationString,
    ScmPhysicalDeviceProperty_DeviceSpecificInfo,
    ScmPhysicalDeviceProperty_DeviceHandle,
    ScmPhysicalDeviceProperty_Max,
 };

 SCM_PD_PROPERTY_QUERY :: struct {
    Version              : u32,
    Size                 : u32,
    PropertyId           : SCM_PD_PROPERTY_ID,
    QueryType            : SCM_PD_QUERY_TYPE,
    AdditionalParameters : [1]BYTE,
 };
 PSCM_PD_PROPERTY_QUERY :: ^struct {
    Version              : u32,
    Size                 : u32,
    PropertyId           : SCM_PD_PROPERTY_ID,
    QueryType            : SCM_PD_QUERY_TYPE,
    AdditionalParameters : [1]BYTE,
 };

 SCM_PD_DESCRIPTOR_HEADER :: struct {
    Version : u32,
    Size    : u32,
 };
 PSCM_PD_DESCRIPTOR_HEADER :: ^struct {
    Version : u32,
    Size    : u32,
 };

 SCM_PD_DEVICE_HANDLE :: struct {
    Version      : u32,
    Size         : u32,
    DeviceGuid   : GUID,
    DeviceHandle : u32,
 };
 PSCM_PD_DEVICE_HANDLE :: ^struct {
    Version      : u32,
    Size         : u32,
    DeviceGuid   : GUID,
    DeviceHandle : u32,
 };

 SCM_PD_DEVICE_INFO :: struct {
    Version                      : u32,
    Size                         : u32,
    DeviceGuid                   : GUID,
    UnsafeShutdownCount          : u32,
    PersistentMemorySizeInBytes  : DWORD64,
    VolatileMemorySizeInBytes    : DWORD64,
    TotalMemorySizeInBytes       : DWORD64,
    SlotNumber                   : u32,
    DeviceHandle                 : u32,
    PhysicalId                   : u16,
    NumberOfFormatInterfaceCodes : BYTE,
    FormatInterfaceCodes         : [8]u16,
    VendorId                     : u32,
    ProductId                    : u32,
    SubsystemDeviceId            : u32,
    SubsystemVendorId            : u32,
    ManufacturingLocation        : BYTE,
    ManufacturingWeek            : BYTE,
    ManufacturingYear            : BYTE,
    SerialNumber4Byte            : u32,
    SerialNumberLengthInChars    : u32,
    SerialNumber                 : [1]CHAR,
 };
 PSCM_PD_DEVICE_INFO :: ^struct {
    Version                      : u32,
    Size                         : u32,
    DeviceGuid                   : GUID,
    UnsafeShutdownCount          : u32,
    PersistentMemorySizeInBytes  : DWORD64,
    VolatileMemorySizeInBytes    : DWORD64,
    TotalMemorySizeInBytes       : DWORD64,
    SlotNumber                   : u32,
    DeviceHandle                 : u32,
    PhysicalId                   : u16,
    NumberOfFormatInterfaceCodes : BYTE,
    FormatInterfaceCodes         : [8]u16,
    VendorId                     : u32,
    ProductId                    : u32,
    SubsystemDeviceId            : u32,
    SubsystemVendorId            : u32,
    ManufacturingLocation        : BYTE,
    ManufacturingWeek            : BYTE,
    ManufacturingYear            : BYTE,
    SerialNumber4Byte            : u32,
    SerialNumberLengthInChars    : u32,
    SerialNumber                 : [1]CHAR,
 };

 SCM_PD_DEVICE_SPECIFIC_PROPERTY :: struct {
    Name  : [128]WCHAR,
    Value : LONGLONG,
 };
 PSCM_PD_DEVICE_SPECIFIC_PROPERTY :: ^struct {
    Name  : [128]WCHAR,
    Value : LONGLONG,
 };

 SCM_PD_DEVICE_SPECIFIC_INFO :: struct {
    Version                  : u32,
    Size                     : u32,
    NumberOfProperties       : u32,
    DeviceSpecificProperties : [1]SCM_PD_DEVICE_SPECIFIC_PROPERTY,
 };
 PSCM_PD_DEVICE_SPECIFIC_INFO :: ^struct {
    Version                  : u32,
    Size                     : u32,
    NumberOfProperties       : u32,
    DeviceSpecificProperties : [1]SCM_PD_DEVICE_SPECIFIC_PROPERTY,
 };

 SCM_PD_FIRMWARE_SLOT_INFO :: struct {
    Version    : u32,
    Size       : u32,
    SlotNumber : BYTE,
    ReadOnly   : ,
    Reserved0  : ,
    Reserved1  : [6]BYTE,
    Revision   : [32]BYTE,
 };
 PSCM_PD_FIRMWARE_SLOT_INFO :: ^struct {
    Version    : u32,
    Size       : u32,
    SlotNumber : BYTE,
    ReadOnly   : ,
    Reserved0  : ,
    Reserved1  : [6]BYTE,
    Revision   : [32]BYTE,
 };

 SCM_PD_FIRMWARE_INFO :: struct {
    Version        : u32,
    Size           : u32,
    ActiveSlot     : BYTE,
    NextActiveSlot : BYTE,
    SlotCount      : BYTE,
    Slots          : [1]SCM_PD_FIRMWARE_SLOT_INFO,
 };
 PSCM_PD_FIRMWARE_INFO :: ^struct {
    Version        : u32,
    Size           : u32,
    ActiveSlot     : BYTE,
    NextActiveSlot : BYTE,
    SlotCount      : BYTE,
    Slots          : [1]SCM_PD_FIRMWARE_SLOT_INFO,
 };

 SCM_PD_HEALTH_STATUS :: enum {
    ScmPhysicalDeviceHealth_Unknown = 0,
    ScmPhysicalDeviceHealth_Unhealthy,
    ScmPhysicalDeviceHealth_Warning,
    ScmPhysicalDeviceHealth_Healthy,
    ScmPhysicalDeviceHealth_Max,
 };
 PSCM_PD_HEALTH_STATUS :: ^enum {
    ScmPhysicalDeviceHealth_Unknown = 0,
    ScmPhysicalDeviceHealth_Unhealthy,
    ScmPhysicalDeviceHealth_Warning,
    ScmPhysicalDeviceHealth_Healthy,
    ScmPhysicalDeviceHealth_Max,
 };

 SCM_PD_OPERATIONAL_STATUS :: enum {
    ScmPhysicalDeviceOpStatus_Unknown = 0,
    ScmPhysicalDeviceOpStatus_Ok,
    ScmPhysicalDeviceOpStatus_PredictingFailure,
    ScmPhysicalDeviceOpStatus_InService,
    ScmPhysicalDeviceOpStatus_HardwareError,
    ScmPhysicalDeviceOpStatus_NotUsable,
    ScmPhysicalDeviceOpStatus_TransientError,
    ScmPhysicalDeviceOpStatus_Missing,
    ScmPhysicalDeviceOpStatus_Max,
 };
 PSCM_PD_OPERATIONAL_STATUS :: ^enum {
    ScmPhysicalDeviceOpStatus_Unknown = 0,
    ScmPhysicalDeviceOpStatus_Ok,
    ScmPhysicalDeviceOpStatus_PredictingFailure,
    ScmPhysicalDeviceOpStatus_InService,
    ScmPhysicalDeviceOpStatus_HardwareError,
    ScmPhysicalDeviceOpStatus_NotUsable,
    ScmPhysicalDeviceOpStatus_TransientError,
    ScmPhysicalDeviceOpStatus_Missing,
    ScmPhysicalDeviceOpStatus_Max,
 };

 SCM_PD_OPERATIONAL_STATUS_REASON :: enum {
    ScmPhysicalDeviceOpReason_Unknown = 0,
    ScmPhysicalDeviceOpReason_Media,
    ScmPhysicalDeviceOpReason_ThresholdExceeded,
    ScmPhysicalDeviceOpReason_LostData,
    ScmPhysicalDeviceOpReason_EnergySource,
    ScmPhysicalDeviceOpReason_Configuration,
    ScmPhysicalDeviceOpReason_DeviceController,
    ScmPhysicalDeviceOpReason_MediaController,
    ScmPhysicalDeviceOpReason_Component,
    ScmPhysicalDeviceOpReason_BackgroundOperation,
    ScmPhysicalDeviceOpReason_InvalidFirmware,
    ScmPhysicalDeviceOpReason_HealthCheck,
    ScmPhysicalDeviceOpReason_LostDataPersistence,
    ScmPhysicalDeviceOpReason_DisabledByPlatform,
    ScmPhysicalDeviceOpReason_PermanentError,
    ScmPhysicalDeviceOpReason_LostWritePersistence,
    ScmPhysicalDeviceOpReason_FatalError,
    ScmPhysicalDeviceOpReason_DataPersistenceLossImminent,
    ScmPhysicalDeviceOpReason_WritePersistenceLossImminent,
    ScmPhysicalDeviceOpReason_MediaRemainingSpareBlock,
    ScmPhysicalDeviceOpReason_PerformanceDegradation,
    ScmPhysicalDeviceOpReason_ExcessiveTemperature,
    ScmPhysicalDeviceOpReason_Max,
 };
 PSCM_PD_OPERATIONAL_STATUS_REASON :: ^enum {
    ScmPhysicalDeviceOpReason_Unknown = 0,
    ScmPhysicalDeviceOpReason_Media,
    ScmPhysicalDeviceOpReason_ThresholdExceeded,
    ScmPhysicalDeviceOpReason_LostData,
    ScmPhysicalDeviceOpReason_EnergySource,
    ScmPhysicalDeviceOpReason_Configuration,
    ScmPhysicalDeviceOpReason_DeviceController,
    ScmPhysicalDeviceOpReason_MediaController,
    ScmPhysicalDeviceOpReason_Component,
    ScmPhysicalDeviceOpReason_BackgroundOperation,
    ScmPhysicalDeviceOpReason_InvalidFirmware,
    ScmPhysicalDeviceOpReason_HealthCheck,
    ScmPhysicalDeviceOpReason_LostDataPersistence,
    ScmPhysicalDeviceOpReason_DisabledByPlatform,
    ScmPhysicalDeviceOpReason_PermanentError,
    ScmPhysicalDeviceOpReason_LostWritePersistence,
    ScmPhysicalDeviceOpReason_FatalError,
    ScmPhysicalDeviceOpReason_DataPersistenceLossImminent,
    ScmPhysicalDeviceOpReason_WritePersistenceLossImminent,
    ScmPhysicalDeviceOpReason_MediaRemainingSpareBlock,
    ScmPhysicalDeviceOpReason_PerformanceDegradation,
    ScmPhysicalDeviceOpReason_ExcessiveTemperature,
    ScmPhysicalDeviceOpReason_Max,
 };

 SCM_PD_MANAGEMENT_STATUS :: struct {
    Version                   : u32,
    Size                      : u32,
    Health                    : SCM_PD_HEALTH_STATUS,
    NumberOfOperationalStatus : u32,
    NumberOfAdditionalReasons : u32,
    OperationalStatus         : [16]SCM_PD_OPERATIONAL_STATUS,
    AdditionalReasons         : [1]SCM_PD_OPERATIONAL_STATUS_REASON,
 };
 PSCM_PD_MANAGEMENT_STATUS :: ^struct {
    Version                   : u32,
    Size                      : u32,
    Health                    : SCM_PD_HEALTH_STATUS,
    NumberOfOperationalStatus : u32,
    NumberOfAdditionalReasons : u32,
    OperationalStatus         : [16]SCM_PD_OPERATIONAL_STATUS,
    AdditionalReasons         : [1]SCM_PD_OPERATIONAL_STATUS_REASON,
 };

 SCM_PD_LOCATION_STRING :: struct {
    Version  : u32,
    Size
No results found