Odin bindings for `Windows.h`

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,