Rebrand to XenonRecomp.

2025-07-22 04:47:13 +00:00 · 2025-01-19 22:39:12 +03:00
parent 7fb8af1bad
commit 87e350906b
54 changed files with 69 additions and 64 deletions
--- a/XenonUtils/CMakeLists.txt
+++ b/XenonUtils/CMakeLists.txt
@@ -0,0 +1,10 @@
+project("XenonUtils")
+
+add_library(XenonUtils
+    "disasm.cpp" 
+    "xex.cpp" 
+    "image.cpp" 
+    "xdbf_wrapper.cpp")
+
+target_include_directories(XenonUtils PUBLIC .)
+target_link_libraries(XenonUtils PUBLIC disasm)
--- a/XenonUtils/byteswap.h
+++ b/XenonUtils/byteswap.h
@@ -0,0 +1,25 @@
+#pragma once 
+
+#include <cassert>
+
+template<typename T>
+inline T ByteSwap(T value)
+{
+    if constexpr (sizeof(T) == 1)
+        return value;
+    else if constexpr (sizeof(T) == 2)
+        return static_cast<T>(__builtin_bswap16(static_cast<uint16_t>(value)));
+    else if constexpr (sizeof(T) == 4)
+        return static_cast<T>(__builtin_bswap32(static_cast<uint32_t>(value)));
+    else if constexpr (sizeof(T) == 8)
+        return static_cast<T>(__builtin_bswap64(static_cast<uint64_t>(value)));
+
+    assert(false && "Unexpected byte size.");
+    return value;
+}
+
+template<typename T>
+inline void ByteSwapInplace(T& value)
+{
+    value = ByteSwap(value);
+}
--- a/XenonUtils/disasm.cpp
+++ b/XenonUtils/disasm.cpp
@@ -0,0 +1,33 @@
+#include "disasm.h"
+
+thread_local ppc::DisassemblerEngine ppc::gBigEndianDisassembler{ BFD_ENDIAN_BIG, "cell 64"};
+
+ppc::DisassemblerEngine::DisassemblerEngine(bfd_endian endian, const char* options)
+{
+    INIT_DISASSEMBLE_INFO(info, stdout, fprintf);
+    info.arch = bfd_arch_powerpc;
+    info.endian = endian;
+    info.disassembler_options = options;
+}
+
+int ppc::DisassemblerEngine::Disassemble(const void* code, size_t size, uint64_t base, ppc_insn& out)
+{
+    if (size < 4)
+    {
+        return 0;
+    }
+
+    info.buffer = (bfd_byte*)code;
+    info.buffer_vma = base;
+    info.buffer_length = size;
+    return decode_insn_ppc(base, &info, &out);
+}
+
+int ppc::Disassemble(const void* code, uint64_t base, ppc_insn* out, size_t nOut)
+{
+    for (size_t i = 0; i < nOut; i++)
+    {
+        Disassemble(static_cast<const uint32_t*>(code) + i, base, out[i]);
+    }
+    return static_cast<int>(nOut) * 4;
+}
--- a/XenonUtils/disasm.h
+++ b/XenonUtils/disasm.h
@@ -0,0 +1,35 @@
+#pragma once
+#include <dis-asm.h>
+#include <ppc.h>
+
+namespace ppc
+{
+    struct DisassemblerEngine
+    {
+        disassemble_info info{};
+        DisassemblerEngine(const DisassemblerEngine&) = default;
+        DisassemblerEngine& operator=(const DisassemblerEngine&) = delete;
+
+        DisassemblerEngine(bfd_endian endian, const char* options);
+        ~DisassemblerEngine() = default;
+
+        /**
+         * \return Numbers of bytes decoded
+         */
+        int Disassemble(const void* code, size_t size, uint64_t base, ppc_insn& out);
+    };
+
+    thread_local extern DisassemblerEngine gBigEndianDisassembler;
+
+    static int Disassemble(const void* code, size_t size, uint64_t base, ppc_insn& out)
+    {
+        return gBigEndianDisassembler.Disassemble(code, size, base, out);
+    }
+
+    static int Disassemble(const void* code, uint64_t base, ppc_insn& out)
+    {
+        return Disassemble(code, 4, base, out);
+    }
+
+    static int Disassemble(const void* code, uint64_t base, ppc_insn* out, size_t nOut);
+}
--- a/XenonUtils/elf.h
+++ b/XenonUtils/elf.h
@@ -0,0 +1,488 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _UAPI_LINUX_ELF_H
+#define _UAPI_LINUX_ELF_H
+
+typedef unsigned int __u32;
+typedef unsigned short __u16;
+
+typedef signed int __s32;
+typedef signed short __s16;
+
+typedef unsigned long long __u64;
+typedef signed long long __s64;
+
+/* 32-bit ELF base types. */
+typedef __u32	Elf32_Addr;
+typedef __u16	Elf32_Half;
+typedef __u32	Elf32_Off;
+typedef __s32	Elf32_Sword;
+typedef __u32	Elf32_Word;
+
+/* 64-bit ELF base types. */
+typedef __u64	Elf64_Addr;
+typedef __u16	Elf64_Half;
+typedef __s16	Elf64_SHalf;
+typedef __u64	Elf64_Off;
+typedef __s32	Elf64_Sword;
+typedef __u32	Elf64_Word;
+typedef __u64	Elf64_Xword;
+typedef __s64	Elf64_Sxword;
+
+/* These constants are for the segment types stored in the image headers */
+#define PT_NULL    0
+#define PT_LOAD    1
+#define PT_DYNAMIC 2
+#define PT_INTERP  3
+#define PT_NOTE    4
+#define PT_SHLIB   5
+#define PT_PHDR    6
+#define PT_TLS     7               /* Thread local storage segment */
+#define PT_LOOS    0x60000000      /* OS-specific */
+#define PT_HIOS    0x6fffffff      /* OS-specific */
+#define PT_LOPROC  0x70000000
+#define PT_HIPROC  0x7fffffff
+#define PT_GNU_EH_FRAME	(PT_LOOS + 0x474e550)
+#define PT_GNU_STACK	(PT_LOOS + 0x474e551)
+#define PT_GNU_RELRO	(PT_LOOS + 0x474e552)
+#define PT_GNU_PROPERTY	(PT_LOOS + 0x474e553)
+
+
+/* ARM MTE memory tag segment type */
+#define PT_AARCH64_MEMTAG_MTE	(PT_LOPROC + 0x2)
+
+/*
+ * Extended Numbering
+ *
+ * If the real number of program header table entries is larger than
+ * or equal to PN_XNUM(0xffff), it is set to sh_info field of the
+ * section header at index 0, and PN_XNUM is set to e_phnum
+ * field. Otherwise, the section header at index 0 is zero
+ * initialized, if it exists.
+ *
+ * Specifications are available in:
+ *
+ * - Oracle: Linker and Libraries.
+ *   Part No: 817<31>1984<38>19, August 2011.
+ *   https://docs.oracle.com/cd/E18752_01/pdf/817-1984.pdf
+ *
+ * - System V ABI AMD64 Architecture Processor Supplement
+ *   Draft Version 0.99.4,
+ *   January 13, 2010.
+ *   http://www.cs.washington.edu/education/courses/cse351/12wi/supp-docs/abi.pdf
+ */
+#define PN_XNUM 0xffff
+
+ /* These constants define the different elf file types */
+#define ET_NONE   0
+#define ET_REL    1
+#define ET_EXEC   2
+#define ET_DYN    3
+#define ET_CORE   4
+#define ET_LOPROC 0xff00
+#define ET_HIPROC 0xffff
+
+/* This is the info that is needed to parse the dynamic section of the file */
+#define DT_NULL		0
+#define DT_NEEDED	1
+#define DT_PLTRELSZ	2
+#define DT_PLTGOT	3
+#define DT_HASH		4
+#define DT_STRTAB	5
+#define DT_SYMTAB	6
+#define DT_RELA		7
+#define DT_RELASZ	8
+#define DT_RELAENT	9
+#define DT_STRSZ	10
+#define DT_SYMENT	11
+#define DT_INIT		12
+#define DT_FINI		13
+#define DT_SONAME	14
+#define DT_RPATH	15
+#define DT_SYMBOLIC	16
+#define DT_REL	        17
+#define DT_RELSZ	18
+#define DT_RELENT	19
+#define DT_PLTREL	20
+#define DT_DEBUG	21
+#define DT_TEXTREL	22
+#define DT_JMPREL	23
+#define DT_ENCODING	32
+#define OLD_DT_LOOS	0x60000000
+#define DT_LOOS		0x6000000d
+#define DT_HIOS		0x6ffff000
+#define DT_VALRNGLO	0x6ffffd00
+#define DT_VALRNGHI	0x6ffffdff
+#define DT_ADDRRNGLO	0x6ffffe00
+#define DT_ADDRRNGHI	0x6ffffeff
+#define DT_VERSYM	0x6ffffff0
+#define DT_RELACOUNT	0x6ffffff9
+#define DT_RELCOUNT	0x6ffffffa
+#define DT_FLAGS_1	0x6ffffffb
+#define DT_VERDEF	0x6ffffffc
+#define	DT_VERDEFNUM	0x6ffffffd
+#define DT_VERNEED	0x6ffffffe
+#define	DT_VERNEEDNUM	0x6fffffff
+#define OLD_DT_HIOS     0x6fffffff
+#define DT_LOPROC	0x70000000
+#define DT_HIPROC	0x7fffffff
+
+/* This info is needed when parsing the symbol table */
+#define STB_LOCAL  0
+#define STB_GLOBAL 1
+#define STB_WEAK   2
+
+#define STT_NOTYPE  0
+#define STT_OBJECT  1
+#define STT_FUNC    2
+#define STT_SECTION 3
+#define STT_FILE    4
+#define STT_COMMON  5
+#define STT_TLS     6
+
+#define ELF_ST_BIND(x)		((x) >> 4)
+#define ELF_ST_TYPE(x)		((x) & 0xf)
+#define ELF32_ST_BIND(x)	ELF_ST_BIND(x)
+#define ELF32_ST_TYPE(x)	ELF_ST_TYPE(x)
+#define ELF64_ST_BIND(x)	ELF_ST_BIND(x)
+#define ELF64_ST_TYPE(x)	ELF_ST_TYPE(x)
+
+typedef struct {
+    Elf32_Sword d_tag;
+    union {
+        Elf32_Sword	d_val;
+        Elf32_Addr	d_ptr;
+    } d_un;
+} Elf32_Dyn;
+
+typedef struct {
+    Elf64_Sxword d_tag;		/* entry tag value */
+    union {
+        Elf64_Xword d_val;
+        Elf64_Addr d_ptr;
+    } d_un;
+} Elf64_Dyn;
+
+/* The following are used with relocations */
+#define ELF32_R_SYM(x) ((x) >> 8)
+#define ELF32_R_TYPE(x) ((x) & 0xff)
+
+#define ELF64_R_SYM(i)			((i) >> 32)
+#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
+
+typedef struct elf32_rel {
+    Elf32_Addr	r_offset;
+    Elf32_Word	r_info;
+} Elf32_Rel;
+
+typedef struct elf64_rel {
+    Elf64_Addr r_offset;	/* Location at which to apply the action */
+    Elf64_Xword r_info;	/* index and type of relocation */
+} Elf64_Rel;
+
+typedef struct elf32_rela {
+    Elf32_Addr	r_offset;
+    Elf32_Word	r_info;
+    Elf32_Sword	r_addend;
+} Elf32_Rela;
+
+typedef struct elf64_rela {
+    Elf64_Addr r_offset;	/* Location at which to apply the action */
+    Elf64_Xword r_info;	/* index and type of relocation */
+    Elf64_Sxword r_addend;	/* Constant addend used to compute value */
+} Elf64_Rela;
+
+typedef struct elf32_sym {
+    Elf32_Word	st_name;
+    Elf32_Addr	st_value;
+    Elf32_Word	st_size;
+    unsigned char	st_info;
+    unsigned char	st_other;
+    Elf32_Half	st_shndx;
+} Elf32_Sym;
+
+typedef struct elf64_sym {
+    Elf64_Word st_name;		/* Symbol name, index in string tbl */
+    unsigned char	st_info;	/* Type and binding attributes */
+    unsigned char	st_other;	/* No defined meaning, 0 */
+    Elf64_Half st_shndx;		/* Associated section index */
+    Elf64_Addr st_value;		/* Value of the symbol */
+    Elf64_Xword st_size;		/* Associated symbol size */
+} Elf64_Sym;
+
+
+#define EI_NIDENT	16
+
+typedef struct elf32_hdr {
+    unsigned char	e_ident[EI_NIDENT];
+    Elf32_Half	e_type;
+    Elf32_Half	e_machine;
+    Elf32_Word	e_version;
+    Elf32_Addr	e_entry;  /* Entry point */
+    Elf32_Off	e_phoff;
+    Elf32_Off	e_shoff;
+    Elf32_Word	e_flags;
+    Elf32_Half	e_ehsize;
+    Elf32_Half	e_phentsize;
+    Elf32_Half	e_phnum;
+    Elf32_Half	e_shentsize;
+    Elf32_Half	e_shnum;
+    Elf32_Half	e_shstrndx;
+} Elf32_Ehdr;
+
+typedef struct elf64_hdr {
+    unsigned char	e_ident[EI_NIDENT];	/* ELF "magic number" */
+    Elf64_Half e_type;
+    Elf64_Half e_machine;
+    Elf64_Word e_version;
+    Elf64_Addr e_entry;		/* Entry point virtual address */
+    Elf64_Off e_phoff;		/* Program header table file offset */
+    Elf64_Off e_shoff;		/* Section header table file offset */
+    Elf64_Word e_flags;
+    Elf64_Half e_ehsize;
+    Elf64_Half e_phentsize;
+    Elf64_Half e_phnum;
+    Elf64_Half e_shentsize;
+    Elf64_Half e_shnum;
+    Elf64_Half e_shstrndx;
+} Elf64_Ehdr;
+
+/* These constants define the permissions on sections in the program
+   header, p_flags. */
+#define PF_R		0x4
+#define PF_W		0x2
+#define PF_X		0x1
+
+typedef struct elf32_phdr {
+    Elf32_Word	p_type;
+    Elf32_Off	p_offset;
+    Elf32_Addr	p_vaddr;
+    Elf32_Addr	p_paddr;
+    Elf32_Word	p_filesz;
+    Elf32_Word	p_memsz;
+    Elf32_Word	p_flags;
+    Elf32_Word	p_align;
+} Elf32_Phdr;
+
+typedef struct elf64_phdr {
+    Elf64_Word p_type;
+    Elf64_Word p_flags;
+    Elf64_Off p_offset;		/* Segment file offset */
+    Elf64_Addr p_vaddr;		/* Segment virtual address */
+    Elf64_Addr p_paddr;		/* Segment physical address */
+    Elf64_Xword p_filesz;		/* Segment size in file */
+    Elf64_Xword p_memsz;		/* Segment size in memory */
+    Elf64_Xword p_align;		/* Segment alignment, file & memory */
+} Elf64_Phdr;
+
+/* sh_type */
+#define SHT_NULL	0
+#define SHT_PROGBITS	1
+#define SHT_SYMTAB	2
+#define SHT_STRTAB	3
+#define SHT_RELA	4
+#define SHT_HASH	5
+#define SHT_DYNAMIC	6
+#define SHT_NOTE	7
+#define SHT_NOBITS	8
+#define SHT_REL		9
+#define SHT_SHLIB	10
+#define SHT_DYNSYM	11
+#define SHT_NUM		12
+#define SHT_LOPROC	0x70000000
+#define SHT_HIPROC	0x7fffffff
+#define SHT_LOUSER	0x80000000
+#define SHT_HIUSER	0xffffffff
+
+/* sh_flags */
+#define SHF_WRITE		0x1
+#define SHF_ALLOC		0x2
+#define SHF_EXECINSTR		0x4
+#define SHF_RELA_LIVEPATCH	0x00100000
+#define SHF_RO_AFTER_INIT	0x00200000
+#define SHF_MASKPROC		0xf0000000
+
+/* special section indexes */
+#define SHN_UNDEF	0
+#define SHN_LORESERVE	0xff00
+#define SHN_LOPROC	0xff00
+#define SHN_HIPROC	0xff1f
+#define SHN_LIVEPATCH	0xff20
+#define SHN_ABS		0xfff1
+#define SHN_COMMON	0xfff2
+#define SHN_HIRESERVE	0xffff
+
+typedef struct elf32_shdr {
+    Elf32_Word	sh_name;
+    Elf32_Word	sh_type;
+    Elf32_Word	sh_flags;
+    Elf32_Addr	sh_addr;
+    Elf32_Off	sh_offset;
+    Elf32_Word	sh_size;
+    Elf32_Word	sh_link;
+    Elf32_Word	sh_info;
+    Elf32_Word	sh_addralign;
+    Elf32_Word	sh_entsize;
+} Elf32_Shdr;
+
+typedef struct elf64_shdr {
+    Elf64_Word sh_name;		/* Section name, index in string tbl */
+    Elf64_Word sh_type;		/* Type of section */
+    Elf64_Xword sh_flags;		/* Miscellaneous section attributes */
+    Elf64_Addr sh_addr;		/* Section virtual addr at execution */
+    Elf64_Off sh_offset;		/* Section file offset */
+    Elf64_Xword sh_size;		/* Size of section in bytes */
+    Elf64_Word sh_link;		/* Index of another section */
+    Elf64_Word sh_info;		/* Additional section information */
+    Elf64_Xword sh_addralign;	/* Section alignment */
+    Elf64_Xword sh_entsize;	/* Entry size if section holds table */
+} Elf64_Shdr;
+
+#define	EI_MAG0		0		/* e_ident[] indexes */
+#define	EI_MAG1		1
+#define	EI_MAG2		2
+#define	EI_MAG3		3
+#define	EI_CLASS	4
+#define	EI_DATA		5
+#define	EI_VERSION	6
+#define	EI_OSABI	7
+#define	EI_PAD		8
+
+#define	ELFMAG0		0x7f		/* EI_MAG */
+#define	ELFMAG1		'E'
+#define	ELFMAG2		'L'
+#define	ELFMAG3		'F'
+#define	ELFMAG		"\177ELF"
+#define	SELFMAG		4
+
+#define	ELFCLASSNONE	0		/* EI_CLASS */
+#define	ELFCLASS32	1
+#define	ELFCLASS64	2
+#define	ELFCLASSNUM	3
+
+#define ELFDATANONE	0		/* e_ident[EI_DATA] */
+#define ELFDATA2LSB	1
+#define ELFDATA2MSB	2
+
+#define EV_NONE		0		/* e_version, EI_VERSION */
+#define EV_CURRENT	1
+#define EV_NUM		2
+
+#define ELFOSABI_NONE	0
+#define ELFOSABI_LINUX	3
+
+#ifndef ELF_OSABI
+#define ELF_OSABI ELFOSABI_NONE
+#endif
+
+/*
+ * Notes used in ET_CORE. Architectures export some of the arch register sets
+ * using the corresponding note types via the PTRACE_GETREGSET and
+ * PTRACE_SETREGSET requests.
+ * The note name for these types is "LINUX", except NT_PRFPREG that is named
+ * "CORE".
+ */
+#define NT_PRSTATUS	1
+#define NT_PRFPREG	2
+#define NT_PRPSINFO	3
+#define NT_TASKSTRUCT	4
+#define NT_AUXV		6
+ /*
+  * Note to userspace developers: size of NT_SIGINFO note may increase
+  * in the future to accomodate more fields, don't assume it is fixed!
+  */
+#define NT_SIGINFO      0x53494749
+#define NT_FILE         0x46494c45
+#define NT_PRXFPREG     0x46e62b7f      /* copied from gdb5.1/include/elf/common.h */
+#define NT_PPC_VMX	0x100		/* PowerPC Altivec/VMX registers */
+#define NT_PPC_SPE	0x101		/* PowerPC SPE/EVR registers */
+#define NT_PPC_VSX	0x102		/* PowerPC VSX registers */
+#define NT_PPC_TAR	0x103		/* Target Address Register */
+#define NT_PPC_PPR	0x104		/* Program Priority Register */
+#define NT_PPC_DSCR	0x105		/* Data Stream Control Register */
+#define NT_PPC_EBB	0x106		/* Event Based Branch Registers */
+#define NT_PPC_PMU	0x107		/* Performance Monitor Registers */
+#define NT_PPC_TM_CGPR	0x108		/* TM checkpointed GPR Registers */
+#define NT_PPC_TM_CFPR	0x109		/* TM checkpointed FPR Registers */
+#define NT_PPC_TM_CVMX	0x10a		/* TM checkpointed VMX Registers */
+#define NT_PPC_TM_CVSX	0x10b		/* TM checkpointed VSX Registers */
+#define NT_PPC_TM_SPR	0x10c		/* TM Special Purpose Registers */
+#define NT_PPC_TM_CTAR	0x10d		/* TM checkpointed Target Address Register */
+#define NT_PPC_TM_CPPR	0x10e		/* TM checkpointed Program Priority Register */
+#define NT_PPC_TM_CDSCR	0x10f		/* TM checkpointed Data Stream Control Register */
+#define NT_PPC_PKEY	0x110		/* Memory Protection Keys registers */
+#define NT_PPC_DEXCR	0x111		/* PowerPC DEXCR registers */
+#define NT_PPC_HASHKEYR	0x112		/* PowerPC HASHKEYR register */
+#define NT_386_TLS	0x200		/* i386 TLS slots (struct user_desc) */
+#define NT_386_IOPERM	0x201		/* x86 io permission bitmap (1=deny) */
+#define NT_X86_XSTATE	0x202		/* x86 extended state using xsave */
+  /* Old binutils treats 0x203 as a CET state */
+#define NT_X86_SHSTK	0x204		/* x86 SHSTK state */
+#define NT_S390_HIGH_GPRS	0x300	/* s390 upper register halves */
+#define NT_S390_TIMER	0x301		/* s390 timer register */
+#define NT_S390_TODCMP	0x302		/* s390 TOD clock comparator register */
+#define NT_S390_TODPREG	0x303		/* s390 TOD programmable register */
+#define NT_S390_CTRS	0x304		/* s390 control registers */
+#define NT_S390_PREFIX	0x305		/* s390 prefix register */
+#define NT_S390_LAST_BREAK	0x306	/* s390 breaking event address */
+#define NT_S390_SYSTEM_CALL	0x307	/* s390 system call restart data */
+#define NT_S390_TDB	0x308		/* s390 transaction diagnostic block */
+#define NT_S390_VXRS_LOW	0x309	/* s390 vector registers 0-15 upper half */
+#define NT_S390_VXRS_HIGH	0x30a	/* s390 vector registers 16-31 */
+#define NT_S390_GS_CB	0x30b		/* s390 guarded storage registers */
+#define NT_S390_GS_BC	0x30c		/* s390 guarded storage broadcast control block */
+#define NT_S390_RI_CB	0x30d		/* s390 runtime instrumentation */
+#define NT_S390_PV_CPU_DATA	0x30e	/* s390 protvirt cpu dump data */
+#define NT_ARM_VFP	0x400		/* ARM VFP/NEON registers */
+#define NT_ARM_TLS	0x401		/* ARM TLS register */
+#define NT_ARM_HW_BREAK	0x402		/* ARM hardware breakpoint registers */
+#define NT_ARM_HW_WATCH	0x403		/* ARM hardware watchpoint registers */
+#define NT_ARM_SYSTEM_CALL	0x404	/* ARM system call number */
+#define NT_ARM_SVE	0x405		/* ARM Scalable Vector Extension registers */
+#define NT_ARM_PAC_MASK		0x406	/* ARM pointer authentication code masks */
+#define NT_ARM_PACA_KEYS	0x407	/* ARM pointer authentication address keys */
+#define NT_ARM_PACG_KEYS	0x408	/* ARM pointer authentication generic key */
+#define NT_ARM_TAGGED_ADDR_CTRL	0x409	/* arm64 tagged address control (prctl()) */
+#define NT_ARM_PAC_ENABLED_KEYS	0x40a	/* arm64 ptr auth enabled keys (prctl()) */
+#define NT_ARM_SSVE	0x40b		/* ARM Streaming SVE registers */
+#define NT_ARM_ZA	0x40c		/* ARM SME ZA registers */
+#define NT_ARM_ZT	0x40d		/* ARM SME ZT registers */
+#define NT_ARM_FPMR	0x40e		/* ARM floating point mode register */
+#define NT_ARC_V2	0x600		/* ARCv2 accumulator/extra registers */
+#define NT_VMCOREDD	0x700		/* Vmcore Device Dump Note */
+#define NT_MIPS_DSP	0x800		/* MIPS DSP ASE registers */
+#define NT_MIPS_FP_MODE	0x801		/* MIPS floating-point mode */
+#define NT_MIPS_MSA	0x802		/* MIPS SIMD registers */
+#define NT_RISCV_CSR	0x900		/* RISC-V Control and Status Registers */
+#define NT_RISCV_VECTOR	0x901		/* RISC-V vector registers */
+#define NT_LOONGARCH_CPUCFG	0xa00	/* LoongArch CPU config registers */
+#define NT_LOONGARCH_CSR	0xa01	/* LoongArch control and status registers */
+#define NT_LOONGARCH_LSX	0xa02	/* LoongArch Loongson SIMD Extension registers */
+#define NT_LOONGARCH_LASX	0xa03	/* LoongArch Loongson Advanced SIMD Extension registers */
+#define NT_LOONGARCH_LBT	0xa04	/* LoongArch Loongson Binary Translation registers */
+#define NT_LOONGARCH_HW_BREAK	0xa05   /* LoongArch hardware breakpoint registers */
+#define NT_LOONGARCH_HW_WATCH	0xa06   /* LoongArch hardware watchpoint registers */
+
+/* Note types with note name "GNU" */
+#define NT_GNU_PROPERTY_TYPE_0	5
+
+/* Note header in a PT_NOTE section */
+typedef struct elf32_note {
+    Elf32_Word	n_namesz;	/* Name size */
+    Elf32_Word	n_descsz;	/* Content size */
+    Elf32_Word	n_type;		/* Content type */
+} Elf32_Nhdr;
+
+/* Note header in a PT_NOTE section */
+typedef struct elf64_note {
+    Elf64_Word n_namesz;	/* Name size */
+    Elf64_Word n_descsz;	/* Content size */
+    Elf64_Word n_type;	/* Content type */
+} Elf64_Nhdr;
+
+/* .note.gnu.property types for EM_AARCH64: */
+#define GNU_PROPERTY_AARCH64_FEATURE_1_AND	0xc0000000
+
+/* Bits for GNU_PROPERTY_AARCH64_FEATURE_1_BTI */
+#define GNU_PROPERTY_AARCH64_FEATURE_1_BTI	(1U << 0)
+
+#endif /* _UAPI_LINUX_ELF_H */
--- a/XenonUtils/file.h
+++ b/XenonUtils/file.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <filesystem>
+#include <fstream>
+#include <vector>
+
+inline std::vector<uint8_t> LoadFile(const std::filesystem::path& path)
+{
+    std::ifstream stream(path, std::ios::binary);
+    if (!stream.is_open())
+    {
+        return {};
+    }
+
+    stream.seekg(0, std::ios::end);
+    std::streampos size = stream.tellg();
+    stream.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> data;
+    data.resize(size);
+    stream.read((char *)(data.data()), size);
+    if (stream.bad())
+    {
+        return {};
+    }
+
+    return data;
+}
--- a/XenonUtils/image.cpp
+++ b/XenonUtils/image.cpp
@@ -0,0 +1,99 @@
+#include "image.h"
+#include "elf.h"
+#include "xex.h"
+#include <cassert>
+#include <cstring>
+
+void Image::Map(const std::string_view& name, size_t base, uint32_t size, uint8_t flags, uint8_t* data)
+{
+    sections.insert({ std::string(name), this->base + base,
+        size, static_cast<SectionFlags>(flags), data });
+}
+
+const void* Image::Find(size_t address) const
+{
+    const auto section = std::prev(sections.upper_bound(address));
+    return section->data + (address - section->base);
+}
+
+const Section* Image::Find(const std::string_view& name) const
+{
+    for (const auto& section : sections)
+    {
+        if (section.name == name)
+        {
+            return &section;
+        }
+    }
+
+    return nullptr;
+}
+
+Image Image::ParseImage(const uint8_t* data, size_t size)
+{
+    if (data[0] == ELFMAG0 && data[1] == ELFMAG1 && data[2] == ELFMAG2 && data[3] == ELFMAG3)
+    {
+        return ElfLoadImage(data, size);
+    }
+    else if (data[0] == 'X' && data[1] == 'E' && data[2] == 'X' && data[3] == '2')
+    {
+        return Xex2LoadImage(data);
+    }
+
+    return {};
+}
+
+Image ElfLoadImage(const uint8_t* data, size_t size)
+{
+    const auto* header = (elf32_hdr*)data;
+    assert(header->e_ident[EI_DATA] == 2);
+
+    Image image{};
+    image.size = size;
+    image.data = std::make_unique<uint8_t[]>(size);
+    image.entry_point = ByteSwap(header->e_entry);
+    memcpy(image.data.get(), data, size);
+
+    auto stringTableIndex = ByteSwap(header->e_shstrndx);
+
+    const auto numSections = ByteSwap(header->e_shnum);
+    const auto numpSections = ByteSwap(header->e_phnum);
+
+    const auto* sections = (elf32_shdr*)(data + ByteSwap(header->e_shoff));
+    const auto* psections = (elf32_phdr*)(data + ByteSwap(header->e_phoff));
+
+    for (size_t i = 0; i < numpSections; i++)
+    {
+        if (psections[i].p_type == ByteSwap((Elf32_Word)PT_LOAD))
+        {
+            image.base = ByteSwap(psections[i].p_vaddr);
+            break;
+        }
+    }
+
+    auto* stringTable = reinterpret_cast<const char*>(data + ByteSwap(sections[stringTableIndex].sh_offset));
+
+    for (size_t i = 0; i < numSections; i++)
+    {
+        const auto& section = sections[i];
+        if (section.sh_type == 0)
+        {
+            continue;
+        }
+
+        uint8_t flags{};
+
+        if (section.sh_flags & ByteSwap(SHF_EXECINSTR))
+        {
+            flags |= SectionFlags_Code;
+        }
+
+        auto* name = section.sh_name != 0 ? stringTable + ByteSwap(section.sh_name) : nullptr;
+        const auto rva = ByteSwap(section.sh_addr) - image.base;
+        const auto size = ByteSwap(section.sh_size);
+
+        image.Map(name, rva, size, flags, image.data.get() + ByteSwap(section.sh_offset));
+    }
+
+    return image;
+}
--- a/XenonUtils/image.h
+++ b/XenonUtils/image.h
@@ -0,0 +1,50 @@
+#pragma once
+#include <memory>
+#include <string>
+#include <set>
+#include <expected>
+#include <section.h>
+#include "symbol_table.h"
+
+struct Image
+{
+    std::unique_ptr<uint8_t[]> data{};
+    size_t base{};
+    uint32_t size{};
+
+    size_t entry_point{};
+    std::set<Section, SectionComparer> sections{};
+    SymbolTable symbols{};
+
+    /**
+     * \brief Map data to image by RVA
+     * \param name Name of section
+     * \param base Section RVA
+     * \param size Section Size
+     * \param flags Section Flags, enum SectionFlags
+     * \param data Section data
+     */
+    void Map(const std::string_view& name, size_t base, uint32_t size, uint8_t flags, uint8_t* data);
+
+    /**
+     * \param address Virtual Address
+     * \return Pointer to image owned data
+     */
+    const void* Find(size_t address) const;
+
+    /**
+     * \param name Name of section
+     * \return Section
+     */
+    const Section* Find(const std::string_view& name) const;
+
+    /**
+     * \brief Parse given data to an image, reallocates with ownership
+     * \param data Pointer to data
+     * \param size Size of data
+     * \return Parsed image
+     */
+    static Image ParseImage(const uint8_t* data, size_t size);
+};
+
+Image ElfLoadImage(const uint8_t* data, size_t size);
--- a/XenonUtils/ppc_context.h
+++ b/XenonUtils/ppc_context.h
@@ -0,0 +1,660 @@
+#ifndef PPC_CONTEXT_H_INCLUDED
+#define PPC_CONTEXT_H_INCLUDED
+
+#ifndef PPC_CONFIG_H_INCLUDED
+#error "ppc_config.h must be included before ppc_context.h"
+#endif
+
+#include <climits>
+#include <cmath>
+#include <csetjmp>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+
+#include <x86intrin.h>
+
+#ifdef _WIN32
+#include <intrin.h>
+#else
+#include <xmmintrin.h>
+#include <smmintrin.h>
+#endif
+
+#define PPC_JOIN(x, y) x##y
+#define PPC_XSTRINGIFY(x) #x
+#define PPC_STRINGIFY(x) PPC_XSTRINGIFY(x)
+#define PPC_FUNC(x) void x(PPCContext& __restrict ctx, uint8_t* base)
+#define PPC_FUNC_IMPL(x) extern "C" PPC_FUNC(x)
+#define PPC_EXTERN_FUNC(x) extern PPC_FUNC(x)
+#define PPC_WEAK_FUNC(x) __attribute__((weak,noinline)) PPC_FUNC(x)
+
+#define PPC_FUNC_PROLOGUE() __builtin_assume(((size_t)base & 0xFFFFFFFF) == 0)
+
+#ifndef PPC_LOAD_U8
+#define PPC_LOAD_U8(x) *(volatile uint8_t*)(base + (x))
+#endif
+
+#ifndef PPC_LOAD_U16
+#define PPC_LOAD_U16(x) __builtin_bswap16(*(volatile uint16_t*)(base + (x)))
+#endif
+
+#ifndef PPC_LOAD_U32
+#define PPC_LOAD_U32(x) __builtin_bswap32(*(volatile uint32_t*)(base + (x)))
+#endif
+
+#ifndef PPC_LOAD_U64
+#define PPC_LOAD_U64(x) __builtin_bswap64(*(volatile uint64_t*)(base + (x)))
+#endif
+
+// TODO: Implement.
+// These are currently unused. However, MMIO loads could possibly be handled statically with some profiling and a fallback.
+// The fallback would be a runtime exception handler which will intercept reads from MMIO regions 
+// and log the PC for compiling to static code later.
+#ifndef PPC_MM_LOAD_U8
+#define PPC_MM_LOAD_U8(x)  PPC_LOAD_U8 (x)
+#endif
+
+#ifndef PPC_MM_LOAD_U16
+#define PPC_MM_LOAD_U16(x) PPC_LOAD_U16(x)
+#endif
+
+#ifndef PPC_MM_LOAD_U32
+#define PPC_MM_LOAD_U32(x) PPC_LOAD_U32(x)
+#endif
+
+#ifndef PPC_MM_LOAD_U64
+#define PPC_MM_LOAD_U64(x) PPC_LOAD_U64(x)
+#endif
+
+#ifndef PPC_STORE_U8
+#define PPC_STORE_U8(x, y) *(volatile uint8_t*)(base + (x)) = (y)
+#endif
+
+#ifndef PPC_STORE_U16
+#define PPC_STORE_U16(x, y) *(volatile uint16_t*)(base + (x)) = __builtin_bswap16(y)
+#endif
+
+#ifndef PPC_STORE_U32
+#define PPC_STORE_U32(x, y) *(volatile uint32_t*)(base + (x)) = __builtin_bswap32(y)
+#endif
+
+#ifndef PPC_STORE_U64
+#define PPC_STORE_U64(x, y) *(volatile uint64_t*)(base + (x)) = __builtin_bswap64(y)
+#endif
+
+// MMIO Store handling is completely reliant on being preeceded by eieio.
+// TODO: Verify if that's always the case.
+#ifndef PPC_MM_STORE_U8
+#define PPC_MM_STORE_U8(x, y)   PPC_STORE_U8 (x, y)
+#endif
+
+#ifndef PPC_MM_STORE_U16
+#define PPC_MM_STORE_U16(x, y)  PPC_STORE_U16(x, y)
+#endif
+
+#ifndef PPC_MM_STORE_U32
+#define PPC_MM_STORE_U32(x, y)  PPC_STORE_U32(x, y)
+#endif
+
+#ifndef PPC_MM_STORE_U64
+#define PPC_MM_STORE_U64(x, y)  PPC_STORE_U64(x, y)
+#endif
+
+#ifndef PPC_CALL_FUNC
+#define PPC_CALL_FUNC(x) x(ctx, base)
+#endif
+
+#define PPC_MEMORY_SIZE 0x100000000ull
+
+#define PPC_LOOKUP_FUNC(x, y) *(PPCFunc**)(x + PPC_IMAGE_BASE + PPC_IMAGE_SIZE + (uint64_t(uint32_t(y) - PPC_CODE_BASE) * 2))
+
+#ifndef PPC_CALL_INDIRECT_FUNC
+#define PPC_CALL_INDIRECT_FUNC(x) (PPC_LOOKUP_FUNC(base, x))(ctx, base)
+#endif
+
+typedef void PPCFunc(struct PPCContext& __restrict__ ctx, uint8_t* base);
+
+struct PPCFuncMapping
+{
+    size_t guest;
+    PPCFunc* host;
+};
+
+extern PPCFuncMapping PPCFuncMappings[];
+
+struct PPCRegister
+{
+    union
+    {
+        int8_t s8;
+        uint8_t u8;
+        int16_t s16;
+        uint16_t u16;
+        int32_t s32;
+        uint32_t u32;
+        int64_t s64;
+        uint64_t u64;
+        float f32;
+        double f64;
+    };
+};
+
+struct PPCXERRegister
+{
+    uint8_t so;
+    uint8_t ov;
+    uint8_t ca;
+};
+
+struct PPCCRRegister
+{
+    uint8_t lt;
+    uint8_t gt;
+    uint8_t eq;
+    union
+    {
+        uint8_t so;
+        uint8_t un;
+    };
+
+    template<typename T>
+    inline void compare(T left, T right, const PPCXERRegister& xer) noexcept
+    {
+        lt = left < right;
+        gt = left > right;
+        eq = left == right;
+        so = xer.so;
+    }
+
+    inline void compare(double left, double right) noexcept
+    {
+        un = __builtin_isnan(left) || __builtin_isnan(right);
+        lt = !un && (left < right);
+        gt = !un && (left > right);
+        eq = !un && (left == right);
+    }
+
+    inline void setFromMask(__m128 mask, int imm) noexcept
+    {
+        int m = _mm_movemask_ps(mask);
+        lt = m == imm; // all equal
+        gt = 0;
+        eq = m == 0; // none equal
+        so = 0;
+    }
+
+    inline void setFromMask(__m128i mask, int imm) noexcept
+    {
+        int m = _mm_movemask_epi8(mask);
+        lt = m == imm; // all equal
+        gt = 0;
+        eq = m == 0; // none equal
+        so = 0;
+    }
+};
+
+struct alignas(0x10) PPCVRegister
+{
+    union
+    {
+        int8_t s8[16];
+        uint8_t u8[16];
+        int16_t s16[8];
+        uint16_t u16[8];
+        int32_t s32[4];
+        uint32_t u32[4];
+        int64_t s64[2];
+        uint64_t u64[2];
+        float f32[4];
+        double f64[2];
+    };
+};
+
+#define PPC_ROUND_NEAREST 0x00
+#define PPC_ROUND_TOWARD_ZERO 0x01
+#define PPC_ROUND_UP 0x02
+#define PPC_ROUND_DOWN 0x03
+#define PPC_ROUND_MASK 0x03
+
+struct PPCFPSCRRegister
+{
+    uint32_t csr;
+
+    static constexpr size_t GuestToHost[] = { _MM_ROUND_NEAREST, _MM_ROUND_TOWARD_ZERO, _MM_ROUND_UP, _MM_ROUND_DOWN };
+    static constexpr size_t HostToGuest[] = { PPC_ROUND_NEAREST, PPC_ROUND_DOWN, PPC_ROUND_UP, PPC_ROUND_TOWARD_ZERO };
+
+    inline uint32_t loadFromHost() noexcept
+    {
+        csr = _mm_getcsr();
+        return HostToGuest[(csr & _MM_ROUND_MASK) >> 13];
+    }
+        
+    inline void storeFromGuest(uint32_t value) noexcept
+    {
+        csr &= ~_MM_ROUND_MASK;
+        csr |= GuestToHost[value & PPC_ROUND_MASK];
+        _mm_setcsr(csr);
+    }
+
+    static constexpr size_t FlushMask = _MM_FLUSH_ZERO_MASK | _MM_DENORMALS_ZERO_MASK;
+
+    inline void enableFlushModeUnconditional() noexcept
+    {
+        csr |= FlushMask;
+        _mm_setcsr(csr);
+    }
+
+    inline void disableFlushModeUnconditional() noexcept
+    {
+        csr &= ~FlushMask;
+        _mm_setcsr(csr);
+    }
+
+    inline void enableFlushMode() noexcept
+    {
+        if ((csr & FlushMask) != FlushMask) [[unlikely]]
+        {
+            csr |= FlushMask;
+            _mm_setcsr(csr);
+        }
+    }
+
+    inline void disableFlushMode() noexcept
+    {
+        if ((csr & FlushMask) != 0) [[unlikely]]
+        {
+            csr &= ~FlushMask;
+            _mm_setcsr(csr);
+        }
+    }
+};
+
+struct PPCContext
+{
+    PPCRegister r3;
+#ifndef PPC_CONFIG_NON_ARGUMENT_AS_LOCAL
+    PPCRegister r0;
+#endif
+    PPCRegister r1;
+#ifndef PPC_CONFIG_NON_ARGUMENT_AS_LOCAL
+    PPCRegister r2;
+#endif
+    PPCRegister r4;
+    PPCRegister r5;
+    PPCRegister r6;
+    PPCRegister r7;
+    PPCRegister r8;
+    PPCRegister r9;
+    PPCRegister r10;
+#ifndef PPC_CONFIG_NON_ARGUMENT_AS_LOCAL
+    PPCRegister r11;
+    PPCRegister r12;
+#endif
+    PPCRegister r13;
+#ifndef PPC_CONFIG_NON_VOLATILE_AS_LOCAL
+    PPCRegister r14;
+    PPCRegister r15;
+    PPCRegister r16;
+    PPCRegister r17;
+    PPCRegister r18;
+    PPCRegister r19;
+    PPCRegister r20;
+    PPCRegister r21;
+    PPCRegister r22;
+    PPCRegister r23;
+    PPCRegister r24;
+    PPCRegister r25;
+    PPCRegister r26;
+    PPCRegister r27;
+    PPCRegister r28;
+    PPCRegister r29;
+    PPCRegister r30;
+    PPCRegister r31;
+#endif
+
+#ifndef PPC_CONFIG_SKIP_LR
+    uint64_t lr;
+#endif
+#ifndef PPC_CONFIG_CTR_AS_LOCAL
+    PPCRegister ctr;
+#endif
+#ifndef PPC_CONFIG_XER_AS_LOCAL
+    PPCXERRegister xer;
+#endif
+#ifndef PPC_CONFIG_RESERVED_AS_LOCAL
+    PPCRegister reserved;
+#endif
+#ifndef PPC_CONFIG_SKIP_MSR
+    uint32_t msr = 0x200A000;
+#endif
+#ifndef PPC_CONFIG_CR_AS_LOCAL
+    PPCCRRegister cr0;
+    PPCCRRegister cr1;
+    PPCCRRegister cr2;
+    PPCCRRegister cr3;
+    PPCCRRegister cr4;
+    PPCCRRegister cr5;
+    PPCCRRegister cr6;
+    PPCCRRegister cr7;
+#endif
+    PPCFPSCRRegister fpscr;
+
+#ifndef PPC_CONFIG_NON_ARGUMENT_AS_LOCAL
+    PPCRegister f0;
+#endif
+    PPCRegister f1;
+    PPCRegister f2;
+    PPCRegister f3;
+    PPCRegister f4;
+    PPCRegister f5;
+    PPCRegister f6;
+    PPCRegister f7;
+    PPCRegister f8;
+    PPCRegister f9;
+    PPCRegister f10;
+    PPCRegister f11;
+    PPCRegister f12;
+    PPCRegister f13;
+#ifndef PPC_CONFIG_NON_VOLATILE_AS_LOCAL
+    PPCRegister f14;
+    PPCRegister f15;
+    PPCRegister f16;
+    PPCRegister f17;
+    PPCRegister f18;
+    PPCRegister f19;
+    PPCRegister f20;
+    PPCRegister f21;
+    PPCRegister f22;
+    PPCRegister f23;
+    PPCRegister f24;
+    PPCRegister f25;
+    PPCRegister f26;
+    PPCRegister f27;
+    PPCRegister f28;
+    PPCRegister f29;
+    PPCRegister f30;
+    PPCRegister f31;
+#endif
+
+    PPCVRegister v0;
+    PPCVRegister v1;
+    PPCVRegister v2;
+    PPCVRegister v3;
+    PPCVRegister v4;
+    PPCVRegister v5;
+    PPCVRegister v6;
+    PPCVRegister v7;
+    PPCVRegister v8;
+    PPCVRegister v9;
+    PPCVRegister v10;
+    PPCVRegister v11;
+    PPCVRegister v12;
+    PPCVRegister v13;
+#ifndef PPC_CONFIG_NON_VOLATILE_AS_LOCAL
+    PPCVRegister v14;
+    PPCVRegister v15;
+    PPCVRegister v16;
+    PPCVRegister v17;
+    PPCVRegister v18;
+    PPCVRegister v19;
+    PPCVRegister v20;
+    PPCVRegister v21;
+    PPCVRegister v22;
+    PPCVRegister v23;
+    PPCVRegister v24;
+    PPCVRegister v25;
+    PPCVRegister v26;
+    PPCVRegister v27;
+    PPCVRegister v28;
+    PPCVRegister v29;
+    PPCVRegister v30;
+    PPCVRegister v31;
+#endif
+#ifndef PPC_CONFIG_NON_ARGUMENT_AS_LOCAL
+    PPCVRegister v32;
+    PPCVRegister v33;
+    PPCVRegister v34;
+    PPCVRegister v35;
+    PPCVRegister v36;
+    PPCVRegister v37;
+    PPCVRegister v38;
+    PPCVRegister v39;
+    PPCVRegister v40;
+    PPCVRegister v41;
+    PPCVRegister v42;
+    PPCVRegister v43;
+    PPCVRegister v44;
+    PPCVRegister v45;
+    PPCVRegister v46;
+    PPCVRegister v47;
+    PPCVRegister v48;
+    PPCVRegister v49;
+    PPCVRegister v50;
+    PPCVRegister v51;
+    PPCVRegister v52;
+    PPCVRegister v53;
+    PPCVRegister v54;
+    PPCVRegister v55;
+    PPCVRegister v56;
+    PPCVRegister v57;
+    PPCVRegister v58;
+    PPCVRegister v59;
+    PPCVRegister v60;
+    PPCVRegister v61;
+    PPCVRegister v62;
+    PPCVRegister v63;
+#endif
+#ifndef PPC_CONFIG_NON_VOLATILE_AS_LOCAL
+    PPCVRegister v64;
+    PPCVRegister v65;
+    PPCVRegister v66;
+    PPCVRegister v67;
+    PPCVRegister v68;
+    PPCVRegister v69;
+    PPCVRegister v70;
+    PPCVRegister v71;
+    PPCVRegister v72;
+    PPCVRegister v73;
+    PPCVRegister v74;
+    PPCVRegister v75;
+    PPCVRegister v76;
+    PPCVRegister v77;
+    PPCVRegister v78;
+    PPCVRegister v79;
+    PPCVRegister v80;
+    PPCVRegister v81;
+    PPCVRegister v82;
+    PPCVRegister v83;
+    PPCVRegister v84;
+    PPCVRegister v85;
+    PPCVRegister v86;
+    PPCVRegister v87;
+    PPCVRegister v88;
+    PPCVRegister v89;
+    PPCVRegister v90;
+    PPCVRegister v91;
+    PPCVRegister v92;
+    PPCVRegister v93;
+    PPCVRegister v94;
+    PPCVRegister v95;
+    PPCVRegister v96;
+    PPCVRegister v97;
+    PPCVRegister v98;
+    PPCVRegister v99;
+    PPCVRegister v100;
+    PPCVRegister v101;
+    PPCVRegister v102;
+    PPCVRegister v103;
+    PPCVRegister v104;
+    PPCVRegister v105;
+    PPCVRegister v106;
+    PPCVRegister v107;
+    PPCVRegister v108;
+    PPCVRegister v109;
+    PPCVRegister v110;
+    PPCVRegister v111;
+    PPCVRegister v112;
+    PPCVRegister v113;
+    PPCVRegister v114;
+    PPCVRegister v115;
+    PPCVRegister v116;
+    PPCVRegister v117;
+    PPCVRegister v118;
+    PPCVRegister v119;
+    PPCVRegister v120;
+    PPCVRegister v121;
+    PPCVRegister v122;
+    PPCVRegister v123;
+    PPCVRegister v124;
+    PPCVRegister v125;
+    PPCVRegister v126;
+    PPCVRegister v127;
+#endif
+};
+
+inline uint8_t VectorMaskL[] =
+{
+    0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
+    0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
+    0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02,
+    0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D, 0x0C,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E, 0x0D,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0E,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F,
+};
+
+inline uint8_t VectorMaskR[] =
+{
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF, 0xFF,
+    0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF, 0xFF,
+    0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xFF,
+};
+
+inline uint8_t VectorShiftTableL[] =
+{
+    0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
+    0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
+    0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02,
+    0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
+    0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04,
+    0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05,
+    0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06,
+    0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07,
+    0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
+    0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09,
+    0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A,
+    0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B,
+    0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C,
+    0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D,
+    0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E,
+    0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F,
+};
+
+inline uint8_t VectorShiftTableR[] =
+{
+    0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
+    0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F,
+    0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E,
+    0x1C, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D,
+    0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C,
+    0x1A, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B,
+    0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A,
+    0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09,
+    0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
+    0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07,
+    0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06,
+    0x14, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05,
+    0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04,
+    0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
+    0x11, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02,
+    0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
+};
+
+inline __m128i _mm_adds_epu32(__m128i a, __m128i b) 
+{
+    return _mm_add_epi32(a, _mm_min_epu32(_mm_xor_si128(a, _mm_cmpeq_epi32(a, a)), b));
+}
+
+inline __m128i _mm_avg_epi8(__m128i a, __m128i b)
+{
+    __m128i c = _mm_set1_epi8(char(128));
+    return _mm_xor_si128(c, _mm_avg_epu8(_mm_xor_si128(c, a), _mm_xor_si128(c, b)));
+}
+
+inline __m128i _mm_avg_epi16(__m128i a, __m128i b)
+{
+    __m128i c = _mm_set1_epi16(short(32768));
+    return _mm_xor_si128(c, _mm_avg_epu16(_mm_xor_si128(c, a), _mm_xor_si128(c, b)));
+}
+
+inline __m128 _mm_cvtepu32_ps_(__m128i src1)
+{
+    __m128i xmm1 = _mm_add_epi32(src1, _mm_set1_epi32(127));
+    __m128i xmm0 = _mm_slli_epi32(src1, 31 - 8);
+    xmm0 = _mm_srli_epi32(xmm0, 31);
+    xmm0 = _mm_add_epi32(xmm0, xmm1);
+    xmm0 = _mm_srai_epi32(xmm0, 8);
+    xmm0 = _mm_add_epi32(xmm0, _mm_set1_epi32(0x4F800000));
+    __m128 xmm2 = _mm_cvtepi32_ps(src1);
+    return _mm_blendv_ps(xmm2, _mm_castsi128_ps(xmm0), _mm_castsi128_ps(src1));
+}
+
+inline __m128i _mm_perm_epi8_(__m128i a, __m128i b, __m128i c)
+{
+    __m128i d = _mm_set1_epi8(0xF);
+    __m128i e = _mm_sub_epi8(d, _mm_and_si128(c, d));
+    return _mm_blendv_epi8(_mm_shuffle_epi8(a, e), _mm_shuffle_epi8(b, e), _mm_slli_epi32(c, 3));
+}
+
+inline __m128i _mm_cmpgt_epu8(__m128i a, __m128i b)
+{
+    __m128i c = _mm_set1_epi8(char(128));
+    return _mm_cmpgt_epi8(_mm_xor_si128(a, c), _mm_xor_si128(b, c));
+}
+
+inline __m128i _mm_cmpgt_epu16(__m128i a, __m128i b)
+{
+    __m128i c = _mm_set1_epi16(short(32768));
+    return _mm_cmpgt_epi16(_mm_xor_si128(a, c), _mm_xor_si128(b, c));
+}
+
+inline __m128i _mm_vctsxs(__m128 src1)
+{
+    __m128 xmm2 = _mm_cmpunord_ps(src1, src1);
+    __m128i xmm0 = _mm_cvttps_epi32(src1);
+    __m128i xmm1 = _mm_cmpeq_epi32(xmm0, _mm_set1_epi32(INT_MIN));
+    xmm1 = _mm_andnot_si128(_mm_castps_si128(src1), xmm1);
+    __m128 dest = _mm_blendv_ps(_mm_castsi128_ps(xmm0), _mm_castsi128_ps(_mm_set1_epi32(INT_MAX)), _mm_castsi128_ps(xmm1));
+    return _mm_andnot_si128(_mm_castps_si128(xmm2), _mm_castps_si128(dest));
+}
+
+inline __m128i _mm_vsr(__m128i a, __m128i b)
+{
+    b = _mm_srli_epi64(_mm_slli_epi64(b, 61), 61);
+    return _mm_castps_si128(_mm_insert_ps(_mm_castsi128_ps(_mm_srl_epi64(a, b)), _mm_castsi128_ps(_mm_srl_epi64(_mm_srli_si128(a, 4), b)), 0x10));
+}
+
+#endif
--- a/XenonUtils/section.h
+++ b/XenonUtils/section.h
@@ -0,0 +1,54 @@
+#pragma once
+#include <string>
+#include <cstdint>
+
+enum SectionFlags : uint8_t
+{
+    SectionFlags_None = 0,
+    SectionFlags_Data = 1,
+    SectionFlags_Code = 2
+};
+
+struct Section
+{
+    std::string name{};
+    size_t base{};
+    uint32_t size{};
+    SectionFlags flags{};
+    uint8_t* data{};
+
+    bool operator<(size_t address) const
+    {
+        return address < base;
+    }
+
+    bool operator>(size_t address) const
+    {
+        return address >= (base + size);
+    }
+
+    bool operator==(size_t address) const
+    {
+        return address >= base && address < base + size;
+    }
+};
+
+struct SectionComparer
+{
+    using is_transparent = void;
+
+    bool operator()(const Section& lhs, size_t rhs) const
+    {
+        return lhs.base < rhs;
+    }
+
+    bool operator()(size_t lhs, const Section& rhs) const
+    {
+        return lhs < rhs.base;
+    }
+
+    bool operator()(const Section& lhs, const Section& rhs) const
+    {
+        return lhs.base < rhs.base;
+    }
+};
--- a/XenonUtils/symbol.h
+++ b/XenonUtils/symbol.h
@@ -0,0 +1,48 @@
+#pragma once
+#include <string>
+#include <cstdint>
+
+enum SymbolType
+{
+    Symbol_None,
+    Symbol_Section,
+    Symbol_Function,
+    Symbol_Comment,
+};
+
+struct Symbol
+{
+    mutable std::string name{};
+    size_t address{};
+    size_t size{};
+    mutable SymbolType type{};
+
+    Symbol()
+    {
+    }
+
+    Symbol(std::string name, size_t address, size_t size, SymbolType type)
+        : name(std::move(name)), address(address), size(size), type(type)
+    {
+    }
+};
+
+struct SymbolComparer
+{
+    using is_transparent = void;
+
+    bool operator()(const Symbol& lhs, size_t rhs) const
+    {
+        return lhs.address < rhs;
+    }
+
+    bool operator()(size_t lhs, const Symbol& rhs) const
+    {
+        return lhs < rhs.address;
+    }
+
+    bool operator()(const Symbol& lhs, const Symbol& rhs) const
+    {
+        return lhs.address < rhs.address;
+    }
+};
--- a/XenonUtils/symbol_table.h
+++ b/XenonUtils/symbol_table.h
@@ -0,0 +1,63 @@
+#pragma once
+#include "symbol.h"
+#include <set>
+
+class SymbolTable : public std::multiset<Symbol, SymbolComparer>
+{
+public:
+    const_iterator find(size_t address) const
+    {
+        auto [beginIt, endIt] = equal_range(address);
+        if (beginIt == endIt)
+        {
+            return end();
+        }
+
+        size_t closest{ address - beginIt->address };
+        auto match = end();
+        for (auto it = beginIt; it != endIt; ++it)
+        {
+            if (address < it->address || address >= it->address + it->size)
+            {
+                continue;
+            }
+
+            const size_t distance = address - it->address;
+            if (distance <= closest)
+            {
+                match = it;
+                closest = distance;
+            }
+        }
+
+        return match;
+    }
+
+    iterator find(size_t address)
+    {
+        auto [beginIt, endIt] = equal_range(address);
+        if (beginIt == endIt)
+        {
+            return end();
+        }
+
+        size_t closest{ address - beginIt->address };
+        auto match = end();
+        for (auto it = beginIt; it != endIt; ++it)
+        {
+            if (address < it->address || address >= it->address + it->size)
+            {
+                continue;
+            }
+
+            const size_t distance = address - it->address;
+            if (distance <= closest)
+            {
+                match = it;
+                closest = distance;
+            }
+        }
+
+        return match;
+    }
+};
--- a/XenonUtils/xbox.h
+++ b/XenonUtils/xbox.h
@@ -0,0 +1,409 @@
+#pragma once
+#include <cstdint>
+#include <type_traits>
+#include <bit>
+#include <string>
+#include "byteswap.h"
+
+#ifdef _WIN32
+    #include <windows.h>
+#endif
+
+// real win32 handles will never use the upper bits unless something goes really wrong
+#define CHECK_GUEST_HANDLE(HANDLE) (((HANDLE) & 0x80000000) == 0x80000000)
+#define GUEST_HANDLE(HANDLE) ((HANDLE) | 0x80000000)
+#define HOST_HANDLE(HANDLE) ((HANDLE) & ~0x80000000)
+
+// Return true to free the associated memory
+typedef bool(*TypeDestructor_t)(void*);
+
+template<typename T>
+bool DestroyObject(void* obj)
+{
+    static_cast<T*>(obj)->~T();
+    return true;
+}
+
+template<typename T>
+struct be
+{
+    T value;
+
+    be() : value(0)
+    {
+    }
+
+    be(const T v)
+    {
+        set(v);
+    }
+
+    static T byteswap(T value)
+    {
+        if constexpr (std::is_same_v<T, double>)
+        {
+            const uint64_t swapped = ByteSwap(*reinterpret_cast<uint64_t*>(&value));
+            return *reinterpret_cast<const T*>(&swapped);
+        }
+        else if constexpr (std::is_same_v<T, float>)
+        {
+            const uint32_t swapped = ByteSwap(*reinterpret_cast<uint32_t*>(&value));
+            return *reinterpret_cast<const T*>(&swapped);
+        }
+        else if constexpr (std::is_enum_v<T>)
+        {
+            const std::underlying_type_t<T> swapped = ByteSwap(*reinterpret_cast<std::underlying_type_t<T>*>(&value));
+            return *reinterpret_cast<const T*>(&swapped);
+        }
+        else
+        {
+            return ByteSwap(value);
+        }
+    }
+
+    void set(const T v)
+    {
+        value = byteswap(v);
+    }
+
+    T get() const
+    {
+        return byteswap(value);
+    }
+
+    be& operator| (T value)
+    {
+        set(get() | value);
+        return *this;
+    }
+
+    be& operator& (T value)
+    {
+        set(get() & value);
+        return *this;
+    }
+
+    operator T() const
+    {
+        return get();
+    }
+
+    be& operator=(T v)
+    {
+        set(v);
+        return *this;
+    }
+};
+
+extern "C" void* MmGetHostAddress(uint32_t ptr);
+template<typename T>
+struct xpointer
+{
+    be<uint32_t> ptr;
+
+    xpointer() : ptr(0)
+    {
+    }
+
+    xpointer(T* ptr) : ptr(reinterpret_cast<size_t>(ptr) - reinterpret_cast<size_t>(MmGetHostAddress(0)))
+    {
+    }
+
+    T* get() const
+    {
+        if (!ptr.value)
+        {
+            return nullptr;
+        }
+
+        return reinterpret_cast<T*>(MmGetHostAddress(ptr));
+    }
+
+    operator T* () const
+    {
+        return get();
+    }
+
+    T* operator->() const
+    {
+        return get();
+    }
+};
+
+template<typename TGuest>
+struct HostObject
+{
+    typedef TGuest guest_type;
+};
+
+struct _XLIST_ENTRY;
+typedef _XLIST_ENTRY XLIST_ENTRY;
+typedef xpointer<XLIST_ENTRY> PXLIST_ENTRY;
+
+typedef struct _IMAGE_CE_RUNTIME_FUNCTION
+{
+    uint32_t BeginAddress;
+
+    union 
+    {
+        uint32_t Data;
+        struct
+        {
+            uint32_t PrologLength : 8;
+            uint32_t FunctionLength : 22;
+            uint32_t ThirtyTwoBit : 1;
+            uint32_t ExceptionFlag : 1;
+        };
+    };
+} IMAGE_CE_RUNTIME_FUNCTION;
+
+static_assert(sizeof(IMAGE_CE_RUNTIME_FUNCTION) == 8);
+
+typedef struct _XLIST_ENTRY
+{
+    be<uint32_t> Flink;
+    be<uint32_t> Blink;
+} XLIST_ENTRY;
+
+typedef struct _XDISPATCHER_HEADER
+{
+    union
+    {
+        struct
+        {
+            uint8_t Type;
+            union
+            {
+                uint8_t Abandoned;
+                uint8_t Absolute;
+                uint8_t NpxIrql;
+                uint8_t Signalling;
+            };
+            union
+            {
+                uint8_t Size;
+                uint8_t Hand;
+            };
+            union
+            {
+                uint8_t Inserted;
+                uint8_t DebugActive;
+                uint8_t DpcActive;
+            };
+        };
+        be<uint32_t> Lock;
+    };
+
+    be<uint32_t> SignalState;
+    XLIST_ENTRY WaitListHead;
+} XDISPATCHER_HEADER, * XPDISPATCHER_HEADER;
+
+// These variables are never accessed in guest code, we can safely use them in little endian
+typedef struct _XRTL_CRITICAL_SECTION
+{
+    XDISPATCHER_HEADER Header;
+    int32_t LockCount;
+    int32_t RecursionCount;
+    uint32_t OwningThread;
+} XRTL_CRITICAL_SECTION;
+
+typedef struct _XANSI_STRING {
+    be<uint16_t> Length;
+    be<uint16_t> MaximumLength;
+    xpointer<char> Buffer;
+} XANSI_STRING;
+
+typedef struct _XOBJECT_ATTRIBUTES
+{
+    be<uint32_t> RootDirectory;
+    xpointer<XANSI_STRING> Name;
+    xpointer<void> Attributes;
+} XOBJECT_ATTRIBUTES;
+
+typedef XDISPATCHER_HEADER XKEVENT;
+
+typedef struct _XIO_STATUS_BLOCK
+{
+    union {
+        be<uint32_t> Status;
+        be<uint32_t> Pointer;
+    };
+    be<uint32_t> Information;
+} XIO_STATUS_BLOCK;
+
+typedef struct _XOVERLAPPED {
+    be<uint32_t> Internal;
+    be<uint32_t> InternalHigh;
+    be<uint32_t> Offset;
+    be<uint32_t> OffsetHigh;
+    be<uint32_t> hEvent;
+} XOVERLAPPED;
+
+// this name is so dumb
+typedef struct _XXOVERLAPPED {
+    union
+    {
+        struct
+        {
+            be<uint32_t> Error;
+            be<uint32_t> Length;
+        };
+
+        struct
+        {
+            uint32_t InternalLow;
+            uint32_t InternalHigh;
+        };
+    };
+    uint32_t InternalContext;
+    be<uint32_t> hEvent;
+    be<uint32_t> pCompletionRoutine;
+    be<uint32_t> dwCompletionContext;
+    be<uint32_t> dwExtendedError;
+} XXOVERLAPPED, *PXXOVERLAPPED;
+
+static_assert(sizeof(_XXOVERLAPPED) == 0x1C);
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-memorystatus
+typedef struct _XMEMORYSTATUS {
+    be<uint32_t> dwLength;
+    be<uint32_t> dwMemoryLoad;
+    be<uint32_t> dwTotalPhys;
+    be<uint32_t> dwAvailPhys;
+    be<uint32_t> dwTotalPageFile;
+    be<uint32_t> dwAvailPageFile;
+    be<uint32_t> dwTotalVirtual;
+    be<uint32_t> dwAvailVirtual;
+} XMEMORYSTATUS, * XLPMEMORYSTATUS;
+
+typedef struct _XVIDEO_MODE
+{
+    be<uint32_t> DisplayWidth;
+    be<uint32_t> DisplayHeight;
+    be<uint32_t> IsInterlaced;
+    be<uint32_t> IsWidescreen;
+    be<uint32_t> IsHighDefinition;
+    be<uint32_t> RefreshRate;
+    be<uint32_t> VideoStandard;
+    be<uint32_t> Unknown4A;
+    be<uint32_t> Unknown01;
+    be<uint32_t> reserved[3];
+} XVIDEO_MODE;
+
+typedef struct _XKSEMAPHORE
+{
+    XDISPATCHER_HEADER Header;
+    be<uint32_t> Limit;
+} XKSEMAPHORE;
+
+typedef struct _XUSER_SIGNIN_INFO {
+    be<uint64_t> xuid;
+    be<uint32_t> dwField08;
+    be<uint32_t> SigninState;
+    be<uint32_t> dwField10;
+    be<uint32_t> dwField14;
+    char Name[16];
+} XUSER_SIGNIN_INFO;
+
+typedef struct _XTIME_FIELDS
+{
+    be<uint16_t> Year;
+    be<uint16_t> Month;
+    be<uint16_t> Day;
+    be<uint16_t> Hour;
+    be<uint16_t> Minute;
+    be<uint16_t> Second;
+    be<uint16_t> Milliseconds;
+    be<uint16_t> Weekday;
+} XTIME_FIELDS, * PXTIME_FIELDS;
+
+// Content types
+#define XCONTENTTYPE_SAVEDATA 1
+#define XCONTENTTYPE_DLC      2
+#define XCONTENTTYPE_RESERVED 3
+
+#define XCONTENT_NEW      1
+#define XCONTENT_EXISTING 2
+
+#define XCONTENT_MAX_DISPLAYNAME 128
+#define XCONTENT_MAX_FILENAME    42
+#define XCONTENTDEVICE_MAX_NAME  27
+
+typedef struct _XCONTENT_DATA
+{
+    be<uint32_t> DeviceID;
+    be<uint32_t> dwContentType;
+    be<uint16_t> szDisplayName[XCONTENT_MAX_DISPLAYNAME];
+    char szFileName[XCONTENT_MAX_FILENAME];
+} XCONTENT_DATA, * PXCONTENT_DATA;
+
+typedef struct _XHOSTCONTENT_DATA : _XCONTENT_DATA
+{
+    // This is a host exclusive type so we don't care what goes on
+    std::string szRoot{};
+} XHOSTCONTENT_DATA, *PXHOSTCONTENT_DATA;
+
+
+#define XCONTENTDEVICETYPE_HDD 1
+#define XCONTENTDEVICETYPE_MU 2
+
+typedef struct _XDEVICE_DATA
+{
+    be<uint32_t> DeviceID;
+    be<uint32_t> DeviceType;
+    be<uint64_t> ulDeviceBytes;
+    be<uint64_t> ulDeviceFreeBytes;
+    be<uint16_t> wszName[XCONTENTDEVICE_MAX_NAME];
+} XDEVICE_DATA, *PXDEVICE_DATA;
+
+// Direct reflection of XInput structures
+
+#define XAMINPUT_DEVTYPE_GAMEPAD          0x01
+#define XAMINPUT_DEVSUBTYPE_GAMEPAD       0x01
+
+#define XAMINPUT_GAMEPAD_DPAD_UP          0x0001
+#define XAMINPUT_GAMEPAD_DPAD_DOWN        0x0002
+#define XAMINPUT_GAMEPAD_DPAD_LEFT        0x0004
+#define XAMINPUT_GAMEPAD_DPAD_RIGHT       0x0008
+#define XAMINPUT_GAMEPAD_START            0x0010
+#define XAMINPUT_GAMEPAD_BACK             0x0020
+#define XAMINPUT_GAMEPAD_LEFT_THUMB       0x0040
+#define XAMINPUT_GAMEPAD_RIGHT_THUMB      0x0080
+#define XAMINPUT_GAMEPAD_LEFT_SHOULDER    0x0100
+#define XAMINPUT_GAMEPAD_RIGHT_SHOULDER   0x0200
+#define XAMINPUT_GAMEPAD_A                0x1000
+#define XAMINPUT_GAMEPAD_B                0x2000
+#define XAMINPUT_GAMEPAD_X                0x4000
+#define XAMINPUT_GAMEPAD_Y                0x8000
+
+typedef struct _XAMINPUT_GAMEPAD
+{
+    uint16_t                            wButtons;
+    uint8_t                             bLeftTrigger;
+    uint8_t                             bRightTrigger;
+    int16_t                             sThumbLX;
+    int16_t                             sThumbLY;
+    int16_t                             sThumbRX;
+    int16_t                             sThumbRY;
+} XAMINPUT_GAMEPAD, *PXAMINPUT_GAMEPAD;
+
+typedef struct _XAMINPUT_VIBRATION
+{
+    uint16_t                            wLeftMotorSpeed;
+    uint16_t                            wRightMotorSpeed;
+} XAMINPUT_VIBRATION, * PXAMINPUT_VIBRATION;
+
+typedef struct _XAMINPUT_CAPABILITIES
+{
+    uint8_t                             Type;
+    uint8_t                             SubType;
+    uint16_t                            Flags;
+    XAMINPUT_GAMEPAD                    Gamepad;
+    XAMINPUT_VIBRATION                  Vibration;
+} XAMINPUT_CAPABILITIES, * PXAMINPUT_CAPABILITIES;
+
+typedef struct _XAMINPUT_STATE
+{
+    uint32_t                            dwPacketNumber;
+    XAMINPUT_GAMEPAD                    Gamepad;
+} XAMINPUT_STATE, * PXAMINPUT_STATE;
--- a/XenonUtils/xbox/xam_table.inc
+++ b/XenonUtils/xbox/xam_table.inc
--- a/XenonUtils/xbox/xboxkrnl_table.inc
+++ b/XenonUtils/xbox/xboxkrnl_table.inc
@@ -0,0 +1,936 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2021 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+// This is a partial file designed to be included by other files when
+// constructing various tables.
+
+// clang-format off
+
+XE_EXPORT(xboxkrnl, 0x00000001, DbgBreakPoint,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000002, DbgBreakPointWithStatus,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000003, DbgPrint,                                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000004, DbgPrompt,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000005, DumpGetRawDumpInfo,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000006, DumpWriteDump,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000007, ExAcquireReadWriteLockExclusive,                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000008, ExAcquireReadWriteLockShared,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000009, ExAllocatePool,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000000A, ExAllocatePoolWithTag,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000000B, ExAllocatePoolTypeWithTag,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000000C, ExConsoleGameRegion,                                        kVariable),
+XE_EXPORT(xboxkrnl, 0x0000000D, ExCreateThread,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000000E, ExEventObjectType,                                          kVariable),
+XE_EXPORT(xboxkrnl, 0x0000000F, ExFreePool,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000010, ExGetXConfigSetting,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000011, ExInitializeReadWriteLock,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000012, ExMutantObjectType,                                         kVariable),
+XE_EXPORT(xboxkrnl, 0x00000013, ExQueryPoolBlockSize,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000014, ExRegisterThreadNotification,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000015, ExRegisterTitleTerminateNotification,                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000016, ExReleaseReadWriteLock,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000017, ExSemaphoreObjectType,                                      kVariable),
+XE_EXPORT(xboxkrnl, 0x00000018, ExSetXConfigSetting,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000019, ExTerminateThread,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000001A, ExTerminateTitleProcess,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000001B, ExThreadObjectType,                                         kVariable),
+XE_EXPORT(xboxkrnl, 0x0000001C, ExTimerObjectType,                                          kVariable),
+XE_EXPORT(xboxkrnl, 0x0000001D, MmDoubleMapMemory,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000001E, MmUnmapMemory,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000001F, XeKeysGetConsoleCertificate,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000020, FscGetCacheElementCount,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000021, FscSetCacheElementCount,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000022, HalGetCurrentAVPack,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000023, HalGpioControl,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000024, HalOpenCloseODDTray,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000025, HalReadWritePCISpace,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000026, HalRegisterPowerDownNotification,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000027, HalRegisterSMCNotification,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000028, HalReturnToFirmware,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000029, HalSendSMCMessage,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000002A, HalSetAudioEnable,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000002B, InterlockedFlushSList,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000002C, InterlockedPopEntrySList,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000002D, InterlockedPushEntrySList,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000002E, IoAcquireDeviceObjectLock,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000002F, IoAllocateIrp,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000030, IoBuildAsynchronousFsdRequest,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000031, IoBuildDeviceIoControlRequest,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000032, IoBuildSynchronousFsdRequest,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000033, IoCallDriver,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000034, IoCheckShareAccess,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000035, IoCompleteRequest,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000036, IoCompletionObjectType,                                     kVariable),
+XE_EXPORT(xboxkrnl, 0x00000037, IoCreateDevice,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000038, IoCreateFile,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000039, IoDeleteDevice,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000003A, IoDeviceObjectType,                                         kVariable),
+XE_EXPORT(xboxkrnl, 0x0000003B, IoDismountVolume,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000003C, IoDismountVolumeByFileHandle,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000003D, IoDismountVolumeByName,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000003E, IoFileObjectType,                                           kVariable),
+XE_EXPORT(xboxkrnl, 0x0000003F, IoFreeIrp,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000040, IoInitializeIrp,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000041, IoInvalidDeviceRequest,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000042, ExSetBetaFeaturesEnabled,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000043, IoQueueThreadIrp,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000044, IoReleaseDeviceObjectLock,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000045, IoRemoveShareAccess,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000046, IoSetIoCompletion,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000047, IoSetShareAccess,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000048, IoStartNextPacket,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000049, IoStartNextPacketByKey,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000004A, IoStartPacket,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000004B, IoSynchronousDeviceIoControlRequest,                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000004C, IoSynchronousFsdRequest,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000004D, KeAcquireSpinLockAtRaisedIrql,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000004E, KeAlertResumeThread,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000004F, KeAlertThread,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000050, KeBlowFuses,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000051, KeBoostPriorityThread,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000052, KeBugCheck,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000053, KeBugCheckEx,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000054, KeCancelTimer,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000055, KeConnectInterrupt,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000056, KeContextFromKframes,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000057, KeContextToKframes,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000058, KeCreateUserMode,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000059, KeDebugMonitorData,                                         kVariable),
+XE_EXPORT(xboxkrnl, 0x0000005A, KeDelayExecutionThread,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000005B, KeDeleteUserMode,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000005C, KeDisconnectInterrupt,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000005D, KeEnableFpuExceptions,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000005E, KeEnablePPUPerformanceMonitor,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000005F, KeEnterCriticalRegion,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000060, KeEnterUserMode,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000061, KeFlushCacheRange,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000062, KeFlushCurrentEntireTb,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000063, KeFlushEntireTb,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000064, KeFlushUserModeCurrentTb,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000065, KeFlushUserModeTb,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000066, KeGetCurrentProcessType,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000067, KeGetPMWRegister,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000068, KeGetPRVRegister,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000069, KeGetSocRegister,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000006A, KeGetSpecialPurposeRegister,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x0000006B, KeLockL2,                                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000006C, KeUnlockL2,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000006D, KeInitializeApc,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000006E, KeInitializeDeviceQueue,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000006F, KeInitializeDpc,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000070, KeInitializeEvent,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000071, KeInitializeInterrupt,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000072, KeInitializeMutant,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000073, KeInitializeQueue,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000074, KeInitializeSemaphore,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000075, KeInitializeTimerEx,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000076, KeInsertByKeyDeviceQueue,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000077, KeInsertDeviceQueue,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000078, KeInsertHeadQueue,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000079, KeInsertQueue,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000007A, KeInsertQueueApc,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000007B, KeInsertQueueDpc,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000007C, KeIpiGenericCall,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000007D, KeLeaveCriticalRegion,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000007E, KeLeaveUserMode,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000007F, KePulseEvent,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000080, KeQueryBackgroundProcessors,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000081, KeQueryBasePriorityThread,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000082, KeQueryInterruptTime,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000083, KeQueryPerformanceFrequency,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000084, KeQuerySystemTime,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000085, KeRaiseIrqlToDpcLevel,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000086, KeRegisterDriverNotification,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000087, KeReleaseMutant,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000088, KeReleaseSemaphore,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000089, KeReleaseSpinLockFromRaisedIrql,                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000008A, KeRemoveByKeyDeviceQueue,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000008B, KeRemoveDeviceQueue,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000008C, KeRemoveEntryDeviceQueue,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000008D, KeRemoveQueue,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000008E, KeRemoveQueueDpc,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000008F, KeResetEvent,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000090, KeRestoreFloatingPointState,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000091, KeRestoreVectorUnitState,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000092, KeResumeThread,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000093, KeRetireDpcList,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000094, KeRundownQueue,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000095, KeSaveFloatingPointState,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000096, KeSaveVectorUnitState,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000097, KeSetAffinityThread,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000098, KeSetBackgroundProcessors,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000099, KeSetBasePriorityThread,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000009A, KeSetCurrentProcessType,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000009B, KeSetCurrentStackPointers,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000009C, KeSetDisableBoostThread,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000009D, KeSetEvent,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000009E, KeSetEventBoostPriority,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000009F, KeSetPMWRegister,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A0, KeSetPowerMode,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A1, KeSetPRVRegister,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A2, KeSetPriorityClassThread,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A3, KeSetPriorityThread,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A4, KeSetSocRegister,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A5, KeSetSpecialPurposeRegister,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A6, KeSetTimer,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A7, KeSetTimerEx,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A8, KeStallExecutionProcessor,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000000A9, KeSuspendThread,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000000AA, KeSweepDcacheRange,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000000AB, KeSweepIcacheRange,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000000AC, KeTestAlertThread,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000AD, KeTimeStampBundle,                                          kVariable),
+XE_EXPORT(xboxkrnl, 0x000000AE, KeTryToAcquireSpinLockAtRaisedIrql,                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000000AF, KeWaitForMultipleObjects,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B0, KeWaitForSingleObject,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B1, KfAcquireSpinLock,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B2, KfRaiseIrql,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B3, KfLowerIrql,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B4, KfReleaseSpinLock,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B5, KiBugCheckData,                                             kVariable),
+XE_EXPORT(xboxkrnl, 0x000000B6, LDICreateDecompression,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B7, LDIDecompress,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B8, LDIDestroyDecompression,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000000B9, MmAllocatePhysicalMemory,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000000BA, MmAllocatePhysicalMemoryEx,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000000BB, MmCreateKernelStack,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000000BC, MmDeleteKernelStack,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000000BD, MmFreePhysicalMemory,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000000BE, MmGetPhysicalAddress,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000000BF, MmIsAddressValid,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C0, MmLockAndMapSegmentArray,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C1, MmLockUnlockBufferPages,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C2, MmMapIoSpace,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C3, MmPersistPhysicalMemoryAllocation,                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C4, MmQueryAddressProtect,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C5, MmQueryAllocationSize,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C6, MmQueryStatistics,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C7, MmSetAddressProtect,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C8, MmSplitPhysicalMemoryAllocation,                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000000C9, MmUnlockAndUnmapSegmentArray,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000CA, MmUnmapIoSpace,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000000CB, Nls844UnicodeCaseTable,                                     kVariable),
+XE_EXPORT(xboxkrnl, 0x000000CC, NtAllocateVirtualMemory,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000000CD, NtCancelTimer,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000000CE, NtClearEvent,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000CF, NtClose,                                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D0, NtCreateDirectoryObject,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D1, NtCreateEvent,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D2, NtCreateFile,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D3, NtCreateIoCompletion,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D4, NtCreateMutant,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D5, NtCreateSemaphore,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D6, NtCreateSymbolicLinkObject,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D7, NtCreateTimer,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D8, NtDeleteFile,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000D9, NtDeviceIoControlFile,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000000DA, NtDuplicateObject,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000DB, NtFlushBuffersFile,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000000DC, NtFreeVirtualMemory,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000000DD, NtMakeTemporaryObject,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000000DE, NtOpenDirectoryObject,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000000DF, NtOpenFile,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E0, NtOpenSymbolicLinkObject,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E1, NtProtectVirtualMemory,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E2, NtPulseEvent,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E3, NtQueueApcThread,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E4, NtQueryDirectoryFile,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E5, NtQueryDirectoryObject,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E6, NtQueryEvent,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E7, NtQueryFullAttributesFile,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E8, NtQueryInformationFile,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000000E9, NtQueryIoCompletion,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000000EA, NtQueryMutant,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000000EB, NtQuerySemaphore,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000000EC, NtQuerySymbolicLinkObject,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000000ED, NtQueryTimer,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000EE, NtQueryVirtualMemory,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000000EF, NtQueryVolumeInformationFile,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F0, NtReadFile,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F1, NtReadFileScatter,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F2, NtReleaseMutant,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F3, NtReleaseSemaphore,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F4, NtRemoveIoCompletion,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F5, NtResumeThread,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F6, NtSetEvent,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F7, NtSetInformationFile,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F8, NtSetIoCompletion,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000000F9, NtSetSystemTime,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000000FA, NtSetTimerEx,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000000FB, NtSignalAndWaitForSingleObjectEx,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000000FC, NtSuspendThread,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000000FD, NtWaitForSingleObjectEx,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000000FE, NtWaitForMultipleObjectsEx,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000000FF, NtWriteFile,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000100, NtWriteFileGather,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000101, NtYieldExecution,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000102, ObCreateObject,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000103, ObCreateSymbolicLink,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000104, ObDeleteSymbolicLink,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000105, ObDereferenceObject,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000106, ObDirectoryObjectType,                                      kVariable),
+XE_EXPORT(xboxkrnl, 0x00000107, ObGetWaitableObject,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000108, ObInsertObject,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000109, ObIsTitleObject,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000010A, ObLookupAnyThreadByThreadId,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x0000010B, ObLookupThreadByThreadId,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000010C, ObMakeTemporaryObject,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000010D, ObOpenObjectByName,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000010E, ObOpenObjectByPointer,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000010F, ObReferenceObject,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000110, ObReferenceObjectByHandle,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000111, ObReferenceObjectByName,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000112, ObSymbolicLinkObjectType,                                   kVariable),
+XE_EXPORT(xboxkrnl, 0x00000113, ObTranslateSymbolicLink,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000114, RtlAnsiStringToUnicodeString,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000115, RtlAppendStringToString,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000116, RtlAppendUnicodeStringToString,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000117, RtlAppendUnicodeToString,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000118, RtlAssert,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000119, RtlCaptureContext,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000011A, RtlCompareMemory,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000011B, RtlCompareMemoryUlong,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000011C, RtlCompareString,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000011D, RtlCompareStringN,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000011E, RtlCompareUnicodeString,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000011F, RtlCompareUnicodeStringN,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000120, RtlCompareUtf8ToUnicode,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000121, RtlCopyString,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000122, RtlCopyUnicodeString,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000123, RtlCreateUnicodeString,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000124, RtlDowncaseUnicodeChar,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000125, RtlEnterCriticalSection,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000126, RtlFillMemoryUlong,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000127, RtlFreeAnsiString,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000128, RtlFreeUnicodeString,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000129, RtlGetCallersAddress,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000012A, RtlGetStackLimits,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000012B, RtlImageXexHeaderField,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000012C, RtlInitAnsiString,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000012D, RtlInitUnicodeString,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000012E, RtlInitializeCriticalSection,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000012F, RtlInitializeCriticalSectionAndSpinCount,                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000130, RtlLeaveCriticalSection,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000131, RtlLookupFunctionEntry,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000132, RtlLowerChar,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000133, RtlMultiByteToUnicodeN,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000134, RtlMultiByteToUnicodeSize,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000135, RtlNtStatusToDosError,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000136, RtlRaiseException,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000137, RtlRaiseStatus,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000138, RtlRip,                                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000139, _scprintf,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000013A, _snprintf,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000013B, sprintf,                                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000013C, _scwprintf,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000013D, _snwprintf,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000013E, swprintf,                                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000013F, RtlTimeFieldsToTime,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000140, RtlTimeToTimeFields,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000141, RtlTryEnterCriticalSection,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000142, RtlUnicodeStringToAnsiString,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000143, RtlUnicodeToMultiByteN,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000144, RtlUnicodeToMultiByteSize,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000145, RtlUnicodeToUtf8,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000146, RtlUnicodeToUtf8Size,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000147, RtlUnwind,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000148, RtlUnwind2,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000149, RtlUpcaseUnicodeChar,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000014A, RtlUpperChar,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000014B, RtlVirtualUnwind,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000014C, _vscprintf,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000014D, _vsnprintf,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000014E, vsprintf,                                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000014F, _vscwprintf,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000150, _vsnwprintf,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000151, vswprintf,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000152, KeTlsAlloc,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000153, KeTlsFree,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000154, KeTlsGetValue,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000155, KeTlsSetValue,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000156, XboxHardwareInfo,                                           kVariable),
+XE_EXPORT(xboxkrnl, 0x00000157, XboxKrnlBaseVersion,                                        kVariable),
+XE_EXPORT(xboxkrnl, 0x00000158, XboxKrnlVersion,                                            kVariable),
+XE_EXPORT(xboxkrnl, 0x00000159, XeCryptAesKey,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000015A, XeCryptAesEcb,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000015B, XeCryptAesCbc,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000015C, XeCryptBnDwLeDhEqualBase,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000015D, XeCryptBnDwLeDhInvalBase,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000015E, XeCryptBnDwLeDhModExp,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000015F, XeCryptBnDw_Copy,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000160, XeCryptBnDw_SwapLeBe,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000161, XeCryptBnDw_Zero,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000162, XeCryptBnDwLePkcs1Format,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000163, XeCryptBnDwLePkcs1Verify,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000164, XeCryptBnQwBeSigCreate,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000165, XeCryptBnQwBeSigFormat,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000166, XeCryptBnQwBeSigVerify,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000167, XeCryptBnQwNeModExp,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000168, XeCryptBnQwNeModExpRoot,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000169, XeCryptBnQwNeModInv,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000016A, XeCryptBnQwNeModMul,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000016B, XeCryptBnQwNeRsaKeyGen,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000016C, XeCryptBnQwNeRsaPrvCrypt,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000016D, XeCryptBnQwNeRsaPubCrypt,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000016E, XeCryptBnQw_Copy,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000016F, XeCryptBnQw_SwapDwQw,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000170, XeCryptBnQw_SwapDwQwLeBe,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000171, XeCryptBnQw_SwapLeBe,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000172, XeCryptBnQw_Zero,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000173, XeCryptChainAndSumMac,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000174, XeCryptDesParity,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000175, XeCryptDesKey,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000176, XeCryptDesEcb,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000177, XeCryptDesCbc,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000178, XeCryptDes3Key,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000179, XeCryptDes3Ecb,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000017A, XeCryptDes3Cbc,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000017B, XeCryptHmacMd5Init,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000017C, XeCryptHmacMd5Update,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000017D, XeCryptHmacMd5Final,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000017E, XeCryptHmacMd5,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000017F, XeCryptHmacShaInit,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000180, XeCryptHmacShaUpdate,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000181, XeCryptHmacShaFinal,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000182, XeCryptHmacSha,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000183, XeCryptHmacShaVerify,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000184, XeCryptMd5Init,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000185, XeCryptMd5Update,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000186, XeCryptMd5Final,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000187, XeCryptMd5,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000188, XeCryptParveEcb,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000189, XeCryptParveCbcMac,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000018A, XeCryptRandom,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000018B, XeCryptRc4Key,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000018C, XeCryptRc4Ecb,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000018D, XeCryptRc4,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000018E, XeCryptRotSumSha,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000018F, XeCryptShaInit,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000190, XeCryptShaUpdate,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000191, XeCryptShaFinal,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000192, XeCryptSha,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000193, XexExecutableModuleHandle,                                  kVariable),
+XE_EXPORT(xboxkrnl, 0x00000194, XexCheckExecutablePrivilege,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000195, XexGetModuleHandle,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000196, XexGetModuleSection,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000197, XexGetProcedureAddress,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000198, XexLoadExecutable,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000199, XexLoadImage,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000019A, XexLoadImageFromMemory,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000019B, XexLoadImageHeaders,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000019C, XexPcToFileHeader,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000019D, KiApcNormalRoutineNop_,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000019E, XexRegisterPatchDescriptor,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000019F, XexSendDeferredNotifications,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A0, XexStartExecutable,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A1, XexUnloadImage,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A2, XexUnloadImageAndExitThread,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A3, XexUnloadTitleModules,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A4, XexVerifyImageHeaders,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A5, __C_specific_handler,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A6, DbgLoadImageSymbols,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A7, DbgUnLoadImageSymbols,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A8, RtlImageDirectoryEntryToData,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001A9, RtlImageNtHeader,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000001AA, ExDebugMonitorService,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001AB, MmDbgReadCheck,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001AC, MmDbgReleaseAddress,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001AD, MmDbgWriteCheck,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001AE, ExLoadedCommandLine,                                        kVariable),
+XE_EXPORT(xboxkrnl, 0x000001AF, ExLoadedImageName,                                          kVariable),
+XE_EXPORT(xboxkrnl, 0x000001B0, VdBlockUntilGUIIdle,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B1, VdCallGraphicsNotificationRoutines,                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B2, VdDisplayFatalError,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B3, VdEnableClosedCaption,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B4, VdEnableDisableClockGating,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B5, VdEnableDisablePowerSavingMode,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B6, VdEnableRingBufferRPtrWriteBack,                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B7, VdGenerateGPUCSCCoefficients,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B8, VdGetClosedCaptionReadyStatus,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000001B9, VdGetCurrentDisplayGamma,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000001BA, VdGetCurrentDisplayInformation,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001BB, VdGetDisplayModeOverride,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000001BC, VdGetGraphicsAsicID,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001BD, VdGetSystemCommandBuffer,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000001BE, VdGlobalDevice,                                             kVariable),
+XE_EXPORT(xboxkrnl, 0x000001BF, VdGlobalXamDevice,                                          kVariable),
+XE_EXPORT(xboxkrnl, 0x000001C0, VdGpuClockInMHz,                                            kVariable),
+XE_EXPORT(xboxkrnl, 0x000001C1, VdHSIOCalibrationLock,                                      kVariable),
+XE_EXPORT(xboxkrnl, 0x000001C2, VdInitializeEngines,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001C3, VdInitializeRingBuffer,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000001C4, VdInitializeScaler,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000001C5, VdInitializeScalerCommandBuffer,                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001C6, VdIsHSIOTrainingSucceeded,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000001C7, VdPersistDisplay,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000001C8, VdQuerySystemCommandBuffer,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000001C9, VdQueryVideoFlags,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000001CA, VdQueryVideoMode,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000001CB, VdReadDVERegisterUlong,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000001CC, VdReadWriteHSIOCalibrationFlag,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001CD, VdRegisterGraphicsNotification,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001CE, VdRegisterXamGraphicsNotification,                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000001CF, VdSendClosedCaptionData,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D0, VdSetCGMSOption,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D1, VdSetColorProfileAdjustment,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D2, VdSetCscMatricesOverride,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D3, VdSetDisplayMode,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D4, VdSetDisplayModeOverride,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D5, VdSetGraphicsInterruptCallback,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D6, VdSetHDCPOption,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D7, VdSetMacrovisionOption,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D8, VdSetSystemCommandBuffer,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000001D9, VdSetSystemCommandBufferGpuIdentifierAddress,               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001DA, VdSetWSSData,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001DB, VdSetWSSOption,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000001DC, VdShutdownEngines,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000001DD, VdTurnDisplayOff,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000001DE, VdTurnDisplayOn,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001DF, KiApcNormalRoutineNop,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E0, VdWriteDVERegisterUlong,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E1, XVoicedHeadsetPresent,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E2, XVoicedSubmitPacket,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E3, XVoicedClose,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E4, XVoicedActivate,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E5, XInputdGetCapabilities,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E6, XInputdReadState,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E7, XInputdWriteState,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E8, XInputdNotify,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000001E9, XInputdRawState,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000001EA, HidGetCapabilities,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000001EB, HidReadKeys,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000001EC, XInputdGetDeviceStats,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001ED, XInputdResetDevice,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000001EE, XInputdSetRingOfLight,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001EF, XInputdSetRFPowerMode,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F0, XInputdSetRadioFrequency,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F1, HidGetLastInputTime,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F2, XAudioRenderDriverInitialize,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F3, XAudioRegisterRenderDriverClient,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F4, XAudioUnregisterRenderDriverClient,                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F5, XAudioSubmitRenderDriverFrame,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F6, XAudioRenderDriverLock,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F7, XAudioGetVoiceCategoryVolumeChangeMask,                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F8, XAudioGetVoiceCategoryVolume,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001F9, XAudioSetVoiceCategoryVolume,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001FA, XAudioBeginDigitalBypassMode,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001FB, XAudioEndDigitalBypassMode,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000001FC, XAudioSubmitDigitalPacket,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000001FD, XAudioQueryDriverPerformance,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000001FE, XAudioGetRenderDriverThread,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000001FF, XAudioGetSpeakerConfig,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000200, XAudioSetSpeakerConfig,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000201, NicSetUnicastAddress,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000202, NicAttach,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000203, NicDetach,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000204, NicXmit,                                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000205, NicUpdateMcastMembership,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000206, NicFlushXmitQueue,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000207, NicShutdown,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000208, NicGetLinkState,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000209, NicGetStats,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x0000020A, NicGetOpt,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000020B, NicSetOpt,                                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000020C, DrvSetSysReqCallback,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000020D, DrvSetUserBindingCallback,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000020E, DrvSetContentStorageCallback,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000020F, DrvSetAutobind,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000210, DrvGetContentStorageNotification,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000211, MtpdBeginTransaction,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000212, MtpdCancelTransaction,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000213, MtpdEndTransaction,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000214, MtpdGetCurrentDevices,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000215, MtpdReadData,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000216, MtpdReadEvent,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000217, MtpdResetDevice,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000218, MtpdSendData,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000219, MtpdVerifyProximity,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000021A, XUsbcamSetCaptureMode,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000021B, XUsbcamGetConfig,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000021C, XUsbcamSetConfig,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000021D, XUsbcamGetState,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000021E, XUsbcamReadFrame,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000021F, XUsbcamSnapshot,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000220, XUsbcamSetView,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000221, XUsbcamGetView,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000222, XUsbcamCreate,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000223, XUsbcamDestroy,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000224, XMACreateContext,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000225, XMAInitializeContext,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000226, XMAReleaseContext,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000227, XMAEnableContext,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000228, XMADisableContext,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000229, XMAGetOutputBufferWriteOffset,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000022A, XMASetOutputBufferReadOffset,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000022B, XMAGetOutputBufferReadOffset,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000022C, XMASetOutputBufferValid,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000022D, XMAIsOutputBufferValid,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000022E, XMASetInputBuffer0Valid,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000022F, XMAIsInputBuffer0Valid,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000230, XMASetInputBuffer1Valid,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000231, XMAIsInputBuffer1Valid,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000232, XMASetInputBuffer0,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000233, XMASetInputBuffer1,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000234, XMAGetPacketMetadata,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000235, XMABlockWhileInUse,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000236, XMASetLoopData,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000237, XMASetInputBufferReadOffset,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000238, XMAGetInputBufferReadOffset,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000239, ExIsBetaFeatureEnabled,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000023A, XeKeysGetFactoryChallenge,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000023B, XeKeysSetFactoryResponse,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000023C, XeKeysInitializeFuses,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000023D, XeKeysSaveBootLoader,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000023E, XeKeysSaveKeyVault,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000023F, XeKeysGetStatus,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000240, XeKeysGeneratePrivateKey,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000241, XeKeysGetKeyProperties,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000242, XeKeysSetKey,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000243, XeKeysGenerateRandomKey,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000244, XeKeysGetKey,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000245, XeKeysGetDigest,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000246, XeKeysGetConsoleID,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000247, XeKeysGetConsoleType,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000248, XeKeysQwNeRsaPrvCrypt,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000249, XeKeysHmacSha,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000024A, XInputdPassThroughRFCommand,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x0000024B, XeKeysAesCbc,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000024C, XeKeysDes2Cbc,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000024D, XeKeysDesCbc,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000024E, XeKeysObscureKey,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000024F, XeKeysHmacShaUsingKey,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000250, XeKeysSaveBootLoaderEx,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000251, XeKeysAesCbcUsingKey,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000252, XeKeysDes2CbcUsingKey,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000253, XeKeysDesCbcUsingKey,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000254, XeKeysObfuscate,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000255, XeKeysUnObfuscate,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000256, XeKeysConsolePrivateKeySign,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000257, XeKeysConsoleSignatureVerification,                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000258, XeKeysVerifyRSASignature,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000259, StfsCreateDevice,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000025A, StfsControlDevice,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000025B, VdSwap,                                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000025C, HalFsbInterruptCount,                                       kVariable),
+XE_EXPORT(xboxkrnl, 0x0000025D, XeKeysSaveSystemUpdate,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000025E, XeKeysLockSystemUpdate,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000025F, XeKeysExecute,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000260, XeKeysGetVersions,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000261, XInputdPowerDownDevice,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000262, AniBlockOnAnimation,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000263, AniTerminateAnimation,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000264, XUsbcamReset,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000265, AniSetLogo,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000266, KeCertMonitorData,                                          kVariable),
+XE_EXPORT(xboxkrnl, 0x00000267, HalIsExecutingPowerDownDpc,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000268, VdInitializeEDRAM,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000269, VdRetrainEDRAM,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000026A, VdRetrainEDRAMWorker,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000026B, VdHSIOTrainCount,                                           kVariable),
+XE_EXPORT(xboxkrnl, 0x0000026C, HalGetPowerUpCause,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000026D, VdHSIOTrainingStatus,                                       kVariable),
+XE_EXPORT(xboxkrnl, 0x0000026E, RgcBindInfo,                                                kVariable),
+XE_EXPORT(xboxkrnl, 0x0000026F, VdReadEEDIDBlock,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000270, VdEnumerateVideoModes,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000271, VdEnableHDCP,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000272, VdRegisterHDCPNotification,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000273, HidReadMouseChanges,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000274, DumpSetCollectionFacility,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000275, XexTransformImageKey,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000276, XAudioOverrideSpeakerConfig,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000277, XInputdReadTextKeystroke,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000278, DrvXenonButtonPressed,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000279, DrvBindToUser,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000027A, XexGetModuleImportVersions,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000027B, RtlComputeCrc32,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000027C, XeKeysSetRevocationList,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000027D, HalRegisterPowerDownCallback,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000027E, VdGetDisplayDiscoveryData,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000027F, XInputdSendStayAliveRequest,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000280, XVoicedSendVPort,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000281, XVoicedGetBatteryStatus,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000282, XInputdFFGetDeviceInfo,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000283, XInputdFFSetEffect,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000284, XInputdFFUpdateEffect,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000285, XInputdFFEffectOperation,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000286, XInputdFFDeviceControl,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000287, XInputdFFSetDeviceGain,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000288, XInputdFFCancelIo,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000289, XInputdFFSetRumble,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000028A, NtAllocateEncryptedMemory,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000028B, NtFreeEncryptedMemory,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000028C, XeKeysExSaveKeyVault,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000028D, XeKeysExSetKey,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000028E, XeKeysExGetKey,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000028F, DrvSetDeviceConfigChangeCallback,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000290, DrvDeviceConfigChange,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000291, HalRegisterHdDvdRomNotification,                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000292, XeKeysSecurityInitialize,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000293, XeKeysSecurityLoadSettings,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000294, XeKeysSecuritySaveSettings,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000295, XeKeysSecuritySetDetected,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000296, XeKeysSecurityGetDetected,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000297, XeKeysSecuritySetActivated,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000298, XeKeysSecurityGetActivated,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000299, XeKeysDvdAuthAP25InstallTable,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000029A, XeKeysDvdAuthAP25GetTableVersion,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000029B, XeKeysGetProtectedFlag,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000029C, XeKeysSetProtectedFlag,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000029D, KeEnablePFMInterrupt,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000029E, KeDisablePFMInterrupt,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000029F, KeSetProfilerISR,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A0, VdStartDisplayDiscovery,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A1, VdSetHDCPRevocationList,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A2, XeKeysGetUpdateSequence,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A3, XeKeysDvdAuthExActivate,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A4, KeGetImagePageTableEntry,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A5, HalRegisterBackgroundModeTransitionCallback,                kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A6, AniStartBootAnimation,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A7, HalClampUnclampOutputDACs,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A8, HalPowerDownToBackgroundMode,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000002A9, HalNotifyAddRemoveBackgroundTask,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002AA, HalCallBackgroundModeNotificationRoutines,                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002AB, HalFsbResetCount,                                           kVariable),
+XE_EXPORT(xboxkrnl, 0x000002AC, HalGetMemoryInformation,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002AD, XInputdGetLastTextInputTime,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000002AE, VdEnableWMAProOverHDMI,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000002AF, XeKeysRevokeSaveSettings,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B0, XInputdSetTextMessengerIndicator,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B1, MicDeviceRequest,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B2, XeKeysGetMediaID,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B3, XeKeysLoadKeyVault,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B4, KeGetVidInfo,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B5, HalNotifyBackgroundModeTransitionComplete,                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B6, IoAcquireCancelSpinLock,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B7, IoReleaseCancelSpinLock,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B8, NtCancelIoFile,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000002B9, NtCancelIoFileEx,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002BA, HalFinalizePowerLossRecovery,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000002BB, HalSetPowerLossRecovery,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002BC, ExReadModifyWriteXConfigSettingUlong,                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000002BD, HalRegisterXamPowerDownCallback,                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000002BE, ExCancelAlarm,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000002BF, ExInitializeAlarm,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C0, ExSetAlarm,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C1, XexActivationGetNonce,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C2, XexActivationSetLicense,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C3, IptvSetBoundaryKey,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C4, IptvSetSessionKey,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C5, IptvVerifyOmac1Signature,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C6, IptvGetAesCtrTransform,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C7, SataCdRomRecordReset,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C8, XInputdSetTextDeviceKeyLocks,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000002C9, XInputdGetTextDeviceKeyLocks,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000002CA, XexActivationVerifyOwnership,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000002CB, XexDisableVerboseDbgPrint,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002CC, SvodCreateDevice,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002CD, RtlCaptureStackBackTrace,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000002CE, XeKeysRevokeUpdateDynamic,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002CF, XexImportTraceEnable,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D0, ExRegisterXConfigNotification,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D1, XeKeysSecuritySetStat,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D2, VdQueryRealVideoMode,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D3, XexSetExecutablePrivilege,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D4, XAudioSuspendRenderDriverClients,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D5, IptvGetSessionKeyHash,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D6, VdSetCGMSState,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D7, VdSetSCMSState,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D8, KeFlushMultipleTb,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000002D9, VdGetOption,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000002DA, VdSetOption,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x000002DB, UsbdBootEnumerationDoneEvent,                               kVariable),
+XE_EXPORT(xboxkrnl, 0x000002DC, StfsDeviceErrorEvent,                                       kVariable),
+XE_EXPORT(xboxkrnl, 0x000002DD, ExTryToAcquireReadWriteLockExclusive,                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000002DE, ExTryToAcquireReadWriteLockShared,                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000002DF, XexSetLastKdcTime,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E0, XInputdControl,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E1, RmcDeviceRequest,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E2, LDIResetDecompression,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E3, NicRegisterDevice,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E4, UsbdAddDeviceComplete,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E5, UsbdCancelAsyncTransfer,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E6, UsbdGetDeviceSpeed,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E7, UsbdGetDeviceTopology,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E8, UsbdGetEndpointDescriptor,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002E9, UsbdIsDeviceAuthenticated,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x000002EA, UsbdOpenDefaultEndpoint,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002EB, UsbdOpenEndpoint,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002EC, UsbdQueueAsyncTransfer,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000002ED, UsbdQueueCloseDefaultEndpoint,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000002EE, UsbdQueueCloseEndpoint,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000002EF, UsbdRemoveDeviceComplete,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F0, KeRemoveQueueApc,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F1, UsbdDriverLoadRequiredEvent,                                kVariable),
+XE_EXPORT(xboxkrnl, 0x000002F2, UsbdGetRequiredDrivers,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F3, UsbdRegisterDriverObject,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F4, UsbdUnregisterDriverObject,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F5, UsbdCallAndBlockOnDpcRoutine,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F6, UsbdResetDevice,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F7, UsbdGetDeviceDescriptor,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F8, NomnilGetExtension,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000002F9, NomnilStartCloseDevice,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x000002FA, WifiBeginAuthentication,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x000002FB, WifiCheckCounterMeasures,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x000002FC, WifiChooseAuthenCipherSetFromBSSID,                         kFunction),
+XE_EXPORT(xboxkrnl, 0x000002FD, WifiCompleteAuthentication,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000002FE, WifiGetAssociationIE,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x000002FF, WifiOnMICError,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000300, WifiPrepareAuthenticationContext,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000301, WifiRecvEAPOLPacket,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000302, WifiDeduceNetworkType,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000303, NicUnregisterDevice,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000304, DumpXitThread,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000305, XInputdSetWifiChannel,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000306, NomnilSetLed,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000307, WifiCalculateRegulatoryDomain,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000308, WifiSelectAdHocChannel,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000309, WifiChannelToFrequency,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000030A, MmGetPoolPagesType,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000030B, ExExpansionInstall,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000030C, ExExpansionCall,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000030D, PsCamDeviceRequest,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000030E, McaDeviceRequest,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000030F, DetroitDeviceRequest,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000310, XeCryptSha256Init,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000311, XeCryptSha256Update,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000312, XeCryptSha256Final,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000313, XeCryptSha256,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000314, XeCryptSha384Init,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000315, XeCryptSha384Update,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000316, XInputdGetDevicePid,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000317, HalGetNotedArgonErrors,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000318, XeCryptSha384Final,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000319, HalReadArgonEeprom,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000031A, HalWriteArgonEeprom,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000031B, XeKeysFcrtLoad,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000031C, XeKeysFcrtSave,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000031D, XeKeysFcrtSet,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000031E, XeCryptSha384,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000031F, XeCryptSha512Init,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000320, XAudioRegisterRenderDriverMECClient,                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000321, XAudioUnregisterRenderDriverMECClient,                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000322, XAudioCaptureRenderDriverFrame,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000323, XeCryptSha512Update,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000324, XeCryptSha512Final,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000325, XeCryptSha512,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000326, XeCryptBnQwNeCompare,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000327, XVoicedGetDirectionalData,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000328, DrvSetMicArrayStartCallback,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000329, DevAuthGetStatistics,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000032A, NullCableRequest,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000032B, XeKeysRevokeIsDeviceRevoked,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x0000032C, DumpUpdateDumpSettings,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000032D, EtxConsumerDisableEventType,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x0000032E, EtxConsumerEnableEventType,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000032F, EtxConsumerProcessLogs,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000330, EtxConsumerRegister,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000331, EtxConsumerUnregister,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000332, EtxProducerLog,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000333, EtxProducerLogV,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000334, EtxProducerRegister,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000335, EtxProducerUnregister,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000336, EtxConsumerFlushBuffers,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000337, EtxProducerLogXwpp,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000338, EtxProducerLogXwppV,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000339, UsbdEnableDisableRootHubPort,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000033A, EtxBufferRegister,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000033B, EtxBufferUnregister,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000033C, DumpRegisterDedicatedDataBlock,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000033D, XeKeysDvdAuthExSave,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000033E, XeKeysDvdAuthExInstall,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000033F, XexShimDisable,                                             kFunction),
+XE_EXPORT(xboxkrnl, 0x00000340, XexShimEnable,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000341, XexShimEntryDisable,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000342, XexShimEntryEnable,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000343, XexShimEntryRegister,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000344, XexShimLock,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000345, XboxKrnlVersion4Digit,                                      kVariable),
+XE_EXPORT(xboxkrnl, 0x00000346, XeKeysObfuscateEx,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000347, XeKeysUnObfuscateEx,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x00000348, XexTitleHash,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x00000349, XexTitleHashClose,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000034A, XexTitleHashContinue,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000034B, XexTitleHashOpen,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000034C, XAudioGetRenderDriverTic,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000034D, XAudioEnableDucker,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000034E, XAudioSetDuckerLevel,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000034F, XAudioIsDuckerEnabled,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000350, XAudioGetDuckerLevel,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000351, XAudioGetDuckerThreshold,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000352, XAudioSetDuckerThreshold,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000353, XAudioGetDuckerAttackTime,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000354, XAudioSetDuckerAttackTime,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000355, XAudioGetDuckerReleaseTime,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000356, XAudioSetDuckerReleaseTime,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000357, XAudioGetDuckerHoldTime,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000358, XAudioSetDuckerHoldTime,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x00000359, DevAuthShouldAlwaysEnforce,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000035A, XAudioGetUnderrunCount,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000035B, DrvSetAudioLatencyCallback,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x0000035C, XVoicedIsActiveProcess,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000035D, KeExecuteOnProtectedStack,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000035E, XeKeysVerifyPIRSSignature,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000035F, XeCryptAesCtr,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000360, XeCryptAesCbcMac,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000361, XeCryptAesDmMac,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000362, EmaExecute,                                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000363, XeKeysGetTruncatedSecondaryConsoleId,                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000364, ExFreeDebugPool,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000365, VdQueryVideoCapabilities,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000366, UsbdGetDeviceRootPortType,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000367, VdGet3dVideoFormat,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x00000368, VdGetWSS2Data,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000369, VdSet3dVideoFormat,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000036A, VdSetWSS2Data,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x0000036B, XexReserveCodeBuffer,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000036C, XexCommitCodeBuffer,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000036D, RtlSetVectoredExceptionHandler,                             kFunction),
+XE_EXPORT(xboxkrnl, 0x0000036E, RtlClearVectoredExceptionHandler,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000036F, XAudioSetProcessFrameCallback,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000370, UsbdGetRootHubDeviceNode,                                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000371, UsbdGetPortDeviceNode,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x00000372, UsbdGetNatalHub,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x00000373, UsbdGetNatalHardwareVersion,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000374, UsbdNatalHubRegisterNotificationCallback,                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000375, KeCallAndBlockOnDpcRoutine,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000376, KeCallAndWaitForDpcRoutine,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000377, TidDeviceRequest,                                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000378, DmPrintData,                                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000379, VdSetStudioRGBMode,                                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000037A, UsbdTitleDriverResetAllUnrecognizedPorts,                   kFunction),
+XE_EXPORT(xboxkrnl, 0x0000037B, UsbdTitleDriverSetUnrecognizedPort,                         kFunction),
+XE_EXPORT(xboxkrnl, 0x0000037C, UsbdResetEndpoint,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x0000037D, UsbdSetTimer,                                               kFunction),
+XE_EXPORT(xboxkrnl, 0x0000037E, UsbdCancelTimer,                                            kFunction),
+XE_EXPORT(xboxkrnl, 0x0000037F, UsbdQueueIsochTransfer,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000380, KeSetPageRelocationCallback,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000381, XexRegisterUsermodeModule,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000383, TitleDeviceAuthRequest,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x00000384, KeRegisterSwapNotification,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x00000385, XInputdGetFailedConnectionOrBind,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x00000386, XInputdSetFailedConnectionOrBindCallback,                   kFunction),
+XE_EXPORT(xboxkrnl, 0x00000388, XInputdSetMinMaxAuthDelay,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x00000389, VgcHandler_SetHandlers,                                     kFunction),
+XE_EXPORT(xboxkrnl, 0x0000038A, VvcHandlerCancelTransfers,                                  kFunction),
+XE_EXPORT(xboxkrnl, 0x0000038B, VvcHandlerRetrieveVoiceExtension,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x0000038D, MmResetLowestAvailablePages,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000394, VeSetHandlers,                                              kFunction),
+XE_EXPORT(xboxkrnl, 0x00000395, HalConfigureVeDevice,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000396, XeCryptSha224Init,                                          kFunction),
+XE_EXPORT(xboxkrnl, 0x00000397, XeCryptAesCreateKeySchedule,                                kFunction),
+XE_EXPORT(xboxkrnl, 0x00000398, XeCryptAesEncryptOne,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x00000399, XeCryptAesDecryptOne,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000039A, XeCryptAesCbcEncrypt,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000039B, XeCryptAesCbcDecrypt,                                       kFunction),
+XE_EXPORT(xboxkrnl, 0x0000039C, XeCryptAesGcmInitialize,                                    kFunction),
+XE_EXPORT(xboxkrnl, 0x0000039D, XeCryptAesGcmUpdate,                                        kFunction),
+XE_EXPORT(xboxkrnl, 0x0000039E, XeCryptAesGcmFinalize,                                      kFunction),
+XE_EXPORT(xboxkrnl, 0x0000039F, XeCryptEccGetCurveParameters,                               kFunction),
+XE_EXPORT(xboxkrnl, 0x000003A0, XeCryptEccEcdhGenerateKeypair,                              kFunction),
+XE_EXPORT(xboxkrnl, 0x000003A1, XeCryptEccEcdhExponentiate,                                 kFunction),
+XE_EXPORT(xboxkrnl, 0x000003A2, XeCryptEccEcdsaGenerateSignature,                           kFunction),
+XE_EXPORT(xboxkrnl, 0x000003A3, XeCryptEccEcdsaVerifySignature,                             kFunction),
--- a/XenonUtils/xdbf.h
+++ b/XenonUtils/xdbf.h
@@ -0,0 +1,203 @@
+#pragma once
+
+#include <xbox.h>
+
+#define XDBF_SIGNATURE 0x58444246
+#define XACH_SIGNATURE 0x58414348
+
+struct XDBFHeader
+{
+    be<uint32_t> Signature;
+    be<uint32_t> Version;
+    be<uint32_t> EntryTableLength;
+    be<uint32_t> EntryCount;
+    be<uint32_t> FreeSpaceTableLength;
+    be<uint32_t> FreeSpaceTableEntryCount;
+};
+
+enum EXDBFNamespace : uint16_t
+{
+    XDBF_SPA_NAMESPACE_METADATA = 1,
+    XDBF_SPA_NAMESPACE_IMAGE = 2,
+    XDBF_SPA_NAMESPACE_STRING_TABLE = 3,
+    XDBF_GPD_NAMESPACE_ACHIEVEMENT = 1,
+    XDBF_GPD_NAMESPACE_IMAGE = 2,
+    XDBF_GPD_NAMESPACE_SETTING = 3,
+    XDBF_GPD_NAMESPACE_TITLE = 4,
+    XDBF_GPD_NAMESPACE_STRING = 5,
+    XDBF_GPD_NAMESPACE_ACHIEVEMENT_SECURITY_GFWL = 6,
+    XDBF_GPD_NAMESPACE_AVATAR_AWARD_360 = 6
+};
+
+#pragma pack(push, 1)
+struct XDBFEntry
+{
+    be<EXDBFNamespace> NamespaceID;
+    be<uint64_t> ResourceID;
+    be<uint32_t> Offset;
+    be<uint32_t> Length;
+};
+#pragma pack(pop)
+
+struct XDBFFreeSpaceEntry
+{
+    be<uint32_t> Offset;
+    be<uint32_t> Length;
+};
+
+enum EXDBFLanguage : uint32_t
+{
+    XDBF_LANGUAGE_UNKNOWN = 0,
+    XDBF_LANGUAGE_ENGLISH = 1,
+    XDBF_LANGUAGE_JAPANESE = 2,
+    XDBF_LANGUAGE_GERMAN = 3,
+    XDBF_LANGUAGE_FRENCH = 4,
+    XDBF_LANGUAGE_SPANISH = 5,
+    XDBF_LANGUAGE_ITALIAN = 6,
+    XDBF_LANGUAGE_KOREAN = 7,
+    XDBF_LANGUAGE_CHINESE_TRAD = 8,
+    XDBF_LANGUAGE_PORTUGUESE = 9,
+    XDBF_LANGUAGE_CHINESE_SIMP = 10,
+    XDBF_LANGUAGE_POLISH = 11,
+    XDBF_LANGUAGE_RUSSIAN = 12,
+    XDBF_LANGUAGE_MAX
+};
+
+struct XSTCHeader
+{
+    be<uint32_t> Signature;
+    be<uint32_t> Version;
+    be<uint32_t> Size;
+    be<EXDBFLanguage> Language;
+};
+
+#pragma pack(push, 1)
+struct XSTRHeader
+{
+    be<uint32_t> Signature;
+    be<uint32_t> Version;
+    be<uint32_t> Size;
+    be<uint16_t> StringCount;
+};
+#pragma pack(pop)
+
+struct XSTREntry
+{
+    be<uint16_t> ID;
+    be<uint16_t> Length;
+};
+
+#pragma pack(push, 1)
+struct XACHHeader
+{
+    be<uint32_t> Signature;
+    be<uint32_t> Version;
+    be<uint32_t> Size;
+    be<uint16_t> AchievementCount;
+};
+#pragma pack(pop)
+
+enum EXACHFlags : uint32_t
+{
+    XACH_TYPE_COMPLETION = 1U,
+    XACH_TYPE_LEVELING = 2U,
+    XACH_TYPE_UNLOCK = 3U,
+    XACH_TYPE_EVENT = 4U,
+    XACH_TYPE_TOURNAMENT = 5U,
+    XACH_TYPE_CHECKPOINT = 6U,
+    XACH_TYPE_OTHER = 7U,
+    XACH_TYPE_MASK = 7U,
+    XACH_STATUS_UNACHIEVED = (1U << 4),
+    XACH_STATUS_EARNED_ONLINE = (1U << 16),
+    XACH_STATUS_EARNED = (1U << 17),
+    XACH_STATUS_EDITED = (1U << 20)
+};
+
+struct XACHEntry
+{
+    be<uint16_t> AchievementID;
+    be<uint16_t> NameID;
+    be<uint16_t> UnlockedDescID;
+    be<uint16_t> LockedDescID;
+    be<uint32_t> ImageID;
+    be<uint16_t> Gamerscore;
+    char pad0[0x02];
+    be<EXACHFlags> Flags;
+    char pad1[0x10];
+};
+
+union XDBFTitleID
+{
+    struct
+    {
+        be<uint16_t> u16;
+        char u8[0x02];
+    };
+
+    be<uint32_t> u32;
+};
+
+struct XDBFTitleVersion
+{
+    be<uint16_t> Major;
+    be<uint16_t> Minor;
+    be<uint16_t> Build;
+    be<uint16_t> Revision;
+};
+
+enum EXDBFTitleType : uint32_t
+{
+    XDBF_TITLE_TYPE_SYSTEM = 0,
+    XDBF_TITLE_TYPE_FULL = 1,
+    XDBF_TITLE_TYPE_DEMO = 2,
+    XDBF_TITLE_TYPE_DOWNLOAD = 3
+};
+
+struct XTHDHeader
+{
+    be<uint32_t> Signature;
+    be<uint32_t> Version;
+    be<uint32_t> Size;
+    XDBFTitleID TitleID;
+    be<EXDBFTitleType> Type;
+    XDBFTitleVersion TitleVersion;
+    char pad0[0x10];
+};
+
+#pragma pack(push, 1)
+struct XGAAHeader
+{
+    be<uint32_t> Signature;
+    be<uint32_t> Version;
+    be<uint32_t> Size;
+    be<uint16_t> Count;
+};
+#pragma pack(pop)
+
+struct XGAAEntry
+{
+    char pad0[0x04];
+    be<uint16_t> AvatarAwardID;
+    char pad1[0x06];
+    XDBFTitleID TitleID;
+    be<uint16_t> NameID;
+    be<uint16_t> UnlockedDescID;
+    be<uint16_t> LockedDescID;
+    char pad2[0x02];
+    be<uint32_t> ImageID;
+    char pad3[0x08];
+};
+
+struct XSRCHeader
+{
+    be<uint32_t> Signature;
+    be<uint32_t> Version;
+    be<uint32_t> Size;
+    be<uint32_t> FileNameLength;
+};
+
+struct XSRCHeader2
+{
+    be<uint32_t> UncompressedSize;
+    be<uint32_t> CompressedSize;
+};
--- a/XenonUtils/xdbf_wrapper.cpp
+++ b/XenonUtils/xdbf_wrapper.cpp
@@ -0,0 +1,152 @@
+#include "xdbf_wrapper.h"
+
+XDBFWrapper::XDBFWrapper(const uint8_t* buffer, size_t bufferSize) : pBuffer(buffer), BufferSize(bufferSize)
+{
+    if (!buffer || bufferSize <= sizeof(XDBFHeader))
+    {
+        pBuffer = nullptr;
+        return;
+    }
+
+    auto seek = pBuffer;
+
+    pHeader = (XDBFHeader*)seek;
+    seek += sizeof(XDBFHeader);
+
+    if (pHeader->Signature != XDBF_SIGNATURE)
+    {
+        pBuffer = nullptr;
+        return;
+    }
+
+    pEntries = (XDBFEntry*)seek;
+    seek += sizeof(XDBFEntry) * pHeader->EntryCount;
+
+    pFiles = (XDBFFreeSpaceEntry*)seek;
+    seek += sizeof(XDBFFreeSpaceEntry) * pHeader->FreeSpaceTableLength;
+
+    pContent = seek;
+}
+
+XDBFBlock XDBFWrapper::GetResource(EXDBFNamespace ns, uint64_t id) const
+{
+    for (int i = 0; i < pHeader->EntryCount; i++)
+    {
+        auto& entry = pEntries[i];
+
+        if (entry.NamespaceID == ns && entry.ResourceID == id)
+        {
+            XDBFBlock block{};
+            block.pBuffer = pContent + entry.Offset;
+            block.BufferSize = entry.Length;
+            return block;
+        }
+    }
+
+    return { nullptr };
+}
+
+std::string XDBFWrapper::GetString(EXDBFLanguage language, uint16_t id) const
+{
+    auto languageBlock = GetResource(XDBF_SPA_NAMESPACE_STRING_TABLE, (uint64_t)language);
+
+    if (!languageBlock)
+        return "";
+
+    auto pHeader = (XSTRHeader*)languageBlock.pBuffer;
+    auto seek = languageBlock.pBuffer + sizeof(XSTRHeader);
+
+    for (int i = 0; i < pHeader->StringCount; i++)
+    {
+        auto entry = (XSTREntry*)seek;
+
+        seek += sizeof(XSTREntry);
+
+        if (entry->ID == id)
+            return std::string((const char*)seek, entry->Length);
+
+        seek += entry->Length;
+    }
+
+    return "";
+}
+
+std::vector<Achievement> XDBFWrapper::GetAchievements(EXDBFLanguage language) const
+{
+    std::vector<Achievement> result;
+
+    auto achievementsBlock = GetResource(XDBF_SPA_NAMESPACE_METADATA, XACH_SIGNATURE);
+
+    if (!achievementsBlock)
+        return result;
+
+    auto pHeader = (XACHHeader*)achievementsBlock.pBuffer;
+    auto seek = achievementsBlock.pBuffer + sizeof(XACHHeader);
+
+    for (int i = 0; i < pHeader->AchievementCount; i++)
+    {
+        auto entry = (XACHEntry*)seek;
+
+        seek += sizeof(XACHEntry);
+
+        Achievement achievement{};
+        achievement.ID = entry->AchievementID;
+        achievement.Name = GetString(language, entry->NameID);
+        achievement.UnlockedDesc = GetString(language, entry->UnlockedDescID);
+        achievement.LockedDesc = GetString(language, entry->LockedDescID);
+        achievement.Score = entry->Gamerscore;
+
+        auto imageBlock = GetResource(XDBF_SPA_NAMESPACE_IMAGE, entry->ImageID);
+
+        if (imageBlock)
+        {
+            achievement.pImageBuffer = imageBlock.pBuffer;
+            achievement.ImageBufferSize = imageBlock.BufferSize;
+        }
+
+        result.push_back(achievement);
+    }
+
+    return result;
+}
+
+Achievement XDBFWrapper::GetAchievement(EXDBFLanguage language, uint16_t id) const
+{
+    Achievement result{};
+
+    auto achievementsBlock = GetResource(XDBF_SPA_NAMESPACE_METADATA, 0x58414348);
+
+    if (!achievementsBlock)
+        return result;
+
+    auto pHeader = (XACHHeader*)achievementsBlock.pBuffer;
+    auto seek = achievementsBlock.pBuffer + sizeof(XACHHeader);
+
+    for (int i = 0; i < pHeader->AchievementCount; i++)
+    {
+        auto entry = (XACHEntry*)seek;
+
+        seek += sizeof(XACHEntry);
+
+        if (entry->AchievementID == id)
+        {
+            result.ID = entry->AchievementID;
+            result.Name = GetString(language, entry->NameID);
+            result.UnlockedDesc = GetString(language, entry->UnlockedDescID);
+            result.LockedDesc = GetString(language, entry->LockedDescID);
+            result.Score = entry->Gamerscore;
+
+            auto imageBlock = GetResource(XDBF_SPA_NAMESPACE_IMAGE, entry->ImageID);
+
+            if (imageBlock)
+            {
+                result.pImageBuffer = imageBlock.pBuffer;
+                result.ImageBufferSize = imageBlock.BufferSize;
+            }
+
+            return result;
+        }
+    }
+
+    return result;
+}
--- a/XenonUtils/xdbf_wrapper.h
+++ b/XenonUtils/xdbf_wrapper.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <vector>
+#include "xdbf.h"
+
+struct Achievement
+{
+    uint16_t ID;
+    std::string Name;
+    std::string UnlockedDesc;
+    std::string LockedDesc;
+    const uint8_t* pImageBuffer;
+    size_t ImageBufferSize;
+    uint16_t Score;
+};
+
+struct XDBFBlock
+{
+    const uint8_t* pBuffer;
+    size_t BufferSize;
+
+    operator bool() const
+    {
+        return pBuffer;
+    }
+};
+
+class XDBFWrapper
+{
+public:
+    const uint8_t* pBuffer;
+    size_t BufferSize;
+
+    const uint8_t* pContent;
+
+    const XDBFHeader* pHeader;
+    const XDBFEntry* pEntries;
+    const XDBFFreeSpaceEntry* pFiles;
+
+    XDBFWrapper() {}
+    XDBFWrapper(const uint8_t* pBuffer, size_t bufferSize);
+    XDBFBlock GetResource(EXDBFNamespace ns, uint64_t id) const;
+    std::string GetString(EXDBFLanguage language, uint16_t id) const;
+    std::vector<Achievement> GetAchievements(EXDBFLanguage language) const;
+    Achievement GetAchievement(EXDBFLanguage language, uint16_t id) const;
+};
--- a/XenonUtils/xex.cpp
+++ b/XenonUtils/xex.cpp
@@ -0,0 +1,252 @@
+#include "xex.h"
+#include "image.h"
+#include <cassert>
+#include <cstring>
+#include <vector>
+#include <unordered_map>
+
+#define STRINGIFY(X) #X
+#define XE_EXPORT(MODULE, ORDINAL, NAME, TYPE) { (ORDINAL), "__imp__" STRINGIFY(NAME) }
+
+#ifndef _WIN32
+
+typedef struct _IMAGE_DOS_HEADER { 
+    uint16_t   e_magic;                
+    uint16_t   e_cblp;                 
+    uint16_t   e_cp;                   
+    uint16_t   e_crlc;                 
+    uint16_t   e_cparhdr;              
+    uint16_t   e_minalloc;             
+    uint16_t   e_maxalloc;             
+    uint16_t   e_ss;                   
+    uint16_t   e_sp;                   
+    uint16_t   e_csum;                 
+    uint16_t   e_ip;                   
+    uint16_t   e_cs;                   
+    uint16_t   e_lfarlc;               
+    uint16_t   e_ovno;                 
+    uint16_t   e_res[4];               
+    uint16_t   e_oemid;                
+    uint16_t   e_oeminfo;              
+    uint16_t   e_res2[10];             
+    uint32_t   e_lfanew;               
+} IMAGE_DOS_HEADER, * PIMAGE_DOS_HEADER;
+
+typedef struct _IMAGE_FILE_HEADER {
+    uint16_t   Machine;
+    uint16_t   NumberOfSections;
+    uint32_t   TimeDateStamp;
+    uint32_t   PointerToSymbolTable;
+    uint32_t   NumberOfSymbols;
+    uint16_t   SizeOfOptionalHeader;
+    uint16_t   Characteristics;
+} IMAGE_FILE_HEADER, * PIMAGE_FILE_HEADER;
+
+typedef struct _IMAGE_DATA_DIRECTORY {
+    uint32_t   VirtualAddress;
+    uint32_t   Size;
+} IMAGE_DATA_DIRECTORY, * PIMAGE_DATA_DIRECTORY;
+
+#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
+
+typedef struct _IMAGE_OPTIONAL_HEADER {
+    uint16_t   Magic;
+    uint8_t    MajorLinkerVersion;
+    uint8_t    MinorLinkerVersion;
+    uint32_t   SizeOfCode;
+    uint32_t   SizeOfInitializedData;
+    uint32_t   SizeOfUninitializedData;
+    uint32_t   AddressOfEntryPoint;
+    uint32_t   BaseOfCode;
+    uint32_t   BaseOfData;
+    uint32_t   ImageBase;
+    uint32_t   SectionAlignment;
+    uint32_t   FileAlignment;
+    uint16_t   MajorOperatingSystemVersion;
+    uint16_t   MinorOperatingSystemVersion;
+    uint16_t   MajorImageVersion;
+    uint16_t   MinorImageVersion;
+    uint16_t   MajorSubsystemVersion;
+    uint16_t   MinorSubsystemVersion;
+    uint32_t   Win32VersionValue;
+    uint32_t   SizeOfImage;
+    uint32_t   SizeOfHeaders;
+    uint32_t   CheckSum;
+    uint16_t   Subsystem;
+    uint16_t   DllCharacteristics;
+    uint32_t   SizeOfStackReserve;
+    uint32_t   SizeOfStackCommit;
+    uint32_t   SizeOfHeapReserve;
+    uint32_t   SizeOfHeapCommit;
+    uint32_t   LoaderFlags;
+    uint32_t   NumberOfRvaAndSizes;
+    IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
+} IMAGE_OPTIONAL_HEADER32, * PIMAGE_OPTIONAL_HEADER32;
+
+typedef struct _IMAGE_NT_HEADERS {
+    uint32_t Signature;
+    IMAGE_FILE_HEADER FileHeader;
+    IMAGE_OPTIONAL_HEADER32 OptionalHeader;
+} IMAGE_NT_HEADERS32, * PIMAGE_NT_HEADERS32;
+
+#define IMAGE_SIZEOF_SHORT_NAME              8
+
+typedef struct _IMAGE_SECTION_HEADER {
+    uint8_t    Name[IMAGE_SIZEOF_SHORT_NAME];
+    union {
+        uint32_t   PhysicalAddress;
+        uint32_t   VirtualSize;
+    } Misc;
+    uint32_t   VirtualAddress;
+    uint32_t   SizeOfRawData;
+    uint32_t   PointerToRawData;
+    uint32_t   PointerToRelocations;
+    uint32_t   PointerToLinenumbers;
+    uint16_t   NumberOfRelocations;
+    uint16_t   NumberOfLinenumbers;
+    uint32_t   Characteristics;
+} IMAGE_SECTION_HEADER, * PIMAGE_SECTION_HEADER;
+
+#define IMAGE_SCN_CNT_CODE                   0x00000020
+
+#endif
+
+std::unordered_map<size_t, const char*> XamExports = 
+{
+    #include "xbox/xam_table.inc"
+};
+
+std::unordered_map<size_t, const char*> XboxKernelExports =
+{
+    #include "xbox/xboxkrnl_table.inc"
+};
+
+Image Xex2LoadImage(const uint8_t* data)
+{
+    auto* header = reinterpret_cast<const XEX_HEADER*>(data);
+    auto* security = reinterpret_cast<const XEX2_SECURITY_INFO*>(data + header->AddressOfSecurityInfo);
+
+    const auto* compressionInfo = Xex2FindOptionalHeader<XEX_FILE_FORMAT_INFO>(header, XEX_HEADER_FILE_FORMAT_INFO);
+
+    Image image{};
+    std::unique_ptr<uint8_t[]> result{};
+    size_t imageSize = security->SizeOfImage;
+
+    // Decompress image
+    if (compressionInfo != nullptr)
+    {
+        assert(compressionInfo->CompressionType <= XEX_COMPRESSION_BASIC);
+        assert(compressionInfo->EncryptionType == XEX_ENCRYPTION_NONE);
+
+        if (compressionInfo->CompressionType == XEX_COMPRESSION_NONE)
+        {
+            result = std::make_unique<uint8_t[]>(imageSize);
+            memcpy(result.get(), data + header->SizeOfHeader, imageSize);
+        }
+        else if (compressionInfo->CompressionType == XEX_COMPRESSION_BASIC)
+        {
+            auto* blocks = reinterpret_cast<const XEX_BASIC_FILE_COMPRESSION_INFO*>(compressionInfo + 1);
+            const size_t numBlocks = (compressionInfo->SizeOfHeader / sizeof(XEX_BASIC_FILE_COMPRESSION_INFO)) - 1;
+
+            imageSize = 0;
+            for (size_t i = 0; i < numBlocks; i++)
+            {
+                imageSize += blocks[i].SizeOfData + blocks[i].SizeOfPadding;
+            }
+
+            result = std::make_unique<uint8_t[]>(imageSize);
+            auto* srcData = data + header->SizeOfHeader;
+            auto* destData = result.get();
+
+            for (size_t i = 0; i < numBlocks; i++)
+            {
+                memcpy(destData, srcData, blocks[i].SizeOfData);
+
+                srcData += blocks[i].SizeOfData;
+                destData += blocks[i].SizeOfData;
+
+                memset(destData, 0, blocks[i].SizeOfPadding);
+                destData += blocks[i].SizeOfPadding;
+            }
+        }
+    }
+
+    image.data = std::move(result);
+    image.size = imageSize;
+
+    // Map image
+    const auto* dosHeader = reinterpret_cast<IMAGE_DOS_HEADER*>(image.data.get());
+    const auto* ntHeaders = reinterpret_cast<IMAGE_NT_HEADERS32*>(image.data.get() + dosHeader->e_lfanew);
+
+    image.base = ntHeaders->OptionalHeader.ImageBase;
+    image.entry_point = image.base + ntHeaders->OptionalHeader.AddressOfEntryPoint;
+
+    const auto numSections = ntHeaders->FileHeader.NumberOfSections;
+    const auto* sections = reinterpret_cast<const IMAGE_SECTION_HEADER*>(ntHeaders + 1);
+
+    for (size_t i = 0; i < numSections; i++)
+    {
+        const auto& section = sections[i];
+        uint8_t flags{};
+
+        if (section.Characteristics & IMAGE_SCN_CNT_CODE)
+        {
+            flags |= SectionFlags_Code;
+        }
+
+        image.Map(reinterpret_cast<const char*>(section.Name), section.VirtualAddress, 
+            section.Misc.VirtualSize, flags, image.data.get() + section.VirtualAddress);
+    }
+
+    auto* imports = Xex2FindOptionalHeader<XEX_IMPORT_HEADER>(header, XEX_HEADER_IMPORT_LIBRARIES);
+    if (imports != nullptr)
+    {
+        std::vector<std::string_view> stringTable;
+        auto* pStrTable = reinterpret_cast<const char*>(imports + 1);
+
+        for (size_t i = 0; i < imports->NumImports; i++)
+        {
+            stringTable.emplace_back(pStrTable);
+            pStrTable += strlen(pStrTable) + 1;
+        }
+
+        auto* library = (XEX_IMPORT_LIBRARY*)(((char*)imports) + sizeof(XEX_IMPORT_HEADER) + imports->SizeOfStringTable);
+        for (size_t i = 0; i < stringTable.size(); i++)
+        {
+            auto* descriptors = (XEX_IMPORT_DESCRIPTOR*)(library + 1);
+            static std::unordered_map<size_t, const char*> DummyExports;
+            const std::unordered_map<size_t, const char*>* names = &DummyExports;
+
+            if (stringTable[i] == "xam.xex")
+            {
+                names = &XamExports;
+            }
+            else if (stringTable[i] == "xboxkrnl.exe")
+            {
+                names = &XboxKernelExports;
+            }
+
+            for (size_t im = 0; im < library->NumberOfImports; im++)
+            {
+                auto originalThunk = (XEX_THUNK_DATA*)image.Find(descriptors[im].FirstThunk);
+                auto originalData = originalThunk;
+                originalData->Data = ByteSwap(originalData->Data);
+
+                if (originalData->OriginalData.Type != 0)
+                {
+                    uint32_t thunk[4] = { 0x00000060, 0x00000060, 0x00000060, 0x2000804E };
+                    auto name = names->find(originalData->OriginalData.Ordinal);
+                    if (name != names->end())
+                    {
+                        image.symbols.insert({ name->second, descriptors[im].FirstThunk, sizeof(thunk), Symbol_Function });
+                    }
+
+                    memcpy(originalThunk, thunk, sizeof(thunk));
+                }
+            }
+            library = (XEX_IMPORT_LIBRARY*)((char*)(library + 1) + library->NumberOfImports * sizeof(XEX_IMPORT_DESCRIPTOR));
+        }
+    }
+
+    return image;
+}
--- a/XenonUtils/xex.h
+++ b/XenonUtils/xex.h
@@ -0,0 +1,176 @@
+#pragma once
+#include <memory>
+#include "xbox.h"
+
+#define XEX_COMPRESSION_NONE 0
+#define XEX_COMPRESSION_BASIC 1
+
+#define XEX_ENCRYPTION_NONE 0
+
+enum _XEX_THUNK_TYPES
+{
+    XEX_THUNK_VARIABLE = 0,
+    XEX_THUNK_FUNCTION = 1,
+};
+
+enum _XEX_OPTIONAL_HEADER_TYPES
+{
+    XEX_HEADER_RESOURCE_INFO = 0x000002FF,
+    XEX_HEADER_FILE_FORMAT_INFO = 0x000003FF,
+    XEX_HEADER_DELTA_PATCH_DESCRIPTOR = 0x000005FF,
+    XEX_HEADER_BASE_REFERENCE = 0x00000405,
+    XEX_HEADER_BOUNDING_PATH = 0x000080FF,
+    XEX_HEADER_DEVICE_ID = 0x00008105,
+    XEX_HEADER_ORIGINAL_BASE_ADDRESS = 0x00010001,
+    XEX_HEADER_ENTRY_POINT = 0x00010100,
+    XEX_HEADER_IMAGE_BASE_ADDRESS = 0x00010201,
+    XEX_HEADER_IMPORT_LIBRARIES = 0x000103FF,
+    XEX_HEADER_CHECKSUM_TIMESTAMP = 0x00018002,
+    XEX_HEADER_ENABLED_FOR_CALLCAP = 0x00018102,
+    XEX_HEADER_ENABLED_FOR_FASTCAP = 0x00018200,
+    XEX_HEADER_ORIGINAL_PE_NAME = 0x000183FF,
+    XEX_HEADER_STATIC_LIBRARIES = 0x000200FF,
+    XEX_HEADER_TLS_INFO = 0x00020104,
+    XEX_HEADER_DEFAULT_STACK_SIZE = 0x00020200,
+    XEX_HEADER_DEFAULT_FILESYSTEM_CACHE_SIZE = 0x00020301,
+    XEX_HEADER_DEFAULT_HEAP_SIZE = 0x00020401,
+    XEX_HEADER_PAGE_HEAP_SIZE_AND_FLAGS = 0x00028002,
+    XEX_HEADER_SYSTEM_FLAGS = 0x00030000,
+    XEX_HEADER_EXECUTION_INFO = 0x00040006,
+    XEX_HEADER_TITLE_WORKSPACE_SIZE = 0x00040201,
+    XEX_HEADER_GAME_RATINGS = 0x00040310,
+    XEX_HEADER_LAN_KEY = 0x00040404,
+    XEX_HEADER_XBOX360_LOGO = 0x000405FF,
+    XEX_HEADER_MULTIDISC_MEDIA_IDS = 0x000406FF,
+    XEX_HEADER_ALTERNATE_TITLE_IDS = 0x000407FF,
+    XEX_HEADER_ADDITIONAL_TITLE_MEMORY = 0x00040801,
+    XEX_HEADER_EXPORTS_BY_NAME = 0x00E10402,
+};
+
+typedef struct _XEX_FILE_FORMAT_INFO
+{
+    be<uint32_t> SizeOfHeader;
+    be<uint16_t> EncryptionType;
+    be<uint16_t> CompressionType;
+} XEX_FILE_FORMAT_INFO;
+
+typedef struct _XEX_RESOURCE_INFO
+{
+    be<uint32_t> SizeOfHeader;
+    uint8_t ResourceID[8];
+    be<uint32_t> Offset;
+    be<uint32_t> SizeOfData;
+} XEX_RESOURCE_INFO;
+
+typedef struct _XEX_BASIC_FILE_COMPRESSION_INFO
+{
+    be<uint32_t> SizeOfData;
+    be<uint32_t> SizeOfPadding;
+} XEX_BASIC_FILE_COMPRESSION_INFO;
+
+typedef struct _XEX_THUNK_DATA {
+    union
+    {
+        struct
+        {
+            uint16_t Ordinal : 16;
+            uint16_t Hint : 8;
+            uint16_t Type : 8;
+        } OriginalData;
+
+        be<uint32_t> Ordinal;
+        be<uint32_t> Function;
+        be<uint32_t> AddressOfData;
+
+        // For easier swapping
+        uint32_t Data;
+    };
+} XEX_THUNK_DATA;
+
+typedef struct _XEX_IMPORT_HEADER {
+    be<uint32_t> SizeOfHeader;
+    be<uint32_t> SizeOfStringTable;
+    be<uint32_t> NumImports;
+} XEX_IMPORT_HEADER;
+
+typedef struct _XEX_IMPORT_LIBRARY {
+    be<uint32_t> Size;
+    char NextImportDigest[0x14];
+    be<uint32_t> ID;
+    be<uint32_t> Version;
+    be<uint32_t> MinVersion;
+    be<uint16_t> Name;
+    be<uint16_t> NumberOfImports;
+} XEX_IMPORT_LIBRARY;
+
+static_assert(sizeof(XEX_IMPORT_LIBRARY) == 0x28);
+
+typedef struct _XEX_IMPORT_DESCRIPTOR {
+    be<uint32_t> FirstThunk; // VA XEX_THUNK_DATA
+} XEX_IMPORT_DESCRIPTOR;
+
+typedef struct _XEX_OPTIONAL_HEADER
+{
+    be<uint32_t> Type;
+    be<uint32_t> Address;
+} XEX_OPTIONAL_HEADER;
+
+typedef struct _XEX2_SECURITY_INFO
+{
+    be<uint32_t> SizeOfHeader;
+    be<uint32_t> SizeOfImage;
+    char RsaSignature[0x100];
+    be<uint32_t> Unknown108;
+    be<uint32_t> ImageFlags;
+    be<uint32_t> ImageBase;
+    char SectionDigest[0x14];
+    be<uint32_t> NumberOfImports;
+    char ImportsDigest[0x14];
+    char Xgd2MediaID[0x10];
+    char AesKey[0x10];
+    be<uint32_t> AddressOfExports;
+    char HeaderDigest[0x14];
+    be<uint32_t> Region;
+    be<uint32_t> AllowedMediaTypes;
+    be<uint32_t> NumberOfPageDescriptors;
+} XEX2_SECURITY_INFO;
+
+typedef struct _XEX_HEADER
+{
+    char Signature[4];
+    be<uint32_t> Flags;
+    be<uint32_t> SizeOfHeader;
+    char Reserved[4];
+    be<uint32_t> AddressOfSecurityInfo;
+    be<uint32_t> NumberOfOptionalHeaders;
+} XEX_HEADER;
+
+template<typename T>
+inline static const T* Xex2FindOptionalHeader(const void* base, const XEX_OPTIONAL_HEADER* headers, size_t n, _XEX_OPTIONAL_HEADER_TYPES type)
+{
+    for (size_t i = 0; i < n; i++)
+    {
+        if (headers[i].Type == (uint32_t)type)
+        {
+            if ((type & 0xFF) == 0)
+            {
+                return reinterpret_cast<const T*>(&headers[i].Address);
+            }
+            else
+            {
+                return reinterpret_cast<const T*>(static_cast<const char*>(base) + headers[i].Address);
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+template<typename T>
+inline static const T* Xex2FindOptionalHeader(const XEX_HEADER* header, _XEX_OPTIONAL_HEADER_TYPES type)
+{
+    return Xex2FindOptionalHeader<T>(header, (XEX_OPTIONAL_HEADER*)(header + 1), header->NumberOfOptionalHeaders, type);
+}
+
+struct Image;
+Image Xex2LoadImage(const uint8_t* data);