chore: Update codebase

chore: Update vscode workspace files
chore: General cleanup
2025-08-05 11:24:16 +00:00 · 2024-11-28 04:47:30 +02:00 · 2024-11-27 01:56:37 +02:00 · 2024-11-27 01:19:24 +02:00 · 2024-11-26 04:13:34 +02:00 · 2024-11-26 04:03:57 +02:00
720 changed files with 101054 additions and 50717 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,34 @@
+# Include any files or directories that you don't want to be copied to your
+# container here (e.g., local build artifacts, temporary files, etc.).
+#
+# For more help, visit the .dockerignore file reference guide at
+# https://docs.docker.com/go/build-context-dockerignore/
+
+**/.DS_Store
+**/__pycache__
+**/.venv
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose.y*ml
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md
--- a/.github/workflows/makefile.yml
+++ b/.github/workflows/makefile.yml
@@ -9,7 +9,7 @@ on:
 jobs:
  deploydoc:
    name: Deploy Documentation to GitHub Pages
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
@@ -17,7 +17,7 @@ jobs:
          submodules: recursive

      - name: Install Doxygen
-        run: sudo apt-get install doxygen make -y
+        run: sudo apt -y install doxygen make

      - name: Generate Documentation
        run: make doxygen
@@ -32,7 +32,7 @@ jobs:

  buildcompiler:
    name: Build Cross-Compiler & Toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
    steps:
    - uses: actions/checkout@v3
      with:
@@ -47,7 +47,7 @@ jobs:

    - name: Update System
      if: steps.cache-cross.outputs.cache-hit != 'true'
-      run: sudo apt-get update
+      run: sudo apt update

    - name: Install GCC Dependencies
      if: steps.cache-cross.outputs.cache-hit != 'true'
@@ -57,59 +57,24 @@ jobs:
      if: steps.cache-cross.outputs.cache-hit != 'true'
      run: make --quiet -C tools __clone_all_no_qemu

-    - name: Compile Binutils amd64
+    - name: Compile Binutils
      if: steps.cache-cross.outputs.cache-hit != 'true'
-      run: make --quiet -C tools do_binutils_64
+      run: make --quiet -C tools do_binutils

-    - name: Compile Binutils i386
+    - name: Compile GCC
      if: steps.cache-cross.outputs.cache-hit != 'true'
-      run: make --quiet -C tools do_binutils_32
-
-    - name: Compile GCC amd64
-      if: steps.cache-cross.outputs.cache-hit != 'true'
-      run: make --quiet -C tools do_gcc_64
-
-    - name: Compile GCC i386
-      if: steps.cache-cross.outputs.cache-hit != 'true'
-      run: make --quiet -C tools do_gcc_32
+      run: make --quiet -C tools do_gcc

    - name: Clean Up
      if: steps.cache-cross.outputs.cache-hit != 'true'
      run: |
        cd tools
-        rm -rf binutils-gdb gcc build-binutils64 build-gcc64 build-binutils32 build-gcc32
-
-  compilegnuefi:
-    name: Build GNU-EFI
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: recursive
-
-    - name: Cache gnu-efi Folder
-      id: cache-gnuefi
-      uses: actions/cache@v3
-      with:
-        path: Lynx/gnu-efi
-        key: ${{ runner.os }}-gnuefi-${{ hashFiles('Lynx/Makefile') }}
-
-    - name: Update System
-      if: steps.cache-gnuefi.outputs.cache-hit != 'true'
-      run: sudo apt-get update
-
-    - name: Install MinGW compiler
-      if: steps.cache-gnuefi.outputs.cache-hit != 'true'
-      run: sudo apt-get install make gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 -y
-
-    - name: Get GNU-EFI source code and compile it
-      if: steps.cache-gnuefi.outputs.cache-hit != 'true'
-      run: make --quiet -C Lynx prepare
+        rm -rf binutils-gdb gcc

  analyze:
    name: Analyze with CodeQL
-    runs-on: ubuntu-latest
-    needs: [buildcompiler, compilegnuefi]
+    runs-on: ubuntu-22.04
+    needs: [buildcompiler]
    permissions:
      actions: read
      contents: read
@@ -133,12 +98,11 @@ jobs:

    - name: Install Packages
      run: |
-        sudo apt-get update
-        sudo apt-get install rustc xorriso mtools genisoimage ovmf nasm doxygen make gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 build-essential bison flex libgmp3-dev libmpc-dev libmpfr-dev texinfo -y
+        sudo apt update
+        sudo apt install rustc xorriso mtools genisoimage ovmf nasm doxygen make gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 build-essential bison flex libgmp3-dev libmpc-dev libmpfr-dev texinfo -y
        make --quiet -C tools do_limine
        make --quiet -C Drivers prepare
        make --quiet -C Userspace prepare
-        make --quiet -C Lynx prepare
        make --quiet -C Kernel prepare

    - name: Cache cross
@@ -148,16 +112,8 @@ jobs:
        path: tools/cross
        key: ${{ runner.os }}-cross-${{ hashFiles('tools/Makefile') }}

-    - name: Cache gnuefi
-      id: cache-gnuefi
-      uses: actions/cache@v3
-      with:
-        path: Lynx/gnu-efi
-        key: ${{ runner.os }}-gnuefi-${{ hashFiles('Lynx/Makefile') }}
-
    - name: Build OS
      run: |
-        make build_lynx
        make build_userspace
        make build_drivers
        make build_kernel
@@ -168,8 +124,8 @@ jobs:

  compile64:
    name: Build amd64
-    runs-on: ubuntu-latest
-    needs: [buildcompiler, compilegnuefi]
+    runs-on: ubuntu-22.04
+    needs: [buildcompiler]
    steps:
    - uses: actions/checkout@v3
      with:
@@ -177,12 +133,11 @@ jobs:

    - name: Update & Install Required Packages
      run: |
-        sudo apt-get update
-        sudo apt-get install rustc xorriso mtools genisoimage ovmf nasm doxygen make meson gcc-10 g++-10 gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 -y
+        sudo apt update
+        sudo apt install rustc xorriso mtools genisoimage ovmf nasm doxygen make meson gcc-10 g++-10 gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 -y
        make --quiet -C tools do_limine
        make --quiet -C Drivers prepare
        make --quiet -C Userspace prepare
-        make --quiet -C Lynx prepare
        make --quiet -C Kernel prepare

    - name: Cache cross Folder
@@ -192,13 +147,6 @@ jobs:
        path: tools/cross
        key: ${{ runner.os }}-cross-${{ hashFiles('tools/Makefile') }}

-    - name: Cache gnu-efi Folder
-      id: cache-gnuefi
-      uses: actions/cache@v3
-      with:
-        path: Lynx/gnu-efi
-        key: ${{ runner.os }}-gnuefi-${{ hashFiles('Lynx/Makefile') }}
-
    - name: Configure Makefile.conf
      run: sed -i 's/.*OSARCH = .*/OSARCH = amd64/' ./Makefile.conf && cat Makefile.conf | grep OSARCH

@@ -225,8 +173,8 @@ jobs:

  compile32:
    name: Build i386
-    runs-on: ubuntu-latest
-    needs: [buildcompiler, compilegnuefi]
+    runs-on: ubuntu-22.04
+    needs: [buildcompiler]
    steps:
    - uses: actions/checkout@v3
      with:
@@ -234,12 +182,11 @@ jobs:

    - name: Update & Install Required Packages
      run: |
-        sudo apt-get update
-        sudo apt-get install rustc xorriso mtools genisoimage ovmf nasm doxygen make meson gcc-10 g++-10 gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 -y
+        sudo apt update
+        sudo apt install rustc xorriso mtools genisoimage ovmf nasm doxygen make meson gcc-10 g++-10 gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 -y
        make --quiet -C tools do_limine
        make --quiet -C Drivers prepare
        make --quiet -C Userspace prepare
-        make --quiet -C Lynx prepare
        make --quiet -C Kernel prepare

    - name: Cache cross Folder
@@ -249,13 +196,6 @@ jobs:
        path: tools/cross
        key: ${{ runner.os }}-cross-${{ hashFiles('tools/Makefile') }}

-    - name: Cache gnu-efi Folder
-      id: cache-gnuefi
-      uses: actions/cache@v3
-      with:
-        path: Lynx/gnu-efi
-        key: ${{ runner.os }}-gnuefi-${{ hashFiles('Lynx/Makefile') }}
-
    - name: Configure Makefile.conf
      run: sed -i 's/.*OSARCH = .*/OSARCH = i386/' ./Makefile.conf && cat Makefile.conf | grep OSARCH

@@ -283,8 +223,8 @@ jobs:
  compilearm64:
    if: ${{ false }} # Disabled until we can get it to work
    name: Build aarch64
-    runs-on: ubuntu-latest
-    needs: [buildcompiler, compilegnuefi]
+    runs-on: ubuntu-22.04
+    needs: [buildcompiler]
    steps:
    - uses: actions/checkout@v3
      with:
@@ -292,12 +232,11 @@ jobs:

    - name: Update & Install Required Packages
      run: |
-        sudo apt-get update
-        sudo apt-get install rustc xorriso mtools genisoimage ovmf nasm doxygen make meson gcc-10 g++-10 gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 -y
+        sudo apt update
+        sudo apt install rustc xorriso mtools genisoimage ovmf nasm doxygen make meson gcc-10 g++-10 gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 mingw-w64 -y
        make --quiet -C tools do_limine
        make --quiet -C Drivers prepare
        make --quiet -C Userspace prepare
-        make --quiet -C Lynx prepare
        make --quiet -C Kernel prepare

    - name: Cache cross Folder
@@ -307,13 +246,6 @@ jobs:
        path: tools/cross
        key: ${{ runner.os }}-cross-${{ hashFiles('tools/Makefile') }}

-    - name: Cache gnu-efi Folder
-      id: cache-gnuefi
-      uses: actions/cache@v3
-      with:
-        path: Lynx/gnu-efi
-        key: ${{ runner.os }}-gnuefi-${{ hashFiles('Lynx/Makefile') }}
-
    - name: Configure Makefile.conf
      run: sed -i 's/.*OSARCH = .*/OSARCH = aarch64/' ./Makefile.conf && cat Makefile.conf | grep OSARCH

--- a/.gitignore
+++ b/.gitignore
@@ -11,9 +11,10 @@ tools/*
 !tools/website
 !tools/Makefile
 !tools/*.c
+!tools/*.patch
 !tools/*.cpp
 !tools/*.cfg
-!tools/SSDT1.dat
+!tools/acpi
 doxygen-doc
 initrd.tar
 .dccache
@@ -28,3 +29,4 @@ initrd.tar
 *.so
 *.o
 *.dmp
+*.pcap
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,5 +1,5 @@
 {
-    "C_Cpp.errorSquiggles": "Enabled",
+    "C_Cpp.errorSquiggles": "enabled",
    "C_Cpp.autocompleteAddParentheses": true,
    "C_Cpp.codeAnalysis.clangTidy.enabled": true,
    "C_Cpp.clang_format_style": "Visual Studio",
--- a/43
+++ b/43
@@ -0,0 +1,43 @@
+FROM ubuntu:22.04 AS base
+
+ENV DEBIAN_FRONTEND=noninteractive
+WORKDIR /fennix
+ADD . /fennix
+
+RUN apt -y update
+RUN apt -y install \
+	build-essential \
+	bison \
+	flex \
+	libgmp3-dev \
+	libmpc-dev \
+	libmpfr-dev \
+	texinfo \
+	libzstd-dev \
+	libisl-dev \
+	autoconf \
+	m4 \
+	automake \
+	gettext \
+	gperf \
+	dejagnu \
+	guile-3.0 \
+	guile-3.0-dev \
+	expect \
+	tcl \
+	autogen \
+	tex-common \
+	sphinx-common \
+	git \
+	ssh \
+	diffutils \
+	patch
+
+RUN apt clean && rm -rf /var/lib/apt/lists
+
+RUN make -C tools __clone_all_no_qemu
+RUN make --quiet -C tools do_binutils
+RUN make --quiet -C tools do_gcc
+RUN cd tools && rm -rf binutils-gdb gcc
+
+RUN make build
--- a/2
+++ b/2
@@ -864,7 +864,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.

-INPUT                  = Kernel Lynx Userspace Drivers tools/doxymds/main.md
+INPUT                  = Kernel Userspace Drivers tools/doxymds/main.md

 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
--- a/Drivers/LICENSE
+++ b/Drivers/LICENSE
@@ -1,6 +1,6 @@
 BSD 3-Clause License

-Copyright (c) 2022, EnderIce2
+Copyright (c) 2024, EnderIce2
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
--- a/Drivers/README.md
+++ b/Drivers/README.md
@@ -1,11 +1 @@
 # Drivers
-
-Drivers for [Fennix](https://github.com/Fennix-Project/Fennix).
-
---
-
-Use `Fennix` repo to build the operating system.
-
-```bash
-git clone --recurse-submodules https://github.com/Fennix-Project/Fennix.git
-```
--- a/Drivers.code-workspace
+++ b/Drivers.code-workspace
@@ -5,108 +5,7 @@
 		}
 	],
 	"settings": {
-		"debug.allowBreakpointsEverywhere": true,
-		"cSpell.words": [
-			"ABAR",
-			"ABSPOINTER",
-			"AHCI",
-			"BIST",
-			"Cardbus",
-			"CFIEN",
-			"cmdret",
-			"cmpb",
-			"driverinfo",
-			"ECTRL",
-			"EEPROM",
-			"Fennix",
-			"GETVERSION",
-			"HBAPRDT",
-			"IFCS",
-			"inportb",
-			"inportl",
-			"inportw",
-			"INTX",
-			"KAPI",
-			"LEDS",
-			"LPBK",
-			"LSTA",
-			"mminb",
-			"mminl",
-			"mminq",
-			"mminw",
-			"mmioin",
-			"mmioout",
-			"mmoutb",
-			"mmoutl",
-			"mmoutw",
-			"NABM",
-			"NABMB",
-			"NABMBOFF",
-			"outportb",
-			"outportl",
-			"outportw",
-			"PCIBAR",
-			"PCMOUT",
-			"PCNET",
-			"PCTRL",
-			"PMCF",
-			"PORTHB",
-			"PRDT",
-			"Prefetchable",
-			"RCTL",
-			"RCTRL",
-			"RDMTS",
-			"RDTR",
-			"rpci",
-			"RSRPD",
-			"RTCL",
-			"RTLC",
-			"RTLIB",
-			"RTLIL",
-			"RTLIW",
-			"RTLOB",
-			"RTLOL",
-			"RTLOW",
-			"RXDCTL",
-			"RXDESCHEAD",
-			"RXDESCHI",
-			"RXDESCLEN",
-			"RXDESCLO",
-			"RXDESCTAIL",
-			"Sata",
-			"SATAPI",
-			"SECRC",
-			"SEMB",
-			"SWXOFF",
-			"tclo",
-			"TCTL",
-			"TCTRL",
-			"TFES",
-			"TIPG",
-			"TSAD",
-			"TSTA",
-			"TXDESCHEAD",
-			"TXDESCHI",
-			"TXDESCLEN",
-			"TXDESCLO",
-			"TXDESCTAIL",
-			"TYPEMATIC",
-			"ubit",
-			"Virtio",
-			"Wmissing"
-		],
-		"files.associations": {
-			"*.su": "tsv",
-			"driver.h": "c",
-			"base.h": "c",
-			"types.h": "c",
-			"syscall.h": "c",
-			"aip.h": "c",
-			"input.h": "c",
-			"errno.h": "c",
-			"io.h": "c",
-			"rtl8139.hpp": "c",
-			"net.h": "c"
-		}
+		"terminal.integrated.cwd": "../",
+		"debug.allowBreakpointsEverywhere": true
 	}
-}
+}
--- a/Kernel.code-workspace
+++ b/Kernel.code-workspace
@@ -5,513 +5,8 @@
 		}
 	],
 	"settings": {
+		"terminal.integrated.cwd": "../",
 		"debug.allowBreakpointsEverywhere": true,
-		"files.associations": {
-			"*.su": "tsv",
-			"thread": "cpp",
-			"bitset": "cpp",
-			"initializer_list": "cpp",
-			"semaphore": "cpp",
-			"memory": "cpp",
-			"limits": "cpp",
-			"climits": "cpp",
-			"iterator": "cpp",
-			"ranges": "cpp",
-			"cassert": "cpp",
-			"concepts": "cpp",
-			"cctype": "cpp",
-			"tuple": "cpp",
-			"streambuf": "cpp",
-			"system_error": "cpp",
-			"coroutine": "cpp",
-			"static_vector": "cpp",
-			"string_view": "cpp",
-			"compare": "cpp",
-			"limine.h": "c",
-			"types.h": "c",
-			"binfo.h": "c",
-			"liballoc_1_1.h": "c",
-			"cstring": "cpp",
-			"cargs.h": "c",
-			"memory.hpp": "c",
-			"convert.h": "c",
-			"limits.h": "c",
-			"assert.h": "c",
-			"cwalk.h": "c",
-			"md5.h": "c",
-			"stdint.h": "c",
-			"debug.h": "c",
-			"ubsan.h": "c",
-			"kernel.h": "c",
-			"filesystem.hpp": "c",
-			"vector.hpp": "c",
-			"string.hpp": "c",
-			"nc.hpp": "c",
-			"vector": "c",
-			"task.hpp": "c",
-			"recovery.hpp": "c",
-			"symbols.hpp": "c",
-			"cstddef": "cpp",
-			"atomic.hpp": "c",
-			"atomic": "cpp",
-			"syscalls.h": "c",
-			"cmath": "cpp",
-			"typeinfo": "c",
-			"exception": "cpp",
-			"errno.h": "c",
-			"float.h": "c",
-			"mutex": "cpp",
-			"type_trails": "cpp",
-			"utility": "cpp",
-			"algorithm": "cpp",
-			"functional": "cpp",
-			"stdio.h": "c",
-			"string": "cpp",
-			"list": "cpp",
-			"stdexcept": "cpp",
-			"unistd.h": "c",
-			"unordered_map": "cpp",
-			"sched.h": "c",
-			"mman.h": "c",
-			"string.h": "c",
-			"macro.hpp": "c",
-			"stddef.h": "c",
-			"cfloat": "c",
-			"type_traits": "cpp",
-			"stdlib.h": "c",
-			"new": "cpp",
-			"ostream": "cpp",
-			"iostream": "cpp",
-			"istream": "cpp",
-			"ios": "cpp",
-			"locale": "cpp",
-			"unwind.h": "c",
-			"memory.h": "c",
-			"physical.hpp": "c",
-			"swap_pt.hpp": "c",
-			"brk.hpp": "c",
-			"bitmap.hpp": "c",
-			"lock.hpp": "c",
-			"virtual.hpp": "c",
-			"table.hpp": "c",
-			"vma.hpp": "c",
-			"abi.h": "c",
-			"kstack.hpp": "c",
-			"stack.hpp": "c",
-			"optional": "cpp"
-		},
-		"cSpell.words": [
-			"AABBCC",
-			"AAFF",
-			"AAFFAA",
-			"ABAR",
-			"ABIVERSION",
-			"ABSPOINTER",
-			"ACPI",
-			"ACPINVS",
-			"addralign",
-			"AEFF",
-			"AFAFAF",
-			"AHBA",
-			"AHCI",
-			"ALTLBA",
-			"APERF",
-			"apic",
-			"APICID",
-			"archaux",
-			"AROS",
-			"ARRAYSZ",
-			"auxv",
-			"BABABA",
-			"BADRAM",
-			"BGRT",
-			"bimi",
-			"binfo",
-			"biosdev",
-			"BIST",
-			"BITALG",
-			"BLOCKDEV",
-			"BLOCKDEVICE",
-			"BNDCFGS",
-			"bochs",
-			"bootanim",
-			"bootdev",
-			"Bootloader",
-			"brontobyte",
-			"CACACA",
-			"calloc",
-			"Cardbus",
-			"CCCCCCCPU",
-			"CHARDEV",
-			"CHARDEVICE",
-			"charsize",
-			"clac",
-			"CLOUDABI",
-			"CMCI",
-			"CMOS",
-			"cntvct",
-			"COMNULL",
-			"copydoc",
-			"cpudata",
-			"CPUID",
-			"crashdata",
-			"CSTAR",
-			"CTLS",
-			"cutlim",
-			"DADADA",
-			"daif",
-			"daifclr",
-			"daifset",
-			"DAPI",
-			"DBGP",
-			"DEBUGCTL",
-			"defragment",
-			"dfdesc",
-			"dialup",
-			"Didx",
-			"DLAB",
-			"Drivermemcpy",
-			"Drivermemset",
-			"Driversprintf",
-			"drvdir",
-			"DRVER",
-			"DSDT",
-			"DUID",
-			"dynstr",
-			"dynsym",
-			"EBDA",
-			"edid",
-			"EEPROM",
-			"EFER",
-			"Ehdr",
-			"ehsize",
-			"EISA",
-			"ELFABI",
-			"ELFCLASS",
-			"ELFDATA",
-			"ELFMAG",
-			"ELFOSABI",
-			"EMMINTRIN",
-			"endregion",
-			"Ensoniq",
-			"EVTSEL",
-			"EXECFN",
-			"exobyte",
-			"EXTD",
-			"FADT",
-			"FAFAFA",
-			"FAFAFAI",
-			"Fargc",
-			"Fargv",
-			"fcreat",
-			"fctprintf",
-			"Femto",
-			"FENIXOS",
-			"FENNIX",
-			"FFAA",
-			"FFAAAA",
-			"FFSMBIOS",
-			"FFXSR",
-			"filestatus",
-			"FMAPS",
-			"fonthdr",
-			"Framebuffer",
-			"FSGSBASE",
-			"fsmi",
-			"fxrstor",
-			"fxsave",
-			"Gamepad",
-			"Gameport",
-			"geopbyte",
-			"GETVERSION",
-			"GFNI",
-			"haddpd",
-			"headersize",
-			"HIPROC",
-			"HPET",
-			"hwaddress",
-			"ICRHI",
-			"ICRLO",
-			"IDIV",
-			"idtd",
-			"IFHLNK",
-			"infloop",
-			"inportb",
-			"inportl",
-			"inportw",
-			"INTFASTX",
-			"INTLEASTX",
-			"INTX",
-			"invlpg",
-			"ioapic",
-			"ioapicirq",
-			"IOCTLFS",
-			"IPCID",
-			"IRET",
-			"iretq",
-			"isdelim",
-			"ishld",
-			"ishst",
-			"itimerspec",
-			"itrfb",
-			"JMPREL",
-			"KAPI",
-			"KAPIPCI",
-			"kcalloc",
-			"kcon",
-			"kdentry",
-			"kdirent",
-			"kernelctl",
-			"kfree",
-			"klog",
-			"kmalloc",
-			"kproc",
-			"krealloc",
-			"kthrd",
-			"lapic",
-			"lfanew",
-			"LFLR",
-			"lgdt",
-			"liballoc",
-			"LIBLIST",
-			"lidt",
-			"limine",
-			"LMSLE",
-			"LOPROC",
-			"lsacpi",
-			"LSTAR",
-			"MADT",
-			"MADTIO",
-			"malloc",
-			"MCFG",
-			"memdbg",
-			"memmap",
-			"memsz",
-			"MEMTEST",
-			"mfence",
-			"MIDR",
-			"mminb",
-			"mminl",
-			"mminq",
-			"mminw",
-			"mmioin",
-			"mmioout",
-			"mmoutb",
-			"mmoutl",
-			"mmoutq",
-			"mmoutw",
-			"modbg",
-			"Modulememcpy",
-			"Modulememset",
-			"Modulesprintf",
-			"movaps",
-			"movddup",
-			"movdqa",
-			"movdqu",
-			"movntdq",
-			"movntdqa",
-			"movw",
-			"MPERF",
-			"MSRID",
-			"MTRR",
-			"MTRRCAP",
-			"multiboot",
-			"MWAIT",
-			"newfstatat",
-			"NIDENT",
-			"NOBITS",
-			"nullfd",
-			"nullptr",
-			"objptr",
-			"OEMID",
-			"Ofast",
-			"okstat",
-			"oldfd",
-			"OPENVOS",
-			"OPTMZ",
-			"OSABI",
-			"OSFXSR",
-			"OSXMMEXCPT",
-			"OSXSAVE",
-			"Outof",
-			"outportb",
-			"outportl",
-			"outportw",
-			"PAGESZ",
-			"palignr",
-			"PCIDE",
-			"pcmpistri",
-			"PCNET",
-			"PDBR",
-			"PDPTE",
-			"PEBS",
-			"PERFEVTSEL",
-			"PEXIT",
-			"PFLA",
-			"Phdrs",
-			"pheader",
-			"PHENT",
-			"phentsize",
-			"phnum",
-			"phoff",
-			"PHYSBASE",
-			"PHYSMASK",
-			"Pico",
-			"PINBASED",
-			"Pipefd",
-			"PKRU",
-			"PLTGOT",
-			"PLTREL",
-			"PLTRELSZ",
-			"POPCNT",
-			"PORTHB",
-			"powerline",
-			"Prefetchable",
-			"PREINIT",
-			"PROCBASED",
-			"PROGBITS",
-			"PTMX",
-			"ptys",
-			"pushfl",
-			"pushfq",
-			"Raphson",
-			"RARP",
-			"RBSTART",
-			"rdmsr",
-			"RDRAND",
-			"rdseed",
-			"rdtsc",
-			"readcr",
-			"readxcr",
-			"realloc",
-			"Realtek",
-			"RELAENT",
-			"RELASZ",
-			"RELSZ",
-			"Rodata",
-			"RPCI",
-			"rpmalloc",
-			"RRGGBB",
-			"RSDP",
-			"RSDT",
-			"RTIT",
-			"SATA",
-			"schedbg",
-			"SERCOS",
-			"serialports",
-			"sfence",
-			"sgdt",
-			"SGXLEPUBKEYHASH",
-			"Shdr",
-			"Sheader",
-			"shentsize",
-			"shnum",
-			"shoff",
-			"showbuf",
-			"shstrndx",
-			"shstrtab",
-			"sidt",
-			"SIGCOMP",
-			"sigsetsize",
-			"SIVR",
-			"SMAP",
-			"SMBASE",
-			"SMBIOSBIOS",
-			"SMEP",
-			"SMRR",
-			"SMXE",
-			"SNTP",
-			"SRAT",
-			"SSDT",
-			"sspt",
-			"SSSE",
-			"stac",
-			"strdbg",
-			"STRSZ",
-			"SVME",
-			"swapgs",
-			"Symbios",
-			"SYMENT",
-			"SYSENTER",
-			"sysret",
-			"sysretq",
-			"Tamsyn",
-			"targp",
-			"TCCR",
-			"TCLO",
-			"TCPA",
-			"TDCR",
-			"TEXIT",
-			"TEXTREL",
-			"Thrd",
-			"TICR",
-			"tlbi",
-			"Touchpad",
-			"tracepagetable",
-			"tskdbg",
-			"ttbr",
-			"uarch",
-			"uartmemdmp",
-			"ubsan",
-			"UINTFASTX",
-			"UINTLEASTX",
-			"UINTX",
-			"ultoa",
-			"UMIP",
-			"UMWAIT",
-			"UNMAP",
-			"Unmaskable",
-			"Unreserving",
-			"unseek",
-			"Unswap",
-			"unsynchronized",
-			"UPDT",
-			"UPID",
-			"uroot",
-			"UTID",
-			"VAES",
-			"VBMI",
-			"vectorize",
-			"vfctprintf",
-			"vfsdbg",
-			"Vidx",
-			"Virtio",
-			"VMCS",
-			"VMFUNC",
-			"vmouse",
-			"VMXE",
-			"VNNI",
-			"VNNIW",
-			"VPCLMULQDQ",
-			"VPID",
-			"VPOKE",
-			"VPOPCNTDQ",
-			"WAET",
-			"weakrefalias",
-			"Wignored",
-			"Wmissing",
-			"writecr",
-			"writexcr",
-			"wrmsr",
-			"WWVB",
-			"WWVH",
-			"Xalloc",
-			"xallocv",
-			"Xclac",
-			"xgetbv",
-			"Xmemcpy",
-			"Xmemset",
-			"XSDT",
-			"Xsize",
-			"XSLC",
-			"XSLF",
-			"XSLM",
-			"XSLR",
-			"Xstac",
-			"Xuintptr",
-			"yottabyte",
-			"zettabyte"
-		],
 		"editor.tabCompletion": "on",
 		"diffEditor.codeLens": true,
 		"editor.quickSuggestionsDelay": 100,
@@ -529,4 +24,4 @@
 		"editor.cursorStyle": "line",
 		"editor.cursorWidth": 2
 	}
-}
+}
--- a/Lynx.code-workspace
+++ b/Lynx.code-workspace
@@ -1,22 +0,0 @@
-{
-	"folders": [
-		{
-			"path": "./Lynx"
-		}
-	],
-	"settings": {
-		"debug.allowBreakpointsEverywhere": true,
-		"files.associations": {
-			"*.su": "tsv",
-			"limine.h": "c"
-		},
-		"cSpell.words": [
-			"Bootloader",
-			"COMNULL",
-			"CPUID",
-			"FENNIX",
-			"JMPREL",
-			"UBSAN"
-		]
-	}
-}
--- a/Userspace.code-workspace
+++ b/Userspace.code-workspace
@@ -5,67 +5,7 @@
 		}
 	],
 	"settings": {
-		"debug.allowBreakpointsEverywhere": true,
-		"files.associations": {
-			"*.su": "tsv",
-			"thread": "cpp",
-			"bitset": "cpp",
-			"initializer_list": "cpp",
-			"fex.hpp": "c",
-			"types.h": "c",
-			"dlfcn.h": "c",
-			"aux.h": "c",
-			"stddef.h": "c",
-			"stdio.h": "c",
-			"syscalls.h": "c",
-			"syslib.h": "c",
-			"sysfile.h": "c",
-			"ipc.h": "c",
-			"sysbase.h": "c",
-			"inttypes.h": "c",
-			"doomkeys.h": "c",
-			"doomgeneric.h": "c",
-			"elf.h": "c",
-			"init.h": "c",
-			"unused_code": "cpp",
-			"liballoc_1_1.h": "c",
-			"errno.h": "c",
-			"stdlib.h": "c",
-			"stdarg.h": "c",
-			"printf.h": "c",
-			"ctype.h": "c",
-			"unistd.h": "c",
-			"stat.h": "c",
-			"wait.h": "c",
-			"base.h": "c",
-			"ld.h": "c",
-			"syscall.h": "c",
-			"stdint.h": "c",
-			"setjmp.h": "c",
-			"limits.h": "c",
-			"fcntl.h": "c",
-			"pty.h": "c",
-			"string.h": "c",
-			"time.h": "c",
-			"reboot.h": "c",
-			"*.in": "c",
-			"signal.h": "c",
-			"alltypes.h": "c",
-			"pr44328.C": "cpp"
-		},
-		"cSpell.words": [
-			"auxv",
-			"cmpq",
-			"FENNIX",
-			"JMPREL",
-			"Krnl",
-			"liballoc",
-			"libinit",
-			"oldpath",
-			"preinit",
-			"Shdr",
-			"vfctprintf",
-			"WAITSTATUS"
-		]
+		"terminal.integrated.cwd": "../",
+		"debug.allowBreakpointsEverywhere": true
 	}
-}
+}
--- a/Fennix.code-workspace
+++ b/Fennix.code-workspace
@@ -5,31 +5,6 @@
 		}
 	],
 	"settings": {
-		"debug.allowBreakpointsEverywhere": true,
-		"files.associations": {
-			"*.su": "tsv",
-			"thread": "cpp",
-			"bitset": "cpp",
-			"initializer_list": "cpp",
-			"semaphore": "cpp",
-			"memory": "cpp",
-			"limits": "cpp",
-			"climits": "cpp",
-			"iterator": "cpp",
-			"ranges": "cpp",
-			"cassert": "cpp",
-			"concepts": "cpp",
-			"cctype": "cpp",
-			"tuple": "cpp",
-			"streambuf": "cpp",
-			"system_error": "cpp",
-			"coroutine": "cpp",
-			"static_vector": "cpp",
-			"string_view": "cpp",
-			"compare": "cpp",
-			"ostream": "cpp",
-			"unordered_map": "cpp",
-			"vector": "cpp"
-		}
+		"debug.allowBreakpointsEverywhere": true
 	}
 }
--- a/Kernel/.gdbinit
+++ b/Kernel/.gdbinit
@@ -0,0 +1,91 @@
+# Usage: add-symbol-file-all <filename> [<offset>]
+#        remove-symbol-file-all <filename> [<offset>]
+#
+# Credit: https://stackoverflow.com/a/33087762/9352057
+#         CC BY-SA 4.0
+
+python
+import subprocess
+import re
+
+def relocatesections(filename, addr):
+    p = subprocess.Popen(["readelf", "-S", filename], stdout = subprocess.PIPE)
+
+    sections = []
+    textaddr = '0'
+    for line in p.stdout.readlines():
+        line = line.decode("utf-8").strip()
+        if not line.startswith('[') or line.startswith('[Nr]'):
+            continue
+
+        line = re.sub(r' +', ' ', line)
+        line = re.sub(r'\[ *(\d+)\]', '\g<1>', line)
+        fieldsvalue = line.split(' ')
+        fieldsname = ['number', 'name', 'type', 'addr', 'offset', 'size', 'entsize', 'flags', 'link', 'info', 'addralign']
+        sec = dict(zip(fieldsname, fieldsvalue))
+
+        if sec['number'] == '0':
+            continue
+
+        sections.append(sec)
+
+        if sec['name'] == '.text':
+            textaddr = sec['addr']
+
+    return (textaddr, sections)
+
+
+class AddSymbolFileAll(gdb.Command):
+    """The right version for add-symbol-file"""
+
+    def __init__(self):
+        super(AddSymbolFileAll, self).__init__("add-symbol-file-all", gdb.COMMAND_USER)
+        self.dont_repeat()
+
+    def invoke(self, arg, from_tty):
+        argv = gdb.string_to_argv(arg)
+        filename = argv[0]
+
+        if len(argv) > 1:
+            offset = int(str(gdb.parse_and_eval(argv[1])), 0)
+        else:
+            offset = 0
+
+        (textaddr, sections) = relocatesections(filename, offset)
+
+        cmd = "add-symbol-file %s 0x%08x" % (filename, int(textaddr, 16) + offset)
+
+        for s in sections:
+            addr = int(s['addr'], 16)
+            if s['name'] == '.text' or addr == 0:
+                continue
+
+            cmd += " -s %s 0x%08x" % (s['name'], addr + offset)
+
+        gdb.execute(cmd)
+
+class RemoveSymbolFileAll(gdb.Command):
+    """The right version for remove-symbol-file"""
+
+    def __init__(self):
+        super(RemoveSymbolFileAll, self).__init__("remove-symbol-file-all", gdb.COMMAND_USER)
+        self.dont_repeat()
+
+    def invoke(self, arg, from_tty):
+        argv = gdb.string_to_argv(arg)
+        filename = argv[0]
+
+        if len(argv) > 1:
+            offset = int(str(gdb.parse_and_eval(argv[1])), 0)
+        else:
+            offset = 0
+
+        (textaddr, _) = relocatesections(filename, offset)
+
+        cmd = "remove-symbol-file -a 0x%08x" % (int(textaddr, 16) + offset)
+        gdb.execute(cmd)
+
+
+AddSymbolFileAll()
+RemoveSymbolFileAll()
+end
--- a/Kernel/.github/workflows/codacy.yml
+++ b/Kernel/.github/workflows/codacy.yml
@@ -1,61 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-# This workflow checks out code, performs a Codacy security scan
-# and integrates the results with the
-# GitHub Advanced Security code scanning feature.  For more information on
-# the Codacy security scan action usage and parameters, see
-# https://github.com/codacy/codacy-analysis-cli-action.
-# For more information on Codacy Analysis CLI in general, see
-# https://github.com/codacy/codacy-analysis-cli.
-
-name: Codacy Security Scan
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ "main" ]
-  schedule:
-    - cron: '27 22 * * 5'
-
-permissions:
-  contents: read
-
-jobs:
-  codacy-security-scan:
-    permissions:
-      contents: read # for actions/checkout to fetch code
-      security-events: write # for github/codeql-action/upload-sarif to upload SARIF results
-      actions: read # only required for a private repository by github/codeql-action/upload-sarif to get the Action run status
-    name: Codacy Security Scan
-    runs-on: ubuntu-latest
-    steps:
-      # Checkout the repository to the GitHub Actions runner
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      # Execute Codacy Analysis CLI and generate a SARIF output with the security issues identified during the analysis
-      - name: Run Codacy Analysis CLI
-        uses: codacy/codacy-analysis-cli-action@d840f886c4bd4edc059706d09c6a1586111c540b
-        with:
-          # Check https://github.com/codacy/codacy-analysis-cli#project-token to get your project token from your Codacy repository
-          # You can also omit the token and run the tools that support default configurations
-          project-token: ${{ secrets.CODACY_PROJECT_TOKEN }}
-          verbose: true
-          output: results.sarif
-          format: sarif
-          # Adjust severity of non-security issues
-          gh-code-scanning-compat: true
-          # Force 0 exit code to allow SARIF file generation
-          # This will handover control about PR rejection to the GitHub side
-          max-allowed-issues: 2147483647
-
-      # Upload the SARIF file generated in the previous step
-      - name: Upload SARIF results file
-        uses: github/codeql-action/upload-sarif@v2
-        with:
-          sarif_file: results.sarif
--- a/Kernel/.github/workflows/flawfinder.yml
+++ b/Kernel/.github/workflows/flawfinder.yml
@@ -7,12 +7,10 @@ name: flawfinder

 on:
  push:
-    branches: [ "main" ]
+    branches: [ "master" ]
  pull_request:
    # The branches below must be a subset of the branches above
-    branches: [ "main" ]
-  schedule:
-    - cron: '21 1 * * 1'
+    branches: [ "master" ]

 jobs:
  flawfinder:
--- a/Kernel/.gitignore
+++ b/Kernel/.gitignore
@@ -2,6 +2,5 @@
 *.su
 *.gcno
 *.map
-*.fsys
+fennix.elf
 *.log
-.dccache
--- a/Kernel/.vscode/c_boilerplates.code-snippets
+++ b/Kernel/.vscode/c_boilerplates.code-snippets
@@ -1,17 +1,65 @@
 {
-	"Fennix Kernel Header": {
+	"Fennix Kernel C++ Header": {
 		"prefix": [
 			"head",
 		],
 		"body": [
-			"#ifndef __FENNIX_KERNEL_${2:header}_H__",
-			"#define __FENNIX_KERNEL_${2:header}_H__",
+			"/*",
+			"\tThis file is part of Fennix Kernel.",
+			"",
+			"\tFennix Kernel is free software: you can redistribute it and/or",
+			"\tmodify it under the terms of the GNU General Public License as",
+			"\tpublished by the Free Software Foundation, either version 3 of",
+			"\tthe License, or (at your option) any later version.",
+			"",
+			"\tFennix Kernel is distributed in the hope that it will be useful,",
+			"\tbut WITHOUT ANY WARRANTY; without even the implied warranty of",
+			"\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
+			"\tGNU General Public License for more details.",
+			"",
+			"\tYou should have received a copy of the GNU General Public License",
+			"\talong with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.",
+			"*/",
+			"",
+			"#pragma once",
+			"",
+			"$0",
+			"",
+			"$1",
+			""
+		],
+		"description": "Create kernel header."
+	},
+	"Fennix Kernel C Header": {
+		"prefix": [
+			"headc",
+		],
+		"body": [
+			"/*",
+			"\tThis file is part of Fennix Kernel.",
+			"",
+			"\tFennix Kernel is free software: you can redistribute it and/or",
+			"\tmodify it under the terms of the GNU General Public License as",
+			"\tpublished by the Free Software Foundation, either version 3 of",
+			"\tthe License, or (at your option) any later version.",
+			"",
+			"\tFennix Kernel is distributed in the hope that it will be useful,",
+			"\tbut WITHOUT ANY WARRANTY; without even the implied warranty of",
+			"\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
+			"\tGNU General Public License for more details.",
+			"",
+			"\tYou should have received a copy of the GNU General Public License",
+			"\talong with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.",
+			"*/",
+			"",
+			"#ifndef __FENNIX_KERNEL_${1:header}_H__",
+			"#define __FENNIX_KERNEL_${1:header}_H__",
 			"",
 			"#include <types.h>",
 			"",
 			"$0",
 			"",
-			"#endif // !__FENNIX_KERNEL_${2:header}_H__",
+			"#endif // !__FENNIX_KERNEL_${1:header}_H__",
 			""
 		],
 		"description": "Create kernel header."
@@ -24,5 +72,29 @@
 			"/** @brief $0 */"
 		],
 		"description": "Create kernel documentation brief."
+	},
+	"License": {
+		"prefix": [
+			"license",
+		],
+		"body": [
+			"/*",
+			"\tThis file is part of Fennix Kernel.",
+			"",
+			"\tFennix Kernel is free software: you can redistribute it and/or",
+			"\tmodify it under the terms of the GNU General Public License as",
+			"\tpublished by the Free Software Foundation, either version 3 of",
+			"\tthe License, or (at your option) any later version.",
+			"",
+			"\tFennix Kernel is distributed in the hope that it will be useful,",
+			"\tbut WITHOUT ANY WARRANTY; without even the implied warranty of",
+			"\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
+			"\tGNU General Public License for more details.",
+			"",
+			"\tYou should have received a copy of the GNU General Public License",
+			"\talong with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.",
+			"*/"
+		],
+		"description": "Create kernel license."
 	}
 }
--- a/Kernel/.vscode/c_cpp_properties.json
+++ b/Kernel/.vscode/c_cpp_properties.json
@@ -1,123 +1,206 @@
 {
-    "configurations": [
-        {
-            "name": "Fennix x64 (Linux, GCC, debug)",
-            "includePath": [
-                "${workspaceFolder}/include",
-                "${workspaceFolder}/include/**"
-            ],
-            "defines": [
-                "__debug_vscode__",
-                "KERNEL_NAME=\"Fennix\"",
-                "KERNEL_VERSION=\"1.0\"",
-                "GIT_COMMIT=\"0000000000000000000000000000000000000000\"",
-                "GIT_COMMIT_SHORT=\"0000000\"",
-                "a64",
-                "DEBUG=\"1\""
-            ],
-            "compilerPath": "${workspaceFolder}/../tools/cross/bin/amd64-elf-gcc",
-            "cStandard": "c17",
-            "cppStandard": "c++20",
-            "intelliSenseMode": "gcc-x64",
-            "configurationProvider": "ms-vscode.makefile-tools",
-            "compilerArgs": [
-                // Compiler flags
-                "-fno-pic",
-                "-fno-pie",
-                "-mno-red-zone",
-                "-march=core2",
-                "-pipe",
-                "-mcmodel=kernel",
-                "-fno-builtin",
-
-                // C++ flags
-                "-fno-rtti",
-                "-fexceptions",
-
-                // Linker flags
-                "-T${workspaceFolder}/Architecture/amd64/linker.ld",
-                "-Wl,-static,--no-dynamic-linker,-ztext",
-                "-nostdlib",
-                "-nodefaultlibs",
-                "-nolibc",
-                "-zmax-page-size=0x1000",
-                "-shared",
-
-                // Debug flags
-                "-ggdb3",
-                "-O0",
-                "-fdiagnostics-color=always",
-                "-fverbose-asm",
-                "-fstack-usage",
-                "-fstack-check",
-                "-fsanitize=undefined",
-
-                // VSCode flags
-                "-ffreestanding",
-                "-nostdinc",
-                "-nostdinc++"
-            ]
-        },
-        {
-            "name": "Fennix x32 (Linux, GCC, debug)",
-            "includePath": [
-                "${workspaceFolder}/include/**"
-            ],
-            "defines": [
-                "__debug_vscode__",
-                "KERNEL_NAME=\"Fennix\"",
-                "KERNEL_VERSION=\"1.0\"",
-                "GIT_COMMIT=\"0000000000000000000000000000000000000000\"",
-                "GIT_COMMIT_SHORT=\"0000000\"",
-                "a32",
-                "DEBUG=\"1\""
-            ],
-            "compilerPath": "${workspaceFolder}/../tools/cross/bin/i686-elf-gcc",
-            "cStandard": "c17",
-            "cppStandard": "c++20",
-            "intelliSenseMode": "gcc-x86",
-            "configurationProvider": "ms-vscode.makefile-tools",
-            "compilerArgs": [
-                // Compiler flags
-                "-fno-pic",
-                "-fno-pie",
-                "-mno-80387",
-                "-mno-mmx",
-                "-mno-3dnow",
-                "-mno-red-zone",
-                "-march=pentium",
-                "-pipe",
-                "-msoft-float",
-                "-fno-builtin",
-
-                // C++ flags
-                "-fno-rtti",
-                "-fexceptions",
-
-                // Linker flags
-                "-T${workspaceFolder}/Architecture/i686/linker.ld",
-                "-Wl,-static,--no-dynamic-linker,-ztext",
-                "-nostdlib",
-                "-nodefaultlibs",
-                "-nolibc",
-                "-zmax-page-size=0x1000",
-                "-shared",
-
-                // Debug flags
-                "-ggdb3",
-                "-O0",
-                "-fdiagnostics-color=always",
-                "-fverbose-asm",
-                "-fstack-usage",
-                "-fstack-check",
-                "-fsanitize=undefined",
-
-                // VSCode flags
-                "-ffreestanding",
-                "-nostdinc",
-                "-nostdinc++"
-            ]
-        }
-    ],
-    "version": 4
+	"configurations": [
+		{
+			"name": "Fennix x64 (Linux, GCC, debug)",
+			"includePath": [
+				"${workspaceFolder}/include",
+				"${workspaceFolder}/include/**",
+				"${workspaceFolder}/include_std",
+				"${workspaceFolder}/include_std/**",
+				"${workspaceFolder}/arch/amd64/include"
+			],
+			"defines": [
+				"a64",
+				"a86",
+				"DEBUG=\"1\""
+			],
+			"forcedInclude": [
+				"${workspaceFolder}/.vscode/preinclude.h"
+			],
+			"compilerPath": "${workspaceFolder}/../tools/cross/bin/x86_64-fennix-gcc",
+			"cStandard": "c17",
+			"cppStandard": "c++20",
+			"intelliSenseMode": "gcc-x64",
+			"configurationProvider": "ms-vscode.makefile-tools",
+			"compilerArgs": [
+				// Compiler flags
+				"-fno-pic",
+				"-fno-pie",
+				"-mno-red-zone",
+				"-march=core2",
+				"-pipe",
+				"-mcmodel=kernel",
+				"-fno-builtin",
+				"-m64",
+				"-fcoroutines",
+				// Warnings
+				"-Wall",
+				"-Wextra",
+				"-Wfloat-equal",
+				"-Wpointer-arith",
+				"-Wcast-align",
+				"-Wredundant-decls",
+				"-Winit-self",
+				"-Wswitch-default",
+				"-Wstrict-overflow=5",
+				"-Wconversion",
+				// C++ flags
+				"-fno-rtti",
+				"-fno-exceptions",
+				// Linker flags
+				"-T${workspaceFolder}/arch/amd64/linker.ld",
+				"-Wl,-static,--no-dynamic-linker,-ztext",
+				"-nostdlib",
+				"-nodefaultlibs",
+				"-nolibc",
+				"-zmax-page-size=0x1000",
+				"-shared",
+				// Debug flags
+				"-ggdb3",
+				"-O0",
+				"-fdiagnostics-color=always",
+				"-fverbose-asm",
+				"-fstack-usage",
+				"-fstack-check",
+				"-fsanitize=undefined",
+				// VSCode flags
+				"-ffreestanding",
+				"-nostdinc",
+				"-nostdinc++"
+			]
+		},
+		{
+			"name": "Fennix x32 (Linux, GCC, debug)",
+			"includePath": [
+				"${workspaceFolder}/include",
+				"${workspaceFolder}/include/**",
+				"${workspaceFolder}/include_std",
+				"${workspaceFolder}/include_std/**",
+				"${workspaceFolder}/arch/i386/include"
+			],
+			"forcedInclude": [
+				"${workspaceFolder}/.vscode/preinclude.h"
+			],
+			"defines": [
+				"a32",
+				"a86",
+				"DEBUG=\"1\""
+			],
+			"compilerPath": "${workspaceFolder}/../tools/cross/bin/i386-fennix-gcc",
+			"cStandard": "c17",
+			"cppStandard": "c++20",
+			"intelliSenseMode": "gcc-x86",
+			"configurationProvider": "ms-vscode.makefile-tools",
+			"compilerArgs": [
+				// Compiler flags
+				"-fno-pic",
+				"-fno-pie",
+				"-mno-80387",
+				"-mno-mmx",
+				"-mno-3dnow",
+				"-mno-red-zone",
+				"-march=pentium",
+				"-pipe",
+				"-msoft-float",
+				"-fno-builtin",
+				"-m32",
+				"-fcoroutines",
+				// Warnings
+				"-Wall",
+				"-Wextra",
+				"-Wfloat-equal",
+				"-Wpointer-arith",
+				"-Wcast-align",
+				"-Wredundant-decls",
+				"-Winit-self",
+				"-Wswitch-default",
+				"-Wstrict-overflow=5",
+				"-Wconversion",
+				// C++ flags
+				"-fno-rtti",
+				"-fno-exceptions",
+				// Linker flags
+				"-T${workspaceFolder}/arch/i386/linker.ld",
+				"-Wl,-static,--no-dynamic-linker,-ztext",
+				"-nostdlib",
+				"-nodefaultlibs",
+				"-nolibc",
+				"-zmax-page-size=0x1000",
+				"-shared",
+				// Debug flags
+				"-ggdb3",
+				"-O0",
+				"-fdiagnostics-color=always",
+				"-fverbose-asm",
+				"-fstack-usage",
+				"-fstack-check",
+				"-fsanitize=undefined",
+				// VSCode flags
+				"-ffreestanding",
+				"-nostdinc",
+				"-nostdinc++"
+			]
+		},
+		{
+			"name": "Fennix Aarch64 (Linux, GCC, debug)",
+			"includePath": [
+				"${workspaceFolder}/include",
+				"${workspaceFolder}/include/**",
+				"${workspaceFolder}/include_std",
+				"${workspaceFolder}/include_std/**",
+				"${workspaceFolder}/arch/aarch64/include"
+			],
+			"forcedInclude": [
+				"${workspaceFolder}/.vscode/preinclude.h"
+			],
+			"defines": [
+				"aa64",
+				"DEBUG=\"1\""
+			],
+			"compilerPath": "${workspaceFolder}/../tools/cross/bin/aarch64-fennix-gcc",
+			"cStandard": "c17",
+			"cppStandard": "c++20",
+			"intelliSenseMode": "linux-gcc-arm64",
+			"configurationProvider": "ms-vscode.makefile-tools",
+			"compilerArgs": [
+				// Compiler flags
+				"-pipe",
+				"-fno-builtin",
+				"-msoft-float",
+				"-fPIC",
+				"-Wstack-protector",
+				"-fcoroutines",
+				// Warnings
+				"-Wall",
+				"-Wextra",
+				"-Wfloat-equal",
+				"-Wpointer-arith",
+				"-Wcast-align",
+				"-Wredundant-decls",
+				"-Winit-self",
+				"-Wswitch-default",
+				"-Wstrict-overflow=5",
+				"-Wconversion",
+				// C++ flags
+				"-fno-rtti",
+				"-fno-exceptions",
+				// Linker flags
+				"-T${workspaceFolder}/arch/aarch64/linker.ld",
+				"-fPIC",
+				// Debug flags
+				"-ggdb3",
+				"-O0",
+				"-fdiagnostics-color=always",
+				"-fverbose-asm",
+				"-fstack-usage",
+				"-fstack-check",
+				"-fsanitize=undefined",
+				// VSCode flags
+				"-ffreestanding",
+				"-nostdinc",
+				"-nostdinc++"
+			]
+		}
+	],
+	"version": 4
 }
--- a/Kernel/.vscode/extensions.json
+++ b/Kernel/.vscode/extensions.json
@@ -1,13 +1,14 @@
 {
-    "recommendations": [
-        "ms-vscode.cpptools",
-        "wayou.vscode-todo-highlight",
-        "gruntfuggly.todo-tree",
-        "13xforever.language-x86-64-assembly",
-        "webfreak.debug",
-        "zixuanwang.linkerscript",
-        "maziac.hex-hover-converter",
-        "cschlosser.doxdocgen",
-        "streetsidesoftware.code-spell-checker"
-    ]
+	"recommendations": [
+		"jeff-hykin.better-cpp-syntax",
+		"aaron-bond.better-comments",
+		"ms-vscode.cpptools",
+		"maziac.hex-hover-converter",
+		"zixuanwang.linkerscript",
+		"webfreak.debug",
+		"ibm.output-colorizer",
+		"wayou.vscode-todo-highlight",
+		"gruntfuggly.todo-tree",
+		"maziac.asm-code-lens"
+	]
 }
--- a/Kernel/.vscode/launch.json
+++ b/Kernel/.vscode/launch.json
@@ -1,40 +1,175 @@
 {
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Attach to a running QEMU instance",
-            "type": "cppdbg",
-            "request": "launch",
-            "program": "${workspaceRoot}/kernel.fsys",
-            "cwd": "${workspaceRoot}",
-            "args": [],
-            "targetArchitecture": "x64",
-            "MIMode": "gdb",
-            "miDebuggerPath": "/usr/bin/gdb",
-            "miDebuggerArgs": "",
-            "externalConsole": false,
-            "additionalSOLibSearchPath": "${workspaceRoot}",
-            "customLaunchSetupCommands": [
-                {
-                    "text": "target remote localhost:1234",
-                    "description": "Connect to QEMU remote debugger"
-                }
-            ],
-            "setupCommands": [
-                {
-                    "description": "Enable pretty-printing for gdb",
-                    "text": "-enable-pretty-printing",
-                    "ignoreFailures": true
-                },
-                {
-                    "text": "set breakpoint pending on",
-                    "description": "Make breakpoint pending on future shared library load."
-                },
-                {
-                    "text": "file ${workspaceRoot}/kernel.fsys",
-                    "description": "Load binary."
-                },
-            ]
-        }
-    ]
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Launch QEMU and debug the kernel",
+			"type": "cppdbg",
+			"request": "launch",
+			"program": "${workspaceFolder}/fennix.elf",
+			"cwd": "${workspaceFolder}",
+			"args": [],
+			"targetArchitecture": "x64",
+			"MIMode": "gdb",
+			"miDebuggerPath": "${workspaceFolder}/../tools/cross/bin/x86_64-fennix-gdb",
+			"miDebuggerArgs": "",
+			"externalConsole": false,
+			"additionalSOLibSearchPath": "${workspaceFolder}",
+			"customLaunchSetupCommands": [
+				{
+					"text": "target remote localhost:1234",
+					"description": "Connect to QEMU remote debugger"
+				}
+			],
+			"setupCommands": [
+				{
+					"description": "Enable pretty-printing for gdb",
+					"text": "-enable-pretty-printing",
+					"ignoreFailures": true
+				},
+				{
+					"text": "set breakpoint pending on",
+					"description": "Make breakpoint pending on future shared library load."
+				},
+				{
+					"text": "file ${workspaceFolder}/fennix.elf",
+					"description": "Load binary."
+				},
+				{
+					"text": "source ${workspaceFolder}/.gdbinit"
+				}
+			],
+			"preLaunchTask": "launch-qemu"
+		},
+		{
+			"name": "Attach to a running VM instance",
+			"type": "cppdbg",
+			"request": "launch",
+			"program": "${workspaceFolder}/fennix.elf",
+			"cwd": "${workspaceFolder}",
+			"args": [],
+			"targetArchitecture": "x64",
+			"MIMode": "gdb",
+			"miDebuggerPath": "${workspaceFolder}/../tools/cross/bin/x86_64-fennix-gdb",
+			"miDebuggerArgs": "",
+			"externalConsole": false,
+			"additionalSOLibSearchPath": "${workspaceFolder}",
+			"customLaunchSetupCommands": [
+				{
+					"text": "target remote localhost:1234",
+					"description": "Connect to QEMU remote debugger"
+				}
+			],
+			"setupCommands": [
+				{
+					"description": "Enable pretty-printing for gdb",
+					"text": "-enable-pretty-printing",
+					"ignoreFailures": true
+				},
+				{
+					"text": "set breakpoint pending on",
+					"description": "Make breakpoint pending on future shared library load."
+				},
+				{
+					"text": "file ${workspaceFolder}/fennix.elf",
+					"description": "Load binary."
+				},
+				{
+					"text": "source ${workspaceFolder}/.gdbinit"
+				}
+			],
+		},
+		{
+			"name": "Attach to VM w/utest",
+			"type": "cppdbg",
+			"request": "launch",
+			"program": "${workspaceFolder}/fennix.elf",
+			"cwd": "${workspaceFolder}",
+			"args": [],
+			"targetArchitecture": "x64",
+			"MIMode": "gdb",
+			"miDebuggerPath": "${workspaceFolder}/../tools/cross/bin/x86_64-fennix-gdb",
+			"miDebuggerArgs": "",
+			"externalConsole": false,
+			"additionalSOLibSearchPath": "${workspaceFolder}",
+			"customLaunchSetupCommands": [
+				{
+					"text": "target remote localhost:1234",
+					"description": "Connect to QEMU remote debugger"
+				}
+			],
+			"setupCommands": [
+				{
+					"description": "Enable pretty-printing for gdb",
+					"text": "-enable-pretty-printing",
+					"ignoreFailures": true
+				},
+				{
+					"text": "set breakpoint pending on",
+					"description": "Make breakpoint pending on future shared library load."
+				},
+				{
+					"text": "file ${workspaceFolder}/fennix.elf",
+					"description": "Load binary."
+				},
+				{
+					"text": "add-symbol-file ${workspaceFolder}/../initrd_tmp_data/bin/utest",
+					"description": "Load /bin/utest.",
+					"ignoreFailures": true
+				},
+				{
+					"text": "source ${workspaceFolder}/.gdbinit"
+				}
+			],
+			"preLaunchTask": "launch-qemu",
+		},
+		{
+			"name": "Attach to VM w/utest_linux",
+			"type": "cppdbg",
+			"request": "launch",
+			"program": "${workspaceFolder}/fennix.elf",
+			"cwd": "${workspaceFolder}",
+			"args": [],
+			"targetArchitecture": "x64",
+			"MIMode": "gdb",
+			"miDebuggerPath": "${workspaceFolder}/../tools/cross/bin/x86_64-fennix-gdb",
+			"miDebuggerArgs": "",
+			"externalConsole": false,
+			"additionalSOLibSearchPath": "${workspaceFolder}",
+			"customLaunchSetupCommands": [
+				{
+					"text": "target remote localhost:1234",
+					"description": "Connect to QEMU remote debugger"
+				}
+			],
+			"setupCommands": [
+				{
+					"description": "Enable pretty-printing for gdb",
+					"text": "-enable-pretty-printing",
+					"ignoreFailures": true
+				},
+				{
+					"text": "set breakpoint pending on",
+					"description": "Make breakpoint pending on future shared library load."
+				},
+				{
+					"text": "file ${workspaceFolder}/fennix.elf",
+					"description": "Load binary."
+				},
+				{
+					"text": "set debug-file-directory /usr/lib/debug",
+					"description": "Set debug-file-directory to /usr/lib/debug.",
+					"ignoreFailures": true
+				},
+				{
+					"text": "add-symbol-file ${workspaceFolder}/../initrd_tmp_data/bin/utest_linux",
+					"description": "Load /bin/utest_linux.",
+					"ignoreFailures": true
+				},
+				{
+					"text": "source ${workspaceFolder}/.gdbinit"
+				}
+			],
+			"preLaunchTask": "launch-qemu",
+		},
+	]
 }
--- a/Kernel/.vscode/preinclude.h
+++ b/Kernel/.vscode/preinclude.h
@@ -0,0 +1,14 @@
+#undef __linux__
+#undef __WIN32__
+#undef __WIN64__
+#undef _WIN32
+#undef _WIN64
+#undef __APPLE__
+#undef __clang__
+#define __vscode__ 1
+#define __kernel__ 1
+#define KERNEL_NAME "Fennix"
+#define KERNEL_ARCH "amd64"
+#define KERNEL_VERSION "1.0"
+#define GIT_COMMIT "0000000000000000000000000000000000000000"
+#define GIT_COMMIT_SHORT "0000000"
--- a/Kernel/.vscode/settings.json
+++ b/Kernel/.vscode/settings.json
@@ -1,5 +1,5 @@
 {
-    "C_Cpp.errorSquiggles": "Enabled",
+    "C_Cpp.errorSquiggles": "enabled",
    "C_Cpp.autocompleteAddParentheses": true,
    "C_Cpp.codeAnalysis.clangTidy.enabled": true,
    "C_Cpp.clang_format_style": "Visual Studio",
@@ -14,6 +14,10 @@
        "clang-diagnostic-unknown-warning-option",
        "clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling",
        "clang-diagnostic-implicit-exception-spec-mismatch",
-        "clang-diagnostic-unknown-attributes"
+        "clang-diagnostic-unknown-attributes",
+        "clang-diagnostic-user-defined-literals",
+        "clang-diagnostic-non-pod-varargs",
+        "clang-diagnostic-non-pod-varargs",
+        "clang-diagnostic-non-pod-varargs"
    ]
 }
--- a/Kernel/.vscode/tasks.json
+++ b/Kernel/.vscode/tasks.json
@@ -0,0 +1,26 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "launch-qemu",
+			"type": "shell",
+			"command": "make -j$(shell nproc) build && make -C ../ build_image && make -C ../ vscode_debug_only",
+			"isBackground": true,
+			"problemMatcher": [],
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"presentation": {
+				"reveal": "always",
+				"panel": "shared"
+			},
+			"options": {
+				"shell": {
+					"executable": "bash",
+					"args": ["-c"]
+				}
+			}
+		}
+	]
+}
--- a/Kernel/Architecture/aarch64/Entry.cpp
+++ b/Kernel/Architecture/aarch64/Entry.cpp
@@ -1,10 +0,0 @@
-#include <types.h>
-
-#include <debug.h>
-#include <cpu.hpp>
-
-EXTERNC void arm64Entry(uint64_t dtb_ptr32, uint64_t x1, uint64_t x2, uint64_t x3)
-{
-    trace("Hello, World!");
-    CPU::Halt(true);
-}
--- a/Kernel/Architecture/aarch64/SystemCalls.cpp
+++ b/Kernel/Architecture/aarch64/SystemCalls.cpp
@@ -1,14 +0,0 @@
-#include <syscalls.hpp>
-
-#include <cpu.hpp>
-
-extern "C" __attribute__((naked, used, no_stack_protector)) void SystemCallHandlerStub()
-{
-
-}
-
-extern "C" uint64_t SystemCallsHandler(SyscallsFrame *regs);
-
-void InitializeSystemCalls()
-{
-}
--- a/Kernel/Architecture/aarch64/cpu/SymmetricMultiprocessing.cpp
+++ b/Kernel/Architecture/aarch64/cpu/SymmetricMultiprocessing.cpp
@@ -1,40 +0,0 @@
-#include <smp.hpp>
-
-#include <ints.hpp>
-#include <memory.hpp>
-#include <cpu.hpp>
-
-#include "../../../kernel.h"
-
-volatile bool CPUEnabled = false;
-
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-static __attribute__((aligned(PAGE_SIZE))) CPUData CPUs[MAX_CPU] = {0};
-
-CPUData *GetCPU(uint64_t id) { return &CPUs[id]; }
-
-CPUData *GetCurrentCPU()
-{
-    uint64_t ret = 0;
-
-    if (!CPUs[ret].IsActive)
-    {
-        error("CPU %d is not active!", ret);
-        return &CPUs[0];
-    }
-
-    if (CPUs[ret].Checksum != CPU_DATA_CHECKSUM)
-    {
-        error("CPU %d data is corrupted!", ret);
-        return &CPUs[0];
-    }
-    return &CPUs[ret];
-}
-
-namespace SMP
-{
-    void Initialize(void *madt)
-    {
-        fixme("SMP::Initialize() is not implemented!");
-    }
-}
--- a/Kernel/Architecture/aarch64/linker.ld
+++ b/Kernel/Architecture/aarch64/linker.ld
@@ -1,42 +0,0 @@
-ENTRY(_start)
-
-SECTIONS
-{
-    . = 0x80000;
-    _kernel_start = .;
-    .text :
-    {
-        KEEP(*(.text.boot))
-        *(.text .text.*)
-    }
-    . = ALIGN(4096);
-    _kernel_text_end = .;
-
-    .data :
-    {
-        *(.data .data.*)
-    }
-    . = ALIGN(4096);
-    _kernel_data_end = .;
-
-    .rodata :
-    {
-        *(.rodata .rodata.*)
-    }
-    . = ALIGN(4096);
-    _kernel_rodata_end = .;
-
-    .bss :
-    {
-        *(.bss .bss.*)
-    }
-    . = ALIGN(4096);
-    _kernel_end = .;
-    _bss_size = _kernel_end - _kernel_rodata_end;
-
-    /DISCARD/ :
-    {
-        *(.comment*)
-        *(.note*)
-    }
-}
--- a/Kernel/Architecture/aarch64/runtime/crt0.S
+++ b/Kernel/Architecture/aarch64/runtime/crt0.S
@@ -1,17 +0,0 @@
-// .section ".text.boot"
-// 
-// .global _start
-//     .org 0x80000
-// _start:
-//     ldr     x5, =_start
-//     mov     sp, x5
-//     ldr     x5, =_kernel_rodata_end
-//     ldr     w6, =_bss_size
-// 1:  cbz     w6, 2f
-//     str     xzr, [x5], #8
-//     sub     w6, w6, #1
-//     cbnz    w6, 1b
-// 2:  bl      arm64Entry
-// Halt:
-//     wfe
-//     b Halt
--- a/Kernel/Architecture/aarch64/runtime/crt1.S
+++ b/Kernel/Architecture/aarch64/runtime/crt1.S
@@ -1,17 +0,0 @@
-.section ".text.boot"
-
-.global _start
-    .org 0x80000
-_start:
-    ldr     x5, =_start
-    mov     sp, x5
-    ldr     x5, =_kernel_rodata_end
-    ldr     w6, =_bss_size
-1:  cbz     w6, 2f
-    str     xzr, [x5], #8
-    sub     w6, w6, #1
-    cbnz    w6, 1b
-2:  bl      arm64Entry
-Halt:
-    wfe
-    b Halt
--- a/Kernel/Architecture/aarch64/runtime/crtbegin.c
+++ b/Kernel/Architecture/aarch64/runtime/crtbegin.c
@@ -1 +0,0 @@
-// C++ constructor/destructor stuff
--- a/Kernel/Architecture/aarch64/runtime/crtend.c
+++ b/Kernel/Architecture/aarch64/runtime/crtend.c
@@ -1 +0,0 @@
-// C++ constructor/destructor stuff
--- a/Kernel/Architecture/aarch64/runtime/crti.S
+++ b/Kernel/Architecture/aarch64/runtime/crti.S
@@ -1,13 +0,0 @@
-.section .init
-.global _init
-.type _init, @function
-_init:
-//	push %rbp
-//	movq %rsp, %rbp
-
-.section .fini
-.global _fini
-.type _fini, @function
-_fini:
-//	push %rbp
-//	movq %rsp, %rbp
--- a/Kernel/Architecture/aarch64/runtime/crtn.S
+++ b/Kernel/Architecture/aarch64/runtime/crtn.S
@@ -1,7 +0,0 @@
-.section .init
-//	popq %rbp
-	ret
-
-.section .fini
-//	popq %rbp
-	ret
--- a/Kernel/Architecture/amd64/AdvancedConfigurationAndPowerInterface.cpp
+++ b/Kernel/Architecture/amd64/AdvancedConfigurationAndPowerInterface.cpp
@@ -1,130 +0,0 @@
-#include "acpi.hpp"
-
-#include <debug.h>
-#include <io.h>
-
-#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
-
-namespace ACPI
-{
-    void *ACPI::FindTable(ACPI::ACPIHeader *ACPIHeader, char *Signature)
-    {
-        for (uint64_t t = 0; t < ((ACPIHeader->Length - sizeof(ACPI::ACPIHeader)) / (XSDTSupported ? 8 : 4)); t++)
-        {
-            // Should I be concerned about unaligned memory access?
-            ACPI::ACPIHeader *SDTHdr = nullptr;
-            if (XSDTSupported)
-                SDTHdr = (ACPI::ACPIHeader *)(*(uint64_t *)((uint64_t)ACPIHeader + sizeof(ACPI::ACPIHeader) + (t * 8)));
-            else
-                SDTHdr = (ACPI::ACPIHeader *)(*(uint32_t *)((uint64_t)ACPIHeader + sizeof(ACPI::ACPIHeader) + (t * 4)));
-
-            for (uint64_t i = 0; i < 4; i++)
-            {
-                if (SDTHdr->Signature[i] != Signature[i])
-                    break;
-                if (i == 3)
-                {
-                    trace("%s found!", Signature);
-                    return SDTHdr;
-                }
-            }
-        }
-        // warn("%s not found!", Signature);
-        return nullptr;
-    }
-
-    void ACPI::SearchTables(ACPIHeader *Header)
-    {
-        if (!Header)
-            return;
-
-        HPET = (HPETHeader *)FindTable(XSDT, (char *)"HPET");
-        FADT = (FADTHeader *)FindTable(XSDT, (char *)"FACP");
-        MCFG = (MCFGHeader *)FindTable(XSDT, (char *)"MCFG");
-        BGRT = (BGRTHeader *)FindTable(XSDT, (char *)"BGRT");
-        SRAT = (SRATHeader *)FindTable(XSDT, (char *)"SRAT");
-        TPM2 = (TPM2Header *)FindTable(XSDT, (char *)"TPM2");
-        TCPA = (TCPAHeader *)FindTable(XSDT, (char *)"TCPA");
-        WAET = (WAETHeader *)FindTable(XSDT, (char *)"WAET");
-        MADT = (MADTHeader *)FindTable(XSDT, (char *)"APIC");
-        HEST = (HESTHeader *)FindTable(XSDT, (char *)"HEST");
-        FindTable(XSDT, (char *)"BERT");
-        FindTable(XSDT, (char *)"CPEP");
-        FindTable(XSDT, (char *)"DSDT");
-        FindTable(XSDT, (char *)"ECDT");
-        FindTable(XSDT, (char *)"EINJ");
-        FindTable(XSDT, (char *)"ERST");
-        FindTable(XSDT, (char *)"FACS");
-        FindTable(XSDT, (char *)"MSCT");
-        FindTable(XSDT, (char *)"MPST");
-        FindTable(XSDT, (char *)"OEMx");
-        FindTable(XSDT, (char *)"PMTT");
-        FindTable(XSDT, (char *)"PSDT");
-        FindTable(XSDT, (char *)"RASF");
-        FindTable(XSDT, (char *)"RSDT");
-        FindTable(XSDT, (char *)"SBST");
-        FindTable(XSDT, (char *)"SLIT");
-        FindTable(XSDT, (char *)"SSDT");
-        FindTable(XSDT, (char *)"XSDT");
-        FindTable(XSDT, (char *)"DRTM");
-        FindTable(XSDT, (char *)"FPDT");
-        FindTable(XSDT, (char *)"GTDT");
-        FindTable(XSDT, (char *)"PCCT");
-        FindTable(XSDT, (char *)"S3PT");
-        FindTable(XSDT, (char *)"MATR");
-        FindTable(XSDT, (char *)"MSDM");
-        FindTable(XSDT, (char *)"WPBT");
-        FindTable(XSDT, (char *)"OSDT");
-        FindTable(XSDT, (char *)"RSDP");
-        FindTable(XSDT, (char *)"NFIT");
-        FindTable(XSDT, (char *)"ASF!");
-        FindTable(XSDT, (char *)"BOOT");
-        FindTable(XSDT, (char *)"CSRT");
-        FindTable(XSDT, (char *)"DBG2");
-        FindTable(XSDT, (char *)"DBGP");
-        FindTable(XSDT, (char *)"DMAR");
-        FindTable(XSDT, (char *)"IBFT");
-        FindTable(XSDT, (char *)"IORT");
-        FindTable(XSDT, (char *)"IVRS");
-        FindTable(XSDT, (char *)"LPIT");
-        FindTable(XSDT, (char *)"MCHI");
-        FindTable(XSDT, (char *)"MTMR");
-        FindTable(XSDT, (char *)"SLIC");
-        FindTable(XSDT, (char *)"SPCR");
-        FindTable(XSDT, (char *)"SPMI");
-        FindTable(XSDT, (char *)"UEFI");
-        FindTable(XSDT, (char *)"VRTC");
-        FindTable(XSDT, (char *)"WDAT");
-        FindTable(XSDT, (char *)"WDDT");
-        FindTable(XSDT, (char *)"WDRT");
-    }
-
-    ACPI::ACPI(BootInfo *Info)
-    {
-        trace("Initializing ACPI");
-        if (Info->RSDP->Revision >= 2 && Info->RSDP->XSDTAddress)
-        {
-            debug("XSDT supported");
-            XSDTSupported = true;
-            XSDT = (ACPIHeader *)(Info->RSDP->XSDTAddress);
-        }
-        else
-        {
-            debug("RSDT supported");
-            XSDT = (ACPIHeader *)(uintptr_t)Info->RSDP->RSDTAddress;
-        }
-
-        this->SearchTables(XSDT);
-
-        if (FADT)
-        {
-            outb(FADT->SMI_CommandPort, FADT->AcpiEnable);
-            while (!(inw(FADT->PM1aControlBlock) & 1))
-                ;
-        }
-    }
-
-    ACPI::~ACPI()
-    {
-    }
-}
--- a/Kernel/Architecture/amd64/Bootstrap/Limine.c
+++ b/Kernel/Architecture/amd64/Bootstrap/Limine.c
@@ -1,257 +0,0 @@
-#include <boot/binfo.h>
-#include <types.h>
-#include <debug.h>
-#include <convert.h>
-
-#include "../../../../tools/limine/limine.h"
-#include "../../../kernel.h"
-
-void init_limine();
-
-static volatile struct limine_entry_point_request EntryPointRequest = {
-    .id = LIMINE_ENTRY_POINT_REQUEST,
-    .revision = 0,
-    .response = NULL,
-    .entry = init_limine};
-static volatile struct limine_bootloader_info_request BootloaderInfoRequest = {
-    .id = LIMINE_BOOTLOADER_INFO_REQUEST,
-    .revision = 0};
-static volatile struct limine_terminal_request TerminalRequest = {
-    .id = LIMINE_TERMINAL_REQUEST,
-    .revision = 0};
-static volatile struct limine_framebuffer_request FramebufferRequest = {
-    .id = LIMINE_FRAMEBUFFER_REQUEST,
-    .revision = 0};
-static volatile struct limine_memmap_request MemmapRequest = {
-    .id = LIMINE_MEMMAP_REQUEST,
-    .revision = 0};
-static volatile struct limine_kernel_address_request KernelAddressRequest = {
-    .id = LIMINE_KERNEL_ADDRESS_REQUEST,
-    .revision = 0};
-static volatile struct limine_rsdp_request RsdpRequest = {
-    .id = LIMINE_RSDP_REQUEST,
-    .revision = 0};
-static volatile struct limine_kernel_file_request KernelFileRequest = {
-    .id = LIMINE_KERNEL_FILE_REQUEST,
-    .revision = 0};
-static volatile struct limine_module_request ModuleRequest = {
-    .id = LIMINE_MODULE_REQUEST,
-    .revision = 0};
-
-static volatile struct limine_smbios_request SmbiosRequest = {
-    .id = LIMINE_SMBIOS_REQUEST,
-    .revision = 0};
-
-SafeFunction NIF void init_limine()
-{
-    struct BootInfo binfo;
-    struct limine_bootloader_info_response *BootloaderInfoResponse = BootloaderInfoRequest.response;
-    info("Bootloader: %s %s", BootloaderInfoResponse->name, BootloaderInfoResponse->version);
-
-    struct limine_terminal_response *TerminalResponse = TerminalRequest.response;
-
-    if (TerminalResponse == NULL || TerminalResponse->terminal_count < 1)
-    {
-        warn("No terminal available.");
-        while (1)
-            asmv("hlt");
-    }
-    TerminalResponse->write(TerminalResponse->terminals[0], "\033[37mPlease wait... ", 20);
-
-    struct limine_framebuffer_response *FrameBufferResponse = FramebufferRequest.response;
-    struct limine_memmap_response *MemmapResponse = MemmapRequest.response;
-    struct limine_kernel_address_response *KernelAddressResponse = KernelAddressRequest.response;
-    struct limine_rsdp_response *RsdpResponse = RsdpRequest.response;
-    struct limine_kernel_file_response *KernelFileResponse = KernelFileRequest.response;
-    struct limine_module_response *ModuleResponse = ModuleRequest.response;
-    struct limine_smbios_response *SmbiosResponse = SmbiosRequest.response;
-
-    if (FrameBufferResponse == NULL || FrameBufferResponse->framebuffer_count < 1)
-    {
-        error("No framebuffer available [%p;%ld]", FrameBufferResponse,
-              (FrameBufferResponse == NULL) ? 0 : FrameBufferResponse->framebuffer_count);
-        TerminalResponse->write(TerminalResponse->terminals[0], "No framebuffer available", 24);
-        while (1)
-            asmv("hlt");
-    }
-
-    if (MemmapResponse == NULL || MemmapResponse->entry_count < 1)
-    {
-        error("No memory map available [%p;%ld]", MemmapResponse,
-              (MemmapResponse == NULL) ? 0 : MemmapResponse->entry_count);
-        TerminalResponse->write(TerminalResponse->terminals[0], "No memory map available", 23);
-        while (1)
-            asmv("hlt");
-    }
-
-    if (KernelAddressResponse == NULL)
-    {
-        error("No kernel address available [%p]", KernelAddressResponse);
-        TerminalResponse->write(TerminalResponse->terminals[0], "No kernel address available", 27);
-        while (1)
-            asmv("hlt");
-    }
-
-    if (RsdpResponse == NULL || RsdpResponse->address == 0)
-    {
-        error("No RSDP address available [%p;%p]", RsdpResponse,
-              (RsdpResponse == NULL) ? 0 : RsdpResponse->address);
-        TerminalResponse->write(TerminalResponse->terminals[0], "No RSDP address available", 25);
-        while (1)
-            asmv("hlt");
-    }
-
-    if (KernelFileResponse == NULL || KernelFileResponse->kernel_file == NULL)
-    {
-        error("No kernel file available [%p;%p]", KernelFileResponse,
-              (KernelFileResponse == NULL) ? 0 : KernelFileResponse->kernel_file);
-        TerminalResponse->write(TerminalResponse->terminals[0], "No kernel file available", 24);
-        while (1)
-            asmv("hlt");
-    }
-
-    if (ModuleResponse == NULL || ModuleResponse->module_count < 1)
-    {
-        error("No module information available [%p;%ld]", ModuleResponse,
-              (ModuleResponse == NULL) ? 0 : ModuleResponse->module_count);
-        TerminalResponse->write(TerminalResponse->terminals[0], "No module information available", 31);
-        while (1)
-            asmv("hlt");
-    }
-
-    for (uint64_t i = 0; i < FrameBufferResponse->framebuffer_count; i++)
-    {
-        struct limine_framebuffer *framebuffer = FrameBufferResponse->framebuffers[i];
-        binfo.Framebuffer[i].BaseAddress = (void *)((uint64_t)framebuffer->address - 0xffff800000000000);
-        binfo.Framebuffer[i].Width = framebuffer->width;
-        binfo.Framebuffer[i].Height = framebuffer->height;
-        binfo.Framebuffer[i].Pitch = framebuffer->pitch;
-        binfo.Framebuffer[i].BitsPerPixel = framebuffer->bpp;
-        binfo.Framebuffer[i].MemoryModel = framebuffer->memory_model;
-        binfo.Framebuffer[i].RedMaskSize = framebuffer->red_mask_size;
-        binfo.Framebuffer[i].RedMaskShift = framebuffer->red_mask_shift;
-        binfo.Framebuffer[i].GreenMaskSize = framebuffer->green_mask_size;
-        binfo.Framebuffer[i].GreenMaskShift = framebuffer->green_mask_shift;
-        binfo.Framebuffer[i].BlueMaskSize = framebuffer->blue_mask_size;
-        binfo.Framebuffer[i].BlueMaskShift = framebuffer->blue_mask_shift;
-        binfo.Framebuffer[i].ExtendedDisplayIdentificationData = framebuffer->edid;
-        binfo.Framebuffer[i].EDIDSize = framebuffer->edid_size;
-        debug("Framebuffer %d: %dx%d %d bpp", i, framebuffer->width, framebuffer->height, framebuffer->bpp);
-        debug("More info:\nAddress: %p\nPitch: %ld\nMemoryModel: %d\nRedMaskSize: %d\nRedMaskShift: %d\nGreenMaskSize: %d\nGreenMaskShift: %d\nBlueMaskSize: %d\nBlueMaskShift: %d\nEDID: %p\nEDIDSize: %d",
-              (uint64_t)framebuffer->address - 0xffff800000000000, framebuffer->pitch, framebuffer->memory_model, framebuffer->red_mask_size, framebuffer->red_mask_shift, framebuffer->green_mask_size, framebuffer->green_mask_shift, framebuffer->blue_mask_size, framebuffer->blue_mask_shift, framebuffer->edid, framebuffer->edid_size);
-    }
-
-    binfo.Memory.Entries = MemmapResponse->entry_count;
-    for (uint64_t i = 0; i < MemmapResponse->entry_count; i++)
-    {
-        if (MemmapResponse->entry_count > MAX_MEMORY_ENTRIES)
-        {
-            warn("Too many memory entries, skipping the rest...");
-            break;
-        }
-
-        struct limine_memmap_entry *entry = MemmapResponse->entries[i];
-        binfo.Memory.Size += entry->length;
-        switch (entry->type)
-        {
-        case LIMINE_MEMMAP_USABLE:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = Usable;
-            break;
-        case LIMINE_MEMMAP_RESERVED:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = Reserved;
-            break;
-        case LIMINE_MEMMAP_ACPI_RECLAIMABLE:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = ACPIReclaimable;
-            break;
-        case LIMINE_MEMMAP_ACPI_NVS:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = ACPINVS;
-            break;
-        case LIMINE_MEMMAP_BAD_MEMORY:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = BadMemory;
-            break;
-        case LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = BootloaderReclaimable;
-            break;
-        case LIMINE_MEMMAP_KERNEL_AND_MODULES:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = KernelAndModules;
-            break;
-        case LIMINE_MEMMAP_FRAMEBUFFER:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = Framebuffer;
-            break;
-        default:
-            binfo.Memory.Entry[i].BaseAddress = (void *)entry->base;
-            binfo.Memory.Entry[i].Length = entry->length;
-            binfo.Memory.Entry[i].Type = Unknown;
-            break;
-        }
-    }
-
-    for (uint64_t i = 0; i < ModuleResponse->module_count; i++)
-    {
-        if (i > MAX_MODULES)
-        {
-            warn("Too many modules, skipping the rest...");
-            break;
-        }
-
-        binfo.Modules[i].Address = (void *)((uint64_t)ModuleResponse->modules[i]->address - 0xffff800000000000);
-        strncpy(binfo.Modules[i].Path,
-                ModuleResponse->modules[i]->path,
-                strlen(ModuleResponse->modules[i]->path) + 1);
-        strncpy(binfo.Modules[i].CommandLine,
-                ModuleResponse->modules[i]->cmdline,
-                strlen(ModuleResponse->modules[i]->cmdline) + 1);
-        binfo.Modules[i].Size = ModuleResponse->modules[i]->size;
-        debug("Module %d:\nAddress: %p\nPath: %s\nCommand Line: %s\nSize: %ld", i,
-              (uint64_t)ModuleResponse->modules[i]->address - 0xffff800000000000, ModuleResponse->modules[i]->path,
-              ModuleResponse->modules[i]->cmdline, ModuleResponse->modules[i]->size);
-    }
-
-    binfo.RSDP = (struct RSDPInfo *)((uint64_t)RsdpResponse->address - 0xffff800000000000);
-    trace("RSDP: %p(%p) [Signature: %.8s] [OEM: %.6s]",
-          RsdpResponse->address, binfo.RSDP, binfo.RSDP->Signature, binfo.RSDP->OEMID);
-
-    debug("SMBIOS: %p %p", SmbiosResponse->entry_32, SmbiosResponse->entry_64);
-    if (SmbiosResponse->entry_32 != NULL)
-        binfo.SMBIOSPtr = (void *)((uint64_t)SmbiosResponse->entry_32 - 0xffff800000000000);
-    else if (SmbiosResponse->entry_64 != NULL)
-        binfo.SMBIOSPtr = (void *)((uint64_t)SmbiosResponse->entry_64 - 0xffff800000000000);
-    else
-        binfo.SMBIOSPtr = NULL;
-
-    binfo.Kernel.PhysicalBase = (void *)KernelAddressResponse->physical_base;
-    binfo.Kernel.VirtualBase = (void *)KernelAddressResponse->virtual_base;
-    binfo.Kernel.FileBase = KernelFileResponse->kernel_file->address;
-    strncpy(binfo.Kernel.CommandLine,
-            KernelFileResponse->kernel_file->cmdline,
-            strlen(KernelFileResponse->kernel_file->cmdline) + 1);
-    binfo.Kernel.Size = KernelFileResponse->kernel_file->size;
-    trace("Kernel physical address: %p", KernelAddressResponse->physical_base);
-    trace("Kernel virtual address: %p", KernelAddressResponse->virtual_base);
-
-    strncpy(binfo.Bootloader.Name,
-            BootloaderInfoResponse->name,
-            strlen(BootloaderInfoResponse->name) + 1);
-    strncpy(binfo.Bootloader.Version,
-            BootloaderInfoResponse->version,
-            strlen(BootloaderInfoResponse->version) + 1);
-
-    // Call kernel entry point
-    Entry(&binfo);
-}
--- a/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Detection.asm
+++ b/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Detection.asm
@@ -1,41 +0,0 @@
-[bits 32]
-section .bootstrap.text
-global DetectCPUID
-DetectCPUID:
-    pushfd
-    pop eax
-    mov ecx, eax
-    xor eax, 1 << 21
-    push eax
-    popfd
-    pushfd
-    pop eax
-    push ecx
-    popfd
-    xor eax, ecx
-    jz .NoCPUID
-    ret
-.NoCPUID:
-    ; mov word [0xb8F00], 0xF00F ; .
-.Loop:
-    cli
-    hlt
-    jmp .Loop
-
-global Detect64Bit
-Detect64Bit:
-    mov eax, 0x80000000
-    cpuid
-    cmp eax, 0x80000001
-    jb .NoLongMode
-    mov eax, 0x80000001
-    cpuid
-    test edx, 1 << 29
-    jz .NoLongMode
-    ret
-.NoLongMode:
-    ; mov word [0xb8F00], 0xF00A ; .
-.Loop:
-    cli
-    hlt
-    jmp .Loop
--- a/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Entry.asm
+++ b/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Entry.asm
@@ -1,152 +0,0 @@
-; https://wiki.osdev.org/Creating_a_64-bit_kernel
-; https://wiki.osdev.org/Entering_Long_Mode_Directly
-
-KERNEL_VIRTUAL_BASE equ 0xFFFFFFFF80000000 ; 512GB
-KERNEL_LMA equ 0x1000000 ; 16MB
-KERNEL_STACK_SIZE equ 0x4000 ; 16KB
-
-extern Multiboot2Entry
-extern BootPageTable
-extern UpdatePageTable
-extern UpdatePageTable64
-extern DetectCPUID
-extern Detect64Bit
-extern LoadGDT32
-global MB2_start
-extern MB2_start_c
-
-[bits 32]
-
-section .bootstrap.data
-global MB2_HeaderMagic
-MB2_HeaderMagic:
-    times (0x64) dq 0
-
-global MB2_HeaderInfo
-MB2_HeaderInfo:
-	times (0x64) dq 0
-
-section .bootstrap.text
-MB2_start:
-	cli
-	; mov word [0xb8F00], 0x072E ; .
-    mov [MB2_HeaderMagic], eax
-    mov [MB2_HeaderInfo], ebx
-
-	; We need to check if the CPU supports 64-bit mode
-	call DetectCPUID
-	call Detect64Bit
-
-	; mov word [0xb8F02], 0x072E ; .
-
-	mov ecx, cr0
-	and ecx, 0x7fffffff ; Clear PG
-	mov cr0, ecx
-
-	mov ecx, cr4
-	or ecx, 0x10 ; Set PSE
-	or ecx, 0x20 ; Set PAE
-	mov cr4, ecx
-
-	; Load the GDT and update the page table
-	call LoadGDT32
-	call UpdatePageTable
-
-	; Load the new page table
-	mov edi, BootPageTable
-	mov cr3, edi
-
-	; mov word [0xb8F04], 0x072E ; .
-
-	; Enable long mode
-	mov ecx, 0xC0000080 ; EFER
-	rdmsr
-	or eax, 0x800 | 0x100 | 0x1 ; Set LME, LMA, SCE
-	wrmsr
-
-	mov ecx, cr0
-	or ecx, (0x80000000 | 0x1) ; Set PG and PE
-	mov cr0, ecx
-
-
-	lgdt [GDT64.Ptr]
-    ; xor eax, eax
-    ; sgdt [eax]
-    ; test eax, eax
-    ; jz .InvalidGDT
-
-	; .InvalidGDT:
-	; 	mov word [0xb8F07], 0x4 ; Red
-	; 	hlt
-
-	jmp GDT64.code:HigherHalfStart
-
-[bits 64]
-HigherHalfStart:
-	cli
-	; mov word [0xb8F06], 0x072E ; .
-	call UpdatePageTable64
-
-	; Load the new page table
-	mov rdi, BootPageTable
-	mov cr3, rdi
-
-	mov ax, GDT64.data
-	mov ds, ax
-	mov es, ax
-	mov fs, ax
-	mov gs, ax
-	mov ss, ax
-
-	; mov word [0xb8F08], 0x072E ; .
-	mov rsp, (KernelStack + KERNEL_STACK_SIZE)
-	mov rbp, (KernelStack + KERNEL_STACK_SIZE)
-
-	cld
-	cli
-
-	call Multiboot2Entry
-	.Loop:
-		hlt
-		jmp .Loop
-
-section .bootstrap.bss
-align 16
-KernelStack: 
-	resb KERNEL_STACK_SIZE
-
-; Access bits
-PRESENT equ 1 << 7
-NOT_SYS equ 1 << 4
-EXEC equ 1 << 3
-DC equ 1 << 2
-RW equ 1 << 1
-ACCESSED equ 1 << 0
- 
-; Flags bits
-GRAN_4K equ 1 << 7
-SZ_32 equ 1 << 6
-LONG_MODE equ 1 << 5
-
-section .bootstrap.data
-GDT64:
-    .null: equ $ - GDT64
-        dq 0
-    .code: equ $ - GDT64
-        dd 0xFFFF
-        db 0
-        db PRESENT | NOT_SYS | EXEC | RW
-        db GRAN_4K | LONG_MODE | 0xF
-        db 0
-    .data: equ $ - GDT64
-        dd 0xFFFF
-        db 0
-        db PRESENT | NOT_SYS | RW
-        db GRAN_4K | SZ_32 | 0xF
-        db 0
-    .tss: equ $ - GDT64
-        dd 0x00000068
-        dd 0x00CF8900
-	.Ptr:
-		dw $ - GDT64 - 1
-		dq GDT64
--- a/Kernel/Architecture/amd64/Bootstrap/Multiboot2/GDT32.asm
+++ b/Kernel/Architecture/amd64/Bootstrap/Multiboot2/GDT32.asm
@@ -1,47 +0,0 @@
-[bits 32]
-section .bootstrap.text
-
-align 32
-global gdtr
-gdtr:
-    dw GDT32_END - GDT32 - 1
-    dd GDT32
-
-align 32
-GDT32:
-    dq 0x0
-
-    dw 0xffff
-    dw 0x0000
-    db 0x00
-    dw 0xcf9a
-    db 0x00
-
-    dw 0xffff
-    dw 0x0000
-    db 0x00
-    dw 0xcf92
-    db 0x00
-
-    dw 0x0100
-    dw 0x1000
-    db 0x00
-    dw 0x4092
-    db 0x00
-GDT32_END:
-
-global LoadGDT32
-LoadGDT32:
-	lgdt [gdtr]
-
-	jmp 0x8:ActivateGDT
-	ActivateGDT:
-		mov cx, 0x10
-		mov ss, cx
-		mov ds, cx
-		mov es, cx
-		mov fs, cx
-		mov cx, 0x18
-		mov gs, cx
-
-    ret
--- a/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Header.asm
+++ b/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Header.asm
@@ -1,60 +0,0 @@
-extern MB2_start
-
-[bits 32]
-section .multiboot2
-align 4096
-HEADER_START:
-    dd 0xE85250D6
-    dd 0
-    dd (HEADER_END - HEADER_START)
-    dd 0x100000000 - (HEADER_END - HEADER_START) - 0 - 0xE85250D6
-align 8
-MB2_INFO_REQUEST_TAG_START:
-    dw 1
-    dw 0
-    dd MB2_INFO_REQUEST_TAG_END - MB2_INFO_REQUEST_TAG_START
-    dd 1 ; Command Line
-    dd 2 ; Boot Loader Name
-    dd 3 ; Module
-    dd 4 ; Basic Memory Information
-    dd 5 ; BIOS Boot Device
-    dd 6 ; Memory Map
-    dd 7 ; VBE
-    dd 8 ; Framebuffer
-    dd 9 ; ELF Sections
-    dd 10 ; APM Table
-    dd 11 ; EFI 32-bit System Table Pointer
-    dd 12 ; EFI 64-bit System Table Pointer
-    ; dd 13 ; SMBIOS
-    dd 14 ; ACPI Old
-    dd 15 ; ACPI New
-    dd 16 ; Network
-    dd 17 ; EFI Memory Map
-    dd 18 ; EFI Boot Services Notifier
-    dd 19 ; EFI 32-bit Image Handle Pointer
-    dd 20 ; EFI 64-bit Image Handle Pointer
-    dd 21 ; Load Base Address
-MB2_INFO_REQUEST_TAG_END:
-align 8
-MB2_ENTRY_TAG:        
-    dw 3
-    dw 0
-    dd MB2_ENTRY_TAG_END - MB2_ENTRY_TAG
-    dd MB2_start
-MB2_ENTRY_TAG_END:
-align 8
-MB2_FRAMEBUFFER_TAG_START:
-    dw 5
-    dw 1
-    dd MB2_FRAMEBUFFER_TAG_END - MB2_FRAMEBUFFER_TAG_START
-    dd 1280 ; Width
-    dd 720 ; Height
-    dd 32 ; Depth
-MB2_FRAMEBUFFER_TAG_END:
-align 8
-MB2_TAG_START:
-    dw 0
-    dw 0
-    dd MB2_TAG_END - MB2_TAG_START
-MB2_TAG_END:
-HEADER_END:
--- a/Kernel/Architecture/amd64/Bootstrap/Multiboot2/MB2MemoryMapper.cpp
+++ b/Kernel/Architecture/amd64/Bootstrap/Multiboot2/MB2MemoryMapper.cpp
@@ -1,285 +0,0 @@
-#include <types.h>
-
-union __attribute__((packed)) PageTableEntry
-{
-    struct
-    {
-        bool Present : 1;            // 0
-        bool ReadWrite : 1;          // 1
-        bool UserSupervisor : 1;     // 2
-        bool WriteThrough : 1;       // 3
-        bool CacheDisable : 1;       // 4
-        bool Accessed : 1;           // 5
-        bool Dirty : 1;              // 6
-        bool PageAttributeTable : 1; // 7
-        bool Global : 1;             // 8
-        uint8_t Available0 : 3;      // 9-11
-        uint64_t Address : 40;       // 12-51
-        uint32_t Available1 : 7;     // 52-58
-        uint8_t ProtectionKey : 4;   // 59-62
-        bool ExecuteDisable : 1;     // 63
-    };
-    uint64_t raw;
-
-    __always_inline inline SafeFunction NIF void SetAddress(uintptr_t _Address)
-    {
-        _Address &= 0x000000FFFFFFFFFF;
-        this->raw &= 0xFFF0000000000FFF;
-        this->raw |= (_Address << 12);
-    }
-
-    __always_inline inline SafeFunction NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
-};
-
-struct __attribute__((packed)) PageTableEntryPtr
-{
-    PageTableEntry Entries[511];
-};
-
-union __attribute__((packed)) PageDirectoryEntry
-{
-    struct
-    {
-        bool Present : 1;         // 0
-        bool ReadWrite : 1;       // 1
-        bool UserSupervisor : 1;  // 2
-        bool WriteThrough : 1;    // 3
-        bool CacheDisable : 1;    // 4
-        bool Accessed : 1;        // 5
-        bool Available0 : 1;      // 6
-        bool PageSize : 1;        // 7
-        uint8_t Available1 : 4;   // 8-11
-        uint64_t Address : 40;    // 12-51
-        uint32_t Available2 : 11; // 52-62
-        bool ExecuteDisable : 1;  // 63
-    };
-    uint64_t raw;
-
-    __always_inline inline SafeFunction NIF void SetAddress(uintptr_t _Address)
-    {
-        _Address &= 0x000000FFFFFFFFFF;
-        this->raw &= 0xFFF0000000000FFF;
-        this->raw |= (_Address << 12);
-    }
-
-    __always_inline inline SafeFunction NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
-};
-
-struct __attribute__((packed)) PageDirectoryEntryPtr
-{
-    PageDirectoryEntry Entries[511];
-};
-
-union __attribute__((packed)) PageDirectoryPointerTableEntry
-{
-    struct
-    {
-        bool Present : 1;         // 0
-        bool ReadWrite : 1;       // 1
-        bool UserSupervisor : 1;  // 2
-        bool WriteThrough : 1;    // 3
-        bool CacheDisable : 1;    // 4
-        bool Accessed : 1;        // 5
-        bool Available0 : 1;      // 6
-        bool PageSize : 1;        // 7
-        uint8_t Available1 : 4;   // 8-11
-        uint64_t Address : 40;    // 12-51
-        uint32_t Available2 : 11; // 52-62
-        bool ExecuteDisable : 1;  // 63
-    };
-    uint64_t raw;
-
-    __always_inline inline SafeFunction NIF void SetAddress(uintptr_t _Address)
-    {
-        _Address &= 0x000000FFFFFFFFFF;
-        this->raw &= 0xFFF0000000000FFF;
-        this->raw |= (_Address << 12);
-    }
-
-    __always_inline inline SafeFunction NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
-};
-
-struct __attribute__((packed)) PageDirectoryPointerTableEntryPtr
-{
-    PageDirectoryPointerTableEntry Entries[511];
-};
-
-union __attribute__((packed)) PageMapLevel4
-{
-    struct
-    {
-        bool Present : 1;         // 0
-        bool ReadWrite : 1;       // 1
-        bool UserSupervisor : 1;  // 2
-        bool WriteThrough : 1;    // 3
-        bool CacheDisable : 1;    // 4
-        bool Accessed : 1;        // 5
-        bool Available0 : 1;      // 6
-        bool Reserved0 : 1;       // 7
-        uint8_t Available1 : 4;   // 8-11
-        uint64_t Address : 40;    // 12-51
-        uint32_t Available2 : 11; // 52-62
-        bool ExecuteDisable : 1;  // 63
-    };
-    uint64_t raw;
-
-    __always_inline inline SafeFunction NIF void SetAddress(uintptr_t _Address)
-    {
-        _Address &= 0x000000FFFFFFFFFF;
-        this->raw &= 0xFFF0000000000FFF;
-        this->raw |= (_Address << 12);
-    }
-
-    __always_inline inline SafeFunction NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
-};
-
-struct PageTable4
-{
-    PageMapLevel4 Entries[511];
-} __attribute__((aligned(0x1000)));
-
-extern "C" char BootPageTable[];
-extern uintptr_t _kernel_start, _kernel_end;
-
-__attribute__((section(".bootstrap.data"))) static PageTable4 *BPTable = (PageTable4 *)BootPageTable;
-__attribute__((section(".bootstrap.data"))) static size_t BPT_Allocated = 0x4000;
-
-__always_inline inline SafeFunction NIF void *RequestPage()
-{
-    void *Page = (void *)(BootPageTable + BPT_Allocated);
-    BPT_Allocated += 0x1000;
-    if (BPT_Allocated >= 0x10000) /* The length of BootPageTable */
-    {
-        while (true)
-            ;
-    }
-    return Page;
-}
-
-class PageMapIndexer
-{
-public:
-    uintptr_t PMLIndex = 0;
-    uintptr_t PDPTEIndex = 0;
-    uintptr_t PDEIndex = 0;
-    uintptr_t PTEIndex = 0;
-    __always_inline inline SafeFunction NIF PageMapIndexer(uintptr_t VirtualAddress)
-    {
-        uintptr_t Address = VirtualAddress;
-        Address >>= 12;
-        this->PTEIndex = Address & 0x1FF;
-        Address >>= 9;
-        this->PDEIndex = Address & 0x1FF;
-        Address >>= 9;
-        this->PDPTEIndex = Address & 0x1FF;
-        Address >>= 9;
-        this->PMLIndex = Address & 0x1FF;
-    }
-};
-
-__always_inline inline SafeFunction NIF void Map(void *VirtualAddress, void *PhysicalAddress, uint64_t Flags)
-{
-    PageMapIndexer Index = PageMapIndexer((uintptr_t)VirtualAddress);
-    // Clear any flags that are not 1 << 0 (Present) - 1 << 5 (Accessed) because rest are for page table entries only
-    uint64_t DirectoryFlags = Flags & 0x3F;
-
-    PageMapLevel4 PML4 = BPTable->Entries[Index.PMLIndex];
-    PageDirectoryPointerTableEntryPtr *PDPTEPtr = nullptr;
-    if (!PML4.Present)
-    {
-        PDPTEPtr = (PageDirectoryPointerTableEntryPtr *)RequestPage();
-        {
-            void *ptr = PDPTEPtr;
-            int value = 0;
-            size_t num = 0x1000;
-            uint8_t *p = (uint8_t *)ptr;
-            for (size_t i = 0; i < num; i++)
-                p[i] = value;
-        }
-        PML4.Present = true;
-        PML4.SetAddress((uintptr_t)PDPTEPtr >> 12);
-    }
-    else
-        PDPTEPtr = (PageDirectoryPointerTableEntryPtr *)((uintptr_t)PML4.GetAddress() << 12);
-    PML4.raw |= DirectoryFlags;
-    BPTable->Entries[Index.PMLIndex] = PML4;
-
-    PageDirectoryPointerTableEntry PDPTE = PDPTEPtr->Entries[Index.PDPTEIndex];
-    PageDirectoryEntryPtr *PDEPtr = nullptr;
-    if (!PDPTE.Present)
-    {
-        PDEPtr = (PageDirectoryEntryPtr *)RequestPage();
-        {
-            void *ptr = PDEPtr;
-            int value = 0;
-            size_t num = 0x1000;
-            uint8_t *p = (uint8_t *)ptr;
-            for (size_t i = 0; i < num; i++)
-                p[i] = value;
-        }
-        PDPTE.Present = true;
-        PDPTE.SetAddress((uintptr_t)PDEPtr >> 12);
-    }
-    else
-        PDEPtr = (PageDirectoryEntryPtr *)((uintptr_t)PDPTE.GetAddress() << 12);
-    PDPTE.raw |= DirectoryFlags;
-    PDPTEPtr->Entries[Index.PDPTEIndex] = PDPTE;
-
-    PageDirectoryEntry PDE = PDEPtr->Entries[Index.PDEIndex];
-    PageTableEntryPtr *PTEPtr = nullptr;
-    if (!PDE.Present)
-    {
-        PTEPtr = (PageTableEntryPtr *)RequestPage();
-        {
-            void *ptr = PTEPtr;
-            int value = 0;
-            size_t num = 0x1000;
-            uint8_t *p = (uint8_t *)ptr;
-            for (size_t i = 0; i < num; i++)
-                p[i] = value;
-        }
-        PDE.Present = true;
-        PDE.SetAddress((uintptr_t)PTEPtr >> 12);
-    }
-    else
-        PTEPtr = (PageTableEntryPtr *)((uintptr_t)PDE.GetAddress() << 12);
-    PDE.raw |= DirectoryFlags;
-    PDEPtr->Entries[Index.PDEIndex] = PDE;
-
-    PageTableEntry PTE = PTEPtr->Entries[Index.PTEIndex];
-    PTE.Present = true;
-    PTE.raw |= Flags;
-    PTE.SetAddress((uintptr_t)PhysicalAddress >> 12);
-    PTEPtr->Entries[Index.PTEIndex] = PTE;
-    asmv("invlpg (%0)"
-         :
-         : "r"(VirtualAddress)
-         : "memory");
-}
-
-EXTERNC __attribute__((section(".bootstrap.text"))) SafeFunction NIF __attribute__((section(".bootstrap.text"))) void UpdatePageTable64()
-{
-    /*
-    TODO: this code corrupts the page table
-    */
-
-    BPTable = (PageTable4 *)BootPageTable;
-
-    // for (size_t i = 0; i < 0x10000000; i += 0x1000)
-    //     Map((void *)i, (void *)i, 0x3);
-
-    uintptr_t KernelStart = (uintptr_t)&_kernel_start;
-    uintptr_t KernelEnd = (uintptr_t)&_kernel_end;
-    uintptr_t PhysicalStart = KernelStart - 0xFFFFFFFF80000000;
-    for (uintptr_t i = KernelStart; i < KernelEnd; i += 0x1000)
-    {
-        Map((void *)i, (void *)PhysicalStart, 0x3);
-        PhysicalStart += 0x1000;
-    }
-
-    asmv("mov %%cr3, %%rax\n"
-         "mov %%rax, %%cr3\n"
-         :
-         :
-         : "rax");
-}
--- a/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Multiboot2.cpp
+++ b/Kernel/Architecture/amd64/Bootstrap/Multiboot2/Multiboot2.cpp
@@ -1,338 +0,0 @@
-#include <types.h>
-
-#include <boot/protocols/multiboot2.h>
-#include <memory.hpp>
-#include <io.h>
-
-#include "../../../../kernel.h"
-
-enum VideoType
-{
-    VIDEO_TYPE_NONE = 0x00,
-    VIDEO_TYPE_COLOUR = 0x20,
-    VIDEO_TYPE_MONOCHROME = 0x30,
-};
-
-uint16_t GetBiosAreaHardware()
-{
-    const uint16_t *BIOSDataAreaDetectedHardware = (const uint16_t *)0x410;
-    return *BIOSDataAreaDetectedHardware;
-}
-
-enum VideoType GetVideoType() { return (enum VideoType)(GetBiosAreaHardware() & 0x30); }
-
-void GetSMBIOS()
-{
-    unsigned char *SMBIOSAddress = (unsigned char *)0xF0000;
-    while ((unsigned int)(unsigned long)SMBIOSAddress < 0x100000)
-    {
-        if (SMBIOSAddress[0] == '_' &&
-            SMBIOSAddress[1] == 'S' &&
-            SMBIOSAddress[2] == 'M' &&
-            SMBIOSAddress[3] == '_')
-        {
-            unsigned char Checksum = 0;
-            int Length = SMBIOSAddress[5];
-            for (int i = 0; i < Length; i++)
-                Checksum += SMBIOSAddress[i];
-
-            if (Checksum == 0)
-                break;
-        }
-        SMBIOSAddress += 16;
-    }
-
-    if ((unsigned int)(unsigned long)SMBIOSAddress == 0x100000)
-    {
-        // No SMBIOS found
-    }
-}
-
-extern "C" unsigned int MB2_HeaderMagic;
-extern "C" unsigned long MB2_HeaderInfo;
-
-EXTERNC void Multiboot2Entry()
-{
-    unsigned long Info = MB2_HeaderInfo;
-    unsigned int Magic = MB2_HeaderMagic;
-    if (Info == NULL || Magic == NULL)
-    {
-        if (Magic == NULL)
-            error("Multiboot magic is NULL");
-        if (Info == NULL)
-            error("Multiboot info is NULL");
-        CPU::Stop();
-    }
-    else if (Magic != MULTIBOOT2_BOOTLOADER_MAGIC)
-    {
-        error("Multiboot magic is invalid (%#x != %#x)", Magic, MULTIBOOT2_BOOTLOADER_MAGIC);
-        CPU::Stop();
-    }
-
-    uint64_t div = 1193180 / 1000;
-    outb(0x43, 0xB6);
-    outb(0x42, (uint8_t)div);
-    outb(0x42, (uint8_t)(div >> 8));
-    uint8_t tmp = inb(0x61);
-    if (tmp != (tmp | 3))
-        outb(0x61, tmp | 3);
-
-    BootInfo mb2binfo;
-    uint8_t *VideoBuffer = (uint8_t *)0xB8F00;
-    int pos = 0;
-    auto InfoAddress = Info;
-    for (auto Tag = (struct multiboot_tag *)((uint8_t *)InfoAddress + 8);
-         ;
-         Tag = (struct multiboot_tag *)((multiboot_uint8_t *)Tag + ((Tag->size + 7) & ~7)))
-    {
-        VideoBuffer[pos++] = '.';
-        VideoBuffer[pos++] = 0x2;
-
-        if (Tag->type == MULTIBOOT_TAG_TYPE_END)
-        {
-            debug("End of multiboot2 tags");
-            break;
-        }
-
-        switch (Tag->type)
-        {
-        case MULTIBOOT_TAG_TYPE_CMDLINE:
-        {
-            strncpy(mb2binfo.Kernel.CommandLine,
-                    ((multiboot_tag_string *)Tag)->string,
-                    strlen(((multiboot_tag_string *)Tag)->string));
-            debug("Kernel command line: %s", mb2binfo.Kernel.CommandLine);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME:
-        {
-            strncpy(mb2binfo.Bootloader.Name,
-                    ((multiboot_tag_string *)Tag)->string,
-                    strlen(((multiboot_tag_string *)Tag)->string));
-            debug("Bootloader name: %s", mb2binfo.Bootloader.Name);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_MODULE:
-        {
-            multiboot_tag_module *module = (multiboot_tag_module *)Tag;
-            static int module_count = 0;
-            mb2binfo.Modules[module_count++].Address = (void *)(uint64_t)module->mod_start;
-            mb2binfo.Modules[module_count++].Size = module->size;
-            strncpy(mb2binfo.Modules[module_count++].Path, "(null)", 6);
-            strncpy(mb2binfo.Modules[module_count++].CommandLine, module->cmdline,
-                    strlen(module->cmdline));
-            debug("Module: %s", mb2binfo.Modules[module_count++].Path);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO:
-        {
-            multiboot_tag_basic_meminfo *meminfo = (multiboot_tag_basic_meminfo *)Tag;
-            fixme("basic_meminfo->[mem_lower: %#x, mem_upper: %#x]",
-                  meminfo->mem_lower, meminfo->mem_upper);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_BOOTDEV:
-        {
-            multiboot_tag_bootdev *bootdev = (multiboot_tag_bootdev *)Tag;
-            fixme("bootdev->[biosdev: %#x, slice: %#x, part: %#x]",
-                  bootdev->biosdev, bootdev->slice, bootdev->part);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_MMAP:
-        {
-            multiboot_tag_mmap *mmap = (multiboot_tag_mmap *)Tag;
-            uint32_t EntryCount = mmap->size / sizeof(multiboot_mmap_entry);
-            mb2binfo.Memory.Entries = EntryCount;
-            for (uint32_t i = 0; i < EntryCount; i++)
-            {
-                if (EntryCount > MAX_MEMORY_ENTRIES)
-                {
-                    warn("Too many memory entries, skipping the rest...");
-                    break;
-                }
-                multiboot_mmap_entry entry = mmap->entries[i];
-                mb2binfo.Memory.Size += entry.len;
-                switch (entry.type)
-                {
-                case MULTIBOOT_MEMORY_AVAILABLE:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = Usable;
-                    break;
-                case MULTIBOOT_MEMORY_RESERVED:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = Reserved;
-                    break;
-                case MULTIBOOT_MEMORY_ACPI_RECLAIMABLE:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = ACPIReclaimable;
-                    break;
-                case MULTIBOOT_MEMORY_NVS:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = ACPINVS;
-                    break;
-                case MULTIBOOT_MEMORY_BADRAM:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = BadMemory;
-                    break;
-                default:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = Unknown;
-                    break;
-                }
-                debug("Memory entry: [BaseAddress: %#x, Length: %#x, Type: %d]",
-                      mb2binfo.Memory.Entry[i].BaseAddress,
-                      mb2binfo.Memory.Entry[i].Length,
-                      mb2binfo.Memory.Entry[i].Type);
-            }
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_VBE:
-        {
-            multiboot_tag_vbe *vbe = (multiboot_tag_vbe *)Tag;
-            fixme("vbe->[vbe_mode: %#x, vbe_interface_seg: %#x, vbe_interface_off: %#x, vbe_interface_len: %#x]",
-                  vbe->vbe_mode, vbe->vbe_interface_seg, vbe->vbe_interface_off, vbe->vbe_interface_len);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
-        {
-            multiboot_tag_framebuffer *fb = (multiboot_tag_framebuffer *)Tag;
-            static int fb_count = 0;
-            mb2binfo.Framebuffer[fb_count].BaseAddress = (void *)fb->common.framebuffer_addr;
-            mb2binfo.Framebuffer[fb_count].Width = fb->common.framebuffer_width;
-            mb2binfo.Framebuffer[fb_count].Height = fb->common.framebuffer_height;
-            mb2binfo.Framebuffer[fb_count].Pitch = fb->common.framebuffer_pitch;
-            mb2binfo.Framebuffer[fb_count].BitsPerPixel = fb->common.framebuffer_bpp;
-            mb2binfo.Framebuffer[fb_count].MemoryModel = fb->common.framebuffer_type;
-            switch (fb->common.framebuffer_type)
-            {
-            case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED:
-            {
-                mb2binfo.Framebuffer[fb_count].Type = Indexed;
-                break;
-            }
-            case MULTIBOOT_FRAMEBUFFER_TYPE_RGB:
-            {
-                mb2binfo.Framebuffer[fb_count].Type = RGB;
-                mb2binfo.Framebuffer[fb_count].RedMaskSize = fb->framebuffer_red_mask_size;
-                mb2binfo.Framebuffer[fb_count].RedMaskShift = fb->framebuffer_red_field_position;
-                mb2binfo.Framebuffer[fb_count].GreenMaskSize = fb->framebuffer_green_mask_size;
-                mb2binfo.Framebuffer[fb_count].GreenMaskShift = fb->framebuffer_green_field_position;
-                mb2binfo.Framebuffer[fb_count].BlueMaskSize = fb->framebuffer_blue_mask_size;
-                mb2binfo.Framebuffer[fb_count].BlueMaskShift = fb->framebuffer_blue_field_position;
-                break;
-            }
-            case MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT:
-            {
-                mb2binfo.Framebuffer[fb_count].Type = EGA;
-                break;
-            }
-            }
-            debug("Framebuffer %d: %dx%d %d bpp", fb_count, fb->common.framebuffer_width, fb->common.framebuffer_height, fb->common.framebuffer_bpp);
-            debug("More info:\nAddress: %p\nPitch: %lld\nMemoryModel: %d\nRedMaskSize: %d\nRedMaskShift: %d\nGreenMaskSize: %d\nGreenMaskShift: %d\nBlueMaskSize: %d\nBlueMaskShift: %d",
-                  fb->common.framebuffer_addr, fb->common.framebuffer_pitch, fb->common.framebuffer_type,
-                  fb->framebuffer_red_mask_size, fb->framebuffer_red_field_position, fb->framebuffer_green_mask_size,
-                  fb->framebuffer_green_field_position, fb->framebuffer_blue_mask_size, fb->framebuffer_blue_field_position);
-            fb_count++;
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_ELF_SECTIONS:
-        {
-            multiboot_tag_elf_sections *elf = (multiboot_tag_elf_sections *)Tag;
-            fixme("elf_sections->[sections=%#lx num=%d, size=%d, entsize=%d, shndx=%d]",
-                  &elf->sections, elf->num, elf->size, elf->entsize, elf->shndx);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_APM:
-        {
-            multiboot_tag_apm *apm = (multiboot_tag_apm *)Tag;
-            fixme("apm->[version: %d, cseg: %d, offset: %d, cseg_16: %d, dseg: %d, flags: %d, cseg_len: %d, cseg_16_len: %d, dseg_len: %d]",
-                  apm->version, apm->cseg, apm->offset, apm->cseg_16, apm->dseg, apm->flags, apm->cseg_len, apm->cseg_16_len, apm->dseg_len);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI32:
-        {
-            multiboot_tag_efi32 *efi32 = (multiboot_tag_efi32 *)Tag;
-            fixme("efi32->[pointer: %p, size: %d]", efi32->pointer, efi32->size);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI64:
-        {
-            multiboot_tag_efi64 *efi64 = (multiboot_tag_efi64 *)Tag;
-            fixme("efi64->[pointer: %p, size: %d]", efi64->pointer, efi64->size);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_SMBIOS:
-        {
-            multiboot_tag_smbios *smbios = (multiboot_tag_smbios *)Tag;
-            fixme("smbios->[major: %d, minor: %d]", smbios->major, smbios->minor);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_ACPI_OLD:
-        {
-            mb2binfo.RSDP = (BootInfo::RSDPInfo *)((multiboot_tag_old_acpi *)Tag)->rsdp;
-            debug("OLD ACPI RSDP: %p", mb2binfo.RSDP);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_ACPI_NEW:
-        {
-            mb2binfo.RSDP = (BootInfo::RSDPInfo *)((multiboot_tag_new_acpi *)Tag)->rsdp;
-            debug("NEW ACPI RSDP: %p", mb2binfo.RSDP);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_NETWORK:
-        {
-            multiboot_tag_network *net = (multiboot_tag_network *)Tag;
-            fixme("network->[dhcpack: %p]", net->dhcpack);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI_MMAP:
-        {
-            multiboot_tag_efi_mmap *efi_mmap = (multiboot_tag_efi_mmap *)Tag;
-            fixme("efi_mmap->[descr_size: %d, descr_vers: %d, efi_mmap: %p]",
-                  efi_mmap->descr_size, efi_mmap->descr_vers, efi_mmap->efi_mmap);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI_BS:
-        {
-            fixme("efi_bs->[%p] (unknown structure)", Tag);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI32_IH:
-        {
-            multiboot_tag_efi32_ih *efi32_ih = (multiboot_tag_efi32_ih *)Tag;
-            fixme("efi32_ih->[pointer: %p]", efi32_ih->pointer);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI64_IH:
-        {
-            multiboot_tag_efi64_ih *efi64_ih = (multiboot_tag_efi64_ih *)Tag;
-            fixme("efi64_ih->[pointer: %p]", efi64_ih->pointer);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR:
-        {
-            multiboot_tag_load_base_addr *load_base_addr = (multiboot_tag_load_base_addr *)Tag;
-            mb2binfo.Kernel.PhysicalBase = (void *)(uint64_t)load_base_addr->load_base_addr;
-            mb2binfo.Kernel.VirtualBase = (void *)(uint64_t)(load_base_addr->load_base_addr + 0xFFFFFFFF80000000);
-            debug("Kernel base: %p (physical) %p (virtual)", mb2binfo.Kernel.PhysicalBase, mb2binfo.Kernel.VirtualBase);
-            break;
-        }
-        default:
-        {
-            error("Unknown multiboot2 tag type: %d", Tag->type);
-            break;
-        }
-        }
-    }
-
-    tmp = inb(0x61) & 0xFC;
-    outb(0x61, tmp);
-
-    Entry(&mb2binfo);
-}
--- a/Kernel/Architecture/amd64/Bootstrap/Multiboot2/PageTable.asm
+++ b/Kernel/Architecture/amd64/Bootstrap/Multiboot2/PageTable.asm
@@ -1,45 +0,0 @@
-PAGE_TABLE_SIZE equ 0x8 ; 2GB
-[bits 32]
-
-section .bootstrap.bss
-align 0x1000
-global BootPageTable
-BootPageTable:
-    times (0x10000) dq 0 ; 0x4000
-
-section .bootstrap.text
-global UpdatePageTable
-UpdatePageTable:
-	mov edi, (BootPageTable + 0x0000) ; First PML4E
-	mov eax, (BootPageTable + 0x1000) ; First PDPTE
-	or eax, 11b ; Bitwise OR on rax (PDPTE) with 11b (Present, Write)
-	mov dword [edi], eax ; Write 11b to PML4E
-
-	mov edi, (BootPageTable + 0x1000) ; First PDPTE
-	mov eax, (BootPageTable + 0x2000) ; First PDE
-	or eax, 11b ; Bitwise OR on rax (PDE) with 11b (Present, Write)
-
-	mov ecx, PAGE_TABLE_SIZE ; For loop instruction
-	mov ebx, 0x0 ; Value to store in the next 4 bytes
-	.FillPageTableLevel3:
-		mov dword [edi], eax ; Store modified PDE in PDPTE
-		mov dword [edi + 4], ebx ; Store the rbx value in the next 4 bytes
-		add eax, 0x1000 ; Increment (page size)
-		adc ebx, 0 ; Add 0 to carry flag
-		add edi, 8 ; Add 8 to rdi (next PDE)
-		loop .FillPageTableLevel3 ; Loop until rcx is 0
-
-	mov edi, (BootPageTable + 0x2000) ; First PDE
-	mov eax, 11b | 10000000b ; Present, Write, Large Page
-
-	mov ecx, (512 * PAGE_TABLE_SIZE) ; For loop instruction
-	mov ebx, 0x0 ; Value to store in the next 4 bytes
-	.FillPageTableLevel2:
-		mov dword [edi], eax ; Store modified PDE in PDPTE
-		mov dword [edi + 4], ebx ; Store the rbx value in the next 4 bytes
-		add eax, 1 << 21 ; Increment (page size)
-		adc ebx, 0 ; Add 0 (carry flag) to rbx to increment if there was a carry
-		add edi, 8 ; Add 8 to rdi (next PDE)
-		loop .FillPageTableLevel2 ; Loop until rcx is 0
-
-	ret
--- a/Kernel/Architecture/amd64/DifferentiatedSystemDescriptionTable.cpp
+++ b/Kernel/Architecture/amd64/DifferentiatedSystemDescriptionTable.cpp
@@ -1,215 +0,0 @@
-#include "acpi.hpp"
-
-#include <time.hpp>
-#include <debug.h>
-#include <smp.hpp>
-#include <io.h>
-
-#include "cpu/apic.hpp"
-#include "../../kernel.h"
-
-#define ACPI_TIMER 0x0001
-#define ACPI_BUSMASTER 0x0010
-#define ACPI_GLOBAL 0x0020
-#define ACPI_POWER_BUTTON 0x0100
-#define ACPI_SLEEP_BUTTON 0x0200
-#define ACPI_RTC_ALARM 0x0400
-#define ACPI_PCIE_WAKE 0x4000
-#define ACPI_WAKE 0x8000
-
-namespace ACPI
-{
-    __attribute__((always_inline)) inline bool IsCanonical(uint64_t Address)
-    {
-        return ((Address <= 0x00007FFFFFFFFFFF) || ((Address >= 0xFFFF800000000000) && (Address <= 0xFFFFFFFFFFFFFFFF)));
-    }
-
-#define ACPI_ENABLED 0x0001
-#define ACPI_SLEEP 0x2000
-
-#define ACPI_GAS_MMIO 0
-#define ACPI_GAS_IO 1
-#define ACPI_GAS_PCI 2
-
-    void DSDT::OnInterruptReceived(CPU::x64::TrapFrame *Frame)
-    {
-        debug("SCI Handle Triggered");
-        uint16_t Event = 0;
-        {
-            uint16_t a = 0, b = 0;
-            if (acpi->FADT->PM1aEventBlock)
-            {
-                a = inw(acpi->FADT->PM1aEventBlock);
-                outw(acpi->FADT->PM1aEventBlock, a);
-            }
-            if (acpi->FADT->PM1bEventBlock)
-            {
-                b = inw(acpi->FADT->PM1bEventBlock);
-                outw(acpi->FADT->PM1bEventBlock, b);
-            }
-            Event = a | b;
-        }
-
-        debug("SCI Event: %#lx", Event);
-        if (Event & ACPI_BUSMASTER)
-        {
-            fixme("ACPI Busmaster");
-        }
-        else if (Event & ACPI_GLOBAL)
-        {
-            fixme("ACPI Global");
-        }
-        else if (Event & ACPI_POWER_BUTTON)
-        {
-            BeforeShutdown();
-            this->Shutdown();
-            Time::Clock tm = Time::ReadClock();
-            while (tm.Second == Time::ReadClock().Second)
-                ;
-            outw(0xB004, 0x2000);
-            outw(0x604, 0x2000);
-            outw(0x4004, 0x3400);
-            CPU::Stop();
-        }
-        else if (Event & ACPI_SLEEP_BUTTON)
-        {
-            fixme("ACPI Sleep Button");
-        }
-        else if (Event & ACPI_RTC_ALARM)
-        {
-            fixme("ACPI RTC Alarm");
-        }
-        else if (Event & ACPI_PCIE_WAKE)
-        {
-            fixme("ACPI PCIe Wake");
-        }
-        else if (Event & ACPI_WAKE)
-        {
-            fixme("ACPI Wake");
-        }
-        else if (Event & ACPI_TIMER)
-        {
-            fixme("ACPI Timer");
-        }
-        else
-        {
-            error("ACPI unknown event %#lx on CPU %d", Event, GetCurrentCPU()->ID);
-            CPU::Stop();
-        }
-        UNUSED(Frame);
-    }
-
-    void DSDT::Shutdown()
-    {
-        trace("Shutting down...");
-        if (SCI_EN == 1)
-        {
-            outw(acpi->FADT->PM1aControlBlock, (inw(acpi->FADT->PM1aControlBlock) & 0xE3FF) | ((SLP_TYPa << 10) | ACPI_SLEEP));
-            if (acpi->FADT->PM1bControlBlock)
-                outw(acpi->FADT->PM1bControlBlock, (inw(acpi->FADT->PM1bControlBlock) & 0xE3FF) | ((SLP_TYPb << 10) | ACPI_SLEEP));
-            outw(PM1a_CNT, SLP_TYPa | SLP_EN);
-            if (PM1b_CNT)
-                outw(PM1b_CNT, SLP_TYPb | SLP_EN);
-        }
-    }
-
-    void DSDT::Reboot()
-    {
-        trace("Rebooting...");
-        switch (acpi->FADT->ResetReg.AddressSpace)
-        {
-        case ACPI_GAS_MMIO:
-            *(uint8_t *)(acpi->FADT->ResetReg.Address) = acpi->FADT->ResetValue;
-            break;
-        case ACPI_GAS_IO:
-            outb(acpi->FADT->ResetReg.Address, acpi->FADT->ResetValue);
-            break;
-        case ACPI_GAS_PCI:
-            fixme("ACPI_GAS_PCI not supported.");
-            /*
-                seg      - 0
-                bus      - 0
-                dev      - (FADT->ResetReg.Address >> 32) & 0xFFFF
-                function - (FADT->ResetReg.Address >> 16) & 0xFFFF
-                offset   - FADT->ResetReg.Address & 0xFFFF
-                value    - FADT->ResetValue
-            */
-            break;
-        }
-    }
-
-    DSDT::DSDT(ACPI *acpi) : Interrupts::Handler(acpi->FADT->SCI_Interrupt + CPU::x86::IRQ0)
-    {
-        this->acpi = acpi;
-        uint64_t Address = ((IsCanonical(acpi->FADT->X_Dsdt) && acpi->XSDTSupported) ? acpi->FADT->X_Dsdt : acpi->FADT->Dsdt);
-        uint8_t *S5Address = (uint8_t *)(Address) + 36;
-        ACPI::ACPI::ACPIHeader *Header = (ACPI::ACPI::ACPIHeader *)Address;
-        uint64_t Length = Header->Length;
-        while (Length-- > 0)
-        {
-            if (!memcmp(S5Address, "_S5_", 4))
-                break;
-            S5Address++;
-        }
-        if (Length <= 0)
-        {
-            warn("_S5 not present in ACPI");
-            return;
-        }
-        if ((*(S5Address - 1) == 0x08 || (*(S5Address - 2) == 0x08 && *(S5Address - 1) == '\\')) && *(S5Address + 4) == 0x12)
-        {
-            S5Address += 5;
-            S5Address += ((*S5Address & 0xC0) >> 6) + 2;
-            if (*S5Address == 0x0A)
-                S5Address++;
-            SLP_TYPa = *(S5Address) << 10;
-            S5Address++;
-            if (*S5Address == 0x0A)
-                S5Address++;
-            SLP_TYPb = *(S5Address) << 10;
-            SMI_CMD = acpi->FADT->SMI_CommandPort;
-            ACPI_ENABLE = acpi->FADT->AcpiEnable;
-            ACPI_DISABLE = acpi->FADT->AcpiDisable;
-            PM1a_CNT = acpi->FADT->PM1aControlBlock;
-            PM1b_CNT = acpi->FADT->PM1bControlBlock;
-            PM1_CNT_LEN = acpi->FADT->PM1ControlLength;
-            SLP_EN = 1 << 13;
-            SCI_EN = 1;
-            trace("ACPI Shutdown is supported");
-            ACPIShutdownSupported = true;
-
-            uint16_t value = ACPI_POWER_BUTTON | ACPI_SLEEP_BUTTON | ACPI_WAKE;
-            {
-                uint16_t a = acpi->FADT->PM1aEventBlock + (acpi->FADT->PM1EventLength / 2);
-                uint16_t b = acpi->FADT->PM1bEventBlock + (acpi->FADT->PM1EventLength / 2);
-                debug("SCI Event: %#llx [a:%#x b:%#x]", value, a, b);
-                if (acpi->FADT->PM1aEventBlock)
-                    outw(a, value);
-                if (acpi->FADT->PM1bEventBlock)
-                    outw(b, value);
-            }
-
-            {
-                uint16_t a = 0, b = 0;
-                if (acpi->FADT->PM1aEventBlock)
-                {
-                    a = inw(acpi->FADT->PM1aEventBlock);
-                    outw(acpi->FADT->PM1aEventBlock, a);
-                }
-                if (acpi->FADT->PM1bEventBlock)
-                {
-                    b = inw(acpi->FADT->PM1bEventBlock);
-                    outw(acpi->FADT->PM1bEventBlock, b);
-                }
-            }
-            ((APIC::APIC *)Interrupts::apic[0])->RedirectIRQ(0, acpi->FADT->SCI_Interrupt, 1);
-            return;
-        }
-        warn("Failed to parse _S5 in ACPI");
-        SCI_EN = 0;
-    }
-
-    DSDT::~DSDT()
-    {
-    }
-}
--- a/Kernel/Architecture/amd64/MultipleAPICDescriptionTable.cpp
+++ b/Kernel/Architecture/amd64/MultipleAPICDescriptionTable.cpp
@@ -1,69 +0,0 @@
-#include "acpi.hpp"
-
-#include <memory.hpp>
-#include <debug.h>
-
-#include "../../kernel.h"
-
-namespace ACPI
-{
-    MADT::MADT(ACPI::MADTHeader *madt)
-    {
-        trace("Initializing MADT");
-        CPUCores = 0;
-        LAPICAddress = (LAPIC *)(uintptr_t)madt->LocalControllerAddress;
-        for (uint8_t *ptr = (uint8_t *)(madt->Entries);
-             (uintptr_t)(ptr) < (uintptr_t)(madt) + madt->Header.Length;
-             ptr += *(ptr + 1))
-        {
-            switch (*(ptr))
-            {
-            case 0:
-            {
-                if (ptr[4] & 1)
-                {
-                    lapic.push_back((LocalAPIC *)ptr);
-                    KPrint("Local APIC \e8888FF%d\eCCCCCC (APIC \e8888FF%d\eCCCCCC) found.", lapic.back()->ACPIProcessorId, lapic.back()->APICId);
-                    CPUCores++;
-                }
-                break;
-            }
-            case 1:
-            {
-                ioapic.push_back((MADTIOApic *)ptr);
-                KPrint("I/O APIC \e8888FF%d\eCCCCCC (Address \e8888FF%#lx\eCCCCCC) found.", ioapic.back()->APICID, ioapic.back()->Address);
-                Memory::Virtual().Map((void *)(uintptr_t)ioapic.back()->Address, (void *)(uintptr_t)ioapic.back()->Address, Memory::PTFlag::RW | Memory::PTFlag::PCD); // Make sure that the address is mapped.
-                break;
-            }
-            case 2:
-            {
-                iso.push_back((MADTIso *)ptr);
-                KPrint("ISO (IRQ:\e8888FF%#lx\eCCCCCC, BUS:\e8888FF%#lx\eCCCCCC, GSI:\e8888FF%#lx\eCCCCCC, %s\eCCCCCC/%s\eCCCCCC) found.",
-                       iso.back()->IRQSource, iso.back()->BuSSource, iso.back()->GSI,
-                       iso.back()->Flags & 0x00000004 ? "\e1770FFActive High" : "\e475EFFActive Low",
-                       iso.back()->Flags & 0x00000100 ? "\e00962DEdge Triggered" : "\e008F58Level Triggered");
-                break;
-            }
-            case 4:
-            {
-                nmi.push_back((MADTNmi *)ptr);
-                KPrint("NMI \e8888FF%#lx\eCCCCCC (lint:\e8888FF%#lx\eCCCCCC) found.", nmi.back()->processor, nmi.back()->lint);
-                break;
-            }
-            case 5:
-            {
-                LAPICAddress = (LAPIC *)ptr;
-                KPrint("APIC found at \e8888FF%#lx\eCCCCCC", LAPICAddress);
-                break;
-            }
-            }
-            Memory::Virtual().Map((void *)LAPICAddress, (void *)LAPICAddress, Memory::PTFlag::RW | Memory::PTFlag::PCD); // I should map more than one page?
-        }
-        CPUCores--; // We start at 0 (BSP) and end at 11 (APs), so we have 12 cores.
-        KPrint("Total CPU cores: %d", CPUCores + 1);
-    }
-
-    MADT::~MADT()
-    {
-    }
-}
--- a/Kernel/Architecture/amd64/SystemCalls.cpp
+++ b/Kernel/Architecture/amd64/SystemCalls.cpp
@@ -1,85 +0,0 @@
-#include <syscalls.hpp>
-
-#include <cpu.hpp>
-
-#include "cpu/gdt.hpp"
-
-// https://supercip971.github.io/02-wingos-syscalls.html
-using namespace CPU::x64;
-
-// "Core/SystemCalls.cpp"
-extern "C" uint64_t SystemCallsHandler(SyscallsFrame *regs);
-
-extern "C" void SystemCallHandlerStub();
-
-extern "C" __attribute__((naked, used, no_stack_protector)) void SystemCallHandlerStub_broken()
-{
-    // asmv(
-    //     // "cmp $0x08, 0x8(%rsp)\n"
-    //     //  "je 1f\n"
-    //     "swapgs\n"
-    //     //  "1:\n"
-
-    //     "mov %rsp, 0x8(%gs)\n" // CPUData->TempStack
-    //     "mov 0x0(%gs), %rsp\n" // CPUData->SystemCallStack
-    //     "push $0x1b\n"         // user data segment
-    //     "push 0x8(%gs)\n"      // saved stack
-    //     "push %r11\n"          // saved rflags
-    //     "push $0x23\n"         // user code segment
-    //     "push %rcx\n"          // Current RIP
-
-    //     "push %rax\n"
-    //     "push %rbx\n"
-    //     "push %rcx\n"
-    //     "push %rdx\n"
-    //     "push %rsi\n"
-    //     "push %rdi\n"
-    //     "push %rbp\n"
-    //     "push %r8\n"
-    //     "push %r9\n"
-    //     "push %r10\n"
-    //     "push %r11\n"
-    //     "push %r12\n"
-    //     "push %r13\n"
-    //     "push %r14\n"
-    //     "push %r15\n"
-
-    //     "mov %rsp, %rdi\n"
-    //     "mov $0, %rbp\n"
-    //     "call SystemCallsHandler\n"
-
-    //     "pop %r15\n"
-    //     "pop %r14\n"
-    //     "pop %r13\n"
-    //     "pop %r12\n"
-    //     "pop %r11\n"
-    //     "pop %r10\n"
-    //     "pop %r9\n"
-    //     "pop %r8\n"
-    //     "pop %rbp\n"
-    //     "pop %rdi\n"
-    //     "pop %rsi\n"
-    //     "pop %rdx\n"
-    //     "pop %rcx\n"
-    //     "pop %rbx\n"
-    //     /* "pop %rax\n" */
-
-    //     "mov 0x8(%gs), %rsp\n" // CPUData->TempStack
-
-    //     //  "cmp $0x08, 0x8(%rsp)\n"
-    //     //  "je 1f\n"
-    //     "swapgs\n"
-    //     //  "1:\n"
-
-    //     "sti\n"
-
-    //     "sysretq\n");
-}
-
-void InitializeSystemCalls()
-{
-    wrmsr(MSR_EFER, rdmsr(MSR_EFER) | 1);
-    wrmsr(MSR_STAR, ((uint64_t)(GDT_KERNEL_CODE) << 32) | ((uint64_t)(GDT_KERNEL_DATA | 3) << 48));
-    wrmsr(MSR_LSTAR, (uint64_t)SystemCallHandlerStub);
-    wrmsr(MSR_SYSCALL_MASK, (uint64_t)(1 << 9));
-}
--- a/Kernel/Architecture/amd64/SystemCallsAssemblyStub.asm
+++ b/Kernel/Architecture/amd64/SystemCallsAssemblyStub.asm
@@ -1,59 +0,0 @@
-[BITS 64]
-
-%macro PushAllSC 0
-    push rax
-    push rbx
-    push rcx
-    push rdx
-    push rsi
-    push rdi
-    push rbp
-    push r8
-    push r9
-    push r10
-    push r11
-    push r12
-    push r13
-    push r14
-    push r15
-%endmacro
-
-%macro PopAllSC 0
-    pop r15
-    pop r14
-    pop r13
-    pop r12
-    pop r11
-    pop r10
-    pop r9
-    pop r8
-    pop rbp
-    pop rdi
-    pop rsi
-    pop rdx
-    pop rcx
-    pop rbx
-%endmacro
-
-ALIGN 4096
-extern SystemCallsHandler
-global SystemCallHandlerStub
-SystemCallHandlerStub:
-    swapgs                  ; Swap gs and kernelgs
-    mov [gs:0x8], rsp       ; CPUData->TempStack
-    mov rsp, [gs:0x0]       ; CPUData->SystemCallStack
-    push qword 0x1b         ; User data segment
-    push qword [gs:0x8]     ; Saved stack
-    push r11                ; Saved rflags
-    push qword 0x23         ; User code segment
-    push rcx                ; Current instruction pointer
-    cld                     ; Clear direction flag
-    PushAllSC               ; Push all registers
-    mov rdi, rsp            ; Pass pointer to registers
-    mov rbp, 0              ; Pass 0 as return address
-    call SystemCallsHandler ; Call system call handler
-    PopAllSC                ; Pop all registers except rax
-    mov rsp, [gs:0x8]       ; Restore stack
-    swapgs                  ; Swap back gs and kernelgs
-    sti                     ; Enable interrupts
-    o64 sysret              ; Return to user mode
--- a/Kernel/Architecture/amd64/acpi.hpp
+++ b/Kernel/Architecture/amd64/acpi.hpp
@@ -1,277 +0,0 @@
-#ifndef __FENNIX_KERNEL_ACPI_H__
-#define __FENNIX_KERNEL_ACPI_H__
-
-#include <types.h>
-
-#include <boot/binfo.h>
-#include <ints.hpp>
-#include <vector.hpp>
-#include <cpu.hpp>
-
-namespace ACPI
-{
-    class ACPI
-    {
-    public:
-        struct ACPIHeader
-        {
-            unsigned char Signature[4];
-            uint32_t Length;
-            uint8_t Revision;
-            uint8_t Checksum;
-            uint8_t OEMID[6];
-            uint8_t OEMTableID[8];
-            uint32_t OEMRevision;
-            uint32_t CreatorID;
-            uint32_t CreatorRevision;
-        } __attribute__((packed));
-
-        struct GenericAddressStructure
-        {
-            uint8_t AddressSpace;
-            uint8_t BitWidth;
-            uint8_t BitOffset;
-            uint8_t AccessSize;
-            uint64_t Address;
-        } __attribute__((packed));
-
-        struct MCFGHeader
-        {
-            struct ACPIHeader Header;
-            uint64_t Reserved;
-        } __attribute__((packed));
-
-        struct HPETHeader
-        {
-            ACPIHeader Header;
-            uint8_t HardwareRevID;
-            uint8_t ComparatorCount : 5;
-            uint8_t CounterSize : 1;
-            uint8_t Reserved : 1;
-            uint8_t LegacyReplacement : 1;
-            uint16_t PCIVendorID;
-            struct GenericAddressStructure Address;
-            uint8_t HPETNumber;
-            uint16_t MinimumTick;
-            uint8_t PageProtection;
-        } __attribute__((packed));
-
-        struct FADTHeader
-        {
-            ACPIHeader Header;
-            uint32_t FirmwareCtrl;
-            uint32_t Dsdt;
-            uint8_t Reserved;
-            uint8_t PreferredPowerManagementProfile;
-            uint16_t SCI_Interrupt;
-            uint32_t SMI_CommandPort;
-            uint8_t AcpiEnable;
-            uint8_t AcpiDisable;
-            uint8_t S4BIOS_REQ;
-            uint8_t PSTATE_Control;
-            uint32_t PM1aEventBlock;
-            uint32_t PM1bEventBlock;
-            uint32_t PM1aControlBlock;
-            uint32_t PM1bControlBlock;
-            uint32_t PM2ControlBlock;
-            uint32_t PMTimerBlock;
-            uint32_t GPE0Block;
-            uint32_t GPE1Block;
-            uint8_t PM1EventLength;
-            uint8_t PM1ControlLength;
-            uint8_t PM2ControlLength;
-            uint8_t PMTimerLength;
-            uint8_t GPE0Length;
-            uint8_t GPE1Length;
-            uint8_t GPE1Base;
-            uint8_t CStateControl;
-            uint16_t WorstC2Latency;
-            uint16_t WorstC3Latency;
-            uint16_t FlushSize;
-            uint16_t FlushStride;
-            uint8_t DutyOffset;
-            uint8_t DutyWidth;
-            uint8_t DayAlarm;
-            uint8_t MonthAlarm;
-            uint8_t Century;
-            uint16_t BootArchitectureFlags;
-            uint8_t Reserved2;
-            uint32_t Flags;
-            struct GenericAddressStructure ResetReg;
-            uint8_t ResetValue;
-            uint8_t Reserved3[3];
-            uint64_t X_FirmwareControl;
-            uint64_t X_Dsdt;
-            struct GenericAddressStructure X_PM1aEventBlock;
-            struct GenericAddressStructure X_PM1bEventBlock;
-            struct GenericAddressStructure X_PM1aControlBlock;
-            struct GenericAddressStructure X_PM1bControlBlock;
-            struct GenericAddressStructure X_PM2ControlBlock;
-            struct GenericAddressStructure X_PMTimerBlock;
-            struct GenericAddressStructure X_GPE0Block;
-            struct GenericAddressStructure X_GPE1Block;
-        } __attribute__((packed));
-
-        struct BGRTHeader
-        {
-            ACPIHeader Header;
-            uint16_t Version;
-            uint8_t Status;
-            uint8_t ImageType;
-            uint64_t ImageAddress;
-            uint32_t ImageOffsetX;
-            uint32_t ImageOffsetY;
-        };
-
-        struct SRATHeader
-        {
-            ACPIHeader Header;
-            uint32_t TableRevision; // Must be value 1
-            uint64_t Reserved;      // Reserved, must be zero
-        };
-
-        struct TPM2Header
-        {
-            ACPIHeader Header;
-            uint32_t Flags;
-            uint64_t ControlAddress;
-            uint32_t StartMethod;
-        };
-
-        struct TCPAHeader
-        {
-            ACPIHeader Header;
-            uint16_t Reserved;
-            uint32_t MaxLogLength;
-            uint64_t LogAddress;
-        };
-
-        struct WAETHeader
-        {
-            ACPIHeader Header;
-            uint32_t Flags;
-        };
-
-        struct HESTHeader
-        {
-            ACPIHeader Header;
-            uint32_t ErrorSourceCount;
-        };
-
-        struct MADTHeader
-        {
-            ACPIHeader Header;
-            uint32_t LocalControllerAddress;
-            uint32_t Flags;
-            char Entries[];
-        } __attribute__((packed));
-
-        ACPIHeader *XSDT = nullptr;
-        MCFGHeader *MCFG = nullptr;
-        HPETHeader *HPET = nullptr;
-        FADTHeader *FADT = nullptr;
-        BGRTHeader *BGRT = nullptr;
-        SRATHeader *SRAT = nullptr;
-        TPM2Header *TPM2 = nullptr;
-        TCPAHeader *TCPA = nullptr;
-        WAETHeader *WAET = nullptr;
-        MADTHeader *MADT = nullptr;
-        HESTHeader *HEST = nullptr;
-        bool XSDTSupported = false;
-
-        void *FindTable(ACPIHeader *ACPIHeader, char *Signature);
-        void SearchTables(ACPIHeader *Header);
-        ACPI(BootInfo *Info);
-        ~ACPI();
-    };
-
-    class MADT
-    {
-    public:
-        struct APICHeader
-        {
-            uint8_t Type;
-            uint8_t Length;
-        } __attribute__((packed));
-
-        struct MADTIOApic
-        {
-            struct APICHeader Header;
-            uint8_t APICID;
-            uint8_t reserved;
-            uint32_t Address;
-            uint32_t GSIBase;
-        } __attribute__((packed));
-
-        struct MADTIso
-        {
-            struct APICHeader Header;
-            uint8_t BuSSource;
-            uint8_t IRQSource;
-            uint32_t GSI;
-            uint16_t Flags;
-        } __attribute__((packed));
-
-        struct MADTNmi
-        {
-            struct APICHeader Header;
-            uint8_t processor;
-            uint16_t flags;
-            uint8_t lint;
-        } __attribute__((packed));
-
-        struct LocalAPIC
-        {
-            struct APICHeader Header;
-            uint8_t ACPIProcessorId;
-            uint8_t APICId;
-            uint32_t Flags;
-        } __attribute__((packed));
-
-        struct LAPIC
-        {
-            uint8_t id;
-            uintptr_t PhysicalAddress;
-            void *VirtualAddress;
-        };
-
-        Vector<MADTIOApic *> ioapic;
-        Vector<MADTIso *> iso;
-        Vector<MADTNmi *> nmi;
-        Vector<LocalAPIC *> lapic;
-        struct LAPIC *LAPICAddress;
-        uint16_t CPUCores;
-
-        MADT(ACPI::MADTHeader *madt);
-        ~MADT();
-    };
-
-    class DSDT : public Interrupts::Handler
-    {
-    private:
-        uint32_t SMI_CMD = 0;
-        uint8_t ACPI_ENABLE = 0;
-        uint8_t ACPI_DISABLE = 0;
-        uint32_t PM1a_CNT = 0;
-        uint32_t PM1b_CNT = 0;
-        uint16_t SLP_TYPa = 0;
-        uint16_t SLP_TYPb = 0;
-        uint16_t SLP_EN = 0;
-        uint16_t SCI_EN = 0;
-        uint8_t PM1_CNT_LEN = 0;
-
-        ACPI *acpi;
-        void OnInterruptReceived(CPU::x64::TrapFrame *Frame);
-
-    public:
-        bool ACPIShutdownSupported = false;
-
-        void Reboot();
-        void Shutdown();
-
-        DSDT(ACPI *acpi);
-        ~DSDT();
-    };
-}
-
-#endif // !__FENNIX_KERNEL_ACPI_H__
--- a/Kernel/Architecture/amd64/cpu/AdvancedProgrammableInterruptController.cpp
+++ b/Kernel/Architecture/amd64/cpu/AdvancedProgrammableInterruptController.cpp
@@ -1,384 +0,0 @@
-#include "apic.hpp"
-
-#include <memory.hpp>
-#include <uart.hpp>
-#include <lock.hpp>
-#include <cpu.hpp>
-#include <smp.hpp>
-#include <io.h>
-
-#include "../../../kernel.h"
-#include "../acpi.hpp"
-
-NewLock(APICLock);
-
-using namespace CPU::x64;
-using namespace CPU::x86;
-
-/*
-In constructor ‘APIC::APIC::APIC(int)’:
-warning: left shift count >= width of type
-|         APICBaseAddress = BaseStruct.ApicBaseLo << 12u | BaseStruct.ApicBaseHi << 32u;
-|                                                          ~~~~~~~~~~~~~~~~~~~~~~^~~~~~
-*/
-#pragma GCC diagnostic ignored "-Wshift-count-overflow"
-
-namespace APIC
-{
-    // headache
-    // https://www.amd.com/system/files/TechDocs/24593.pdf
-    // https://www.naic.edu/~phil/software/intel/318148.pdf
-
-    uint32_t APIC::Read(uint32_t Register)
-    {
-        if (Register != APIC_ICRLO &&
-            Register != APIC_ICRHI &&
-            Register != APIC_ID)
-            debug("APIC::Read(%#lx) [x2=%d]", Register, x2APICSupported ? 1 : 0);
-        if (x2APICSupported)
-        {
-            if (Register != APIC_ICRHI)
-                return rdmsr((Register >> 4) + 0x800);
-            else
-                return rdmsr(0x30 + 0x800);
-        }
-        else
-        {
-            CPU::MemBar::Barrier();
-            uint32_t ret = *((volatile uint32_t *)((uintptr_t)APICBaseAddress + Register));
-            CPU::MemBar::Barrier();
-            return ret;
-        }
-    }
-
-    void APIC::Write(uint32_t Register, uint32_t Value)
-    {
-        if (Register != APIC_EOI &&
-            Register != APIC_TDCR &&
-            Register != APIC_TIMER &&
-            Register != APIC_TICR &&
-            Register != APIC_ICRLO &&
-            Register != APIC_ICRHI)
-            debug("APIC::Write(%#lx, %#lx) [x2=%d]", Register, Value, x2APICSupported ? 1 : 0);
-        if (x2APICSupported)
-        {
-            if (Register != APIC_ICRHI)
-                wrmsr((Register >> 4) + 0x800, Value);
-            else
-                wrmsr(MSR_X2APIC_ICR, Value);
-        }
-        else
-        {
-            CPU::MemBar::Barrier();
-            *((volatile uint32_t *)(((uintptr_t)APICBaseAddress) + Register)) = Value;
-            CPU::MemBar::Barrier();
-        }
-    }
-
-    void APIC::IOWrite(uint64_t Base, uint32_t Register, uint32_t Value)
-    {
-        debug("APIC::IOWrite(%#lx, %#lx, %#lx)", Base, Register, Value);
-        CPU::MemBar::Barrier();
-        *((volatile uint32_t *)(((uintptr_t)Base))) = Register;
-        CPU::MemBar::Barrier();
-        *((volatile uint32_t *)(((uintptr_t)Base + 16))) = Value;
-        CPU::MemBar::Barrier();
-    }
-
-    uint32_t APIC::IORead(uint64_t Base, uint32_t Register)
-    {
-        debug("APIC::IORead(%#lx, %#lx)", Base, Register);
-        CPU::MemBar::Barrier();
-        *((volatile uint32_t *)(((uintptr_t)Base))) = Register;
-        CPU::MemBar::Barrier();
-        uint32_t ret = *((volatile uint32_t *)(((uintptr_t)Base + 16)));
-        CPU::MemBar::Barrier();
-        return ret;
-    }
-
-    void APIC::EOI() { this->Write(APIC_EOI, 0); }
-
-    void APIC::WaitForIPI()
-    {
-        InterruptCommandRegisterLow icr = {.raw = 0};
-        do
-        {
-            icr.raw = this->Read(APIC_ICRLO);
-        } while (icr.DeliveryStatus != Idle);
-    }
-
-    void APIC::IPI(uint8_t CPU, InterruptCommandRegisterLow icr)
-    {
-        SmartCriticalSection(APICLock);
-        if (x2APICSupported)
-        {
-            fixme("Not implemented for x2APIC");
-            // wrmsr(MSR_X2APIC_ICR, ((uint64_t)CPU) << 32);
-        }
-        else
-        {
-            this->Write(APIC_ICRHI, (CPU << 24));
-            this->Write(APIC_ICRLO, icr.raw);
-            this->WaitForIPI();
-        }
-    }
-
-    void APIC::SendInitIPI(uint8_t CPU)
-    {
-        SmartCriticalSection(APICLock);
-        if (x2APICSupported)
-        {
-            fixme("Not implemented for x2APIC");
-            // wrmsr(MSR_X2APIC_ICR, ((uint64_t)CPU) << 32);
-        }
-        else
-        {
-            InterruptCommandRegisterLow icr = {.raw = 0};
-            icr.DeliveryMode = INIT;
-            icr.Level = Assert;
-            this->Write(APIC_ICRHI, (CPU << 24));
-            this->Write(APIC_ICRLO, icr.raw);
-            this->WaitForIPI();
-        }
-    }
-
-    void APIC::SendStartupIPI(uint8_t CPU, uint64_t StartupAddress)
-    {
-        SmartCriticalSection(APICLock);
-        if (x2APICSupported)
-        {
-            warn("Not tested for x2APIC");
-            wrmsr(MSR_X2APIC_ICR, ((uint64_t)CPU) << 32 | StartupAddress);
-        }
-        else
-        {
-            InterruptCommandRegisterLow icr = {.raw = 0};
-            icr.Vector = StartupAddress >> 12;
-            icr.DeliveryMode = Startup;
-            icr.Level = Assert;
-            this->Write(APIC_ICRHI, (CPU << 24));
-            this->Write(APIC_ICRLO, icr.raw);
-            this->WaitForIPI();
-        }
-    }
-
-    uint32_t APIC::IOGetMaxRedirect(uint32_t APICID)
-    {
-        uint32_t TableAddress = (this->IORead((((ACPI::MADT *)PowerManager->GetMADT())->ioapic[APICID]->Address), GetIOAPICVersion));
-        return ((IOAPICVersion *)&TableAddress)->MaximumRedirectionEntry;
-    }
-
-    void APIC::RawRedirectIRQ(uint8_t Vector, uint32_t GSI, uint16_t Flags, int CPU, int Status)
-    {
-        uint64_t Value = Vector;
-
-        int64_t IOAPICTarget = -1;
-        for (uint64_t i = 0; ((ACPI::MADT *)PowerManager->GetMADT())->ioapic[i] != 0; i++)
-            if (((ACPI::MADT *)PowerManager->GetMADT())->ioapic[i]->GSIBase <= GSI)
-                if (((ACPI::MADT *)PowerManager->GetMADT())->ioapic[i]->GSIBase + IOGetMaxRedirect(i) > GSI)
-                {
-                    IOAPICTarget = i;
-                    break;
-                }
-
-        if (IOAPICTarget == -1)
-        {
-            error("No ISO table found for I/O APIC");
-            return;
-        }
-
-        // TODO: IOAPICRedirectEntry Entry = {.raw = 0};
-
-        if (Flags & ActiveHighLow)
-            Value |= (1 << 13);
-
-        if (Flags & EdgeLevel)
-            Value |= (1 << 15);
-
-        if (!Status)
-            Value |= (1 << 16);
-
-        Value |= (((uintptr_t)CPU) << 56);
-        uint32_t IORegister = (GSI - ((ACPI::MADT *)PowerManager->GetMADT())->ioapic[IOAPICTarget]->GSIBase) * 2 + 16;
-
-        this->IOWrite(((ACPI::MADT *)PowerManager->GetMADT())->ioapic[IOAPICTarget]->Address, IORegister, (uint32_t)Value);
-        this->IOWrite(((ACPI::MADT *)PowerManager->GetMADT())->ioapic[IOAPICTarget]->Address, IORegister + 1, (uint32_t)(Value >> 32));
-    }
-
-    void APIC::RedirectIRQ(int CPU, uint8_t IRQ, int Status)
-    {
-        for (uint64_t i = 0; i < ((ACPI::MADT *)PowerManager->GetMADT())->iso.size(); i++)
-            if (((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->IRQSource == IRQ)
-            {
-                debug("[ISO %d] Mapping to source IRQ%#d GSI:%#lx on CPU %d",
-                      i, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->IRQSource, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->GSI, CPU);
-
-                this->RawRedirectIRQ(((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->IRQSource + 0x20, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->GSI, ((ACPI::MADT *)PowerManager->GetMADT())->iso[i]->Flags, CPU, Status);
-                return;
-            }
-        debug("Mapping IRQ%d on CPU %d", IRQ, CPU);
-        this->RawRedirectIRQ(IRQ + 0x20, IRQ, 0, CPU, Status);
-    }
-
-    void APIC::RedirectIRQs(int CPU)
-    {
-        SmartCriticalSection(APICLock);
-        debug("Redirecting IRQs...");
-        for (int i = 0; i < 16; i++)
-            this->RedirectIRQ(CPU, i, 1);
-        debug("Redirecting IRQs completed.");
-    }
-
-    APIC::APIC(int Core)
-    {
-        SmartCriticalSection(APICLock);
-        APIC_BASE BaseStruct = {.raw = rdmsr(MSR_APIC_BASE)};
-        uint64_t BaseLow = BaseStruct.ApicBaseLo;
-        uint64_t BaseHigh = BaseStruct.ApicBaseHi;
-        this->APICBaseAddress = BaseLow << 12u | BaseHigh << 32u;
-        trace("APIC Address: %#lx", this->APICBaseAddress);
-
-        bool x2APICSupported = false;
-        if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_AMD) == 0)
-        {
-#if defined(a64)
-            CPU::x64::AMD::CPUID0x1 cpuid1amd;
-#elif defined(a32)
-            CPU::x32::AMD::CPUID0x1 cpuid1amd;
-#endif
-#if defined(a64) || defined(a32)
-            asmv("cpuid"
-                 : "=a"(cpuid1amd.EAX.raw), "=b"(cpuid1amd.EBX.raw), "=c"(cpuid1amd.ECX.raw), "=d"(cpuid1amd.EDX.raw)
-                 : "a"(0x1));
-#endif
-            // FIXME: Not sure if I configured this correctly or something else is wrong
-            // x2APICSupported = cpuid1amd.ECX.x2APIC;
-            fixme("AMD does even support x2APIC? ECX->Reserved10: %#lx", cpuid1amd.ECX.Reserved10);
-        }
-        else if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_INTEL) == 0)
-        {
-#if defined(a64)
-            CPU::x64::Intel::CPUID0x1 cpuid1intel;
-#elif defined(a32)
-            CPU::x32::Intel::CPUID0x1 cpuid1intel;
-#endif
-#if defined(a64) || defined(a32)
-            asmv("cpuid"
-                 : "=a"(cpuid1intel.EAX.raw), "=b"(cpuid1intel.EBX.raw), "=c"(cpuid1intel.ECX.raw), "=d"(cpuid1intel.EDX.raw)
-                 : "a"(0x1));
-#endif
-            x2APICSupported = cpuid1intel.ECX.x2APIC;
-        }
-
-        if (x2APICSupported)
-        {
-            this->x2APICSupported = true;
-            wrmsr(MSR_APIC_BASE, (rdmsr(MSR_APIC_BASE) | (1 << 11)) & ~(1 << 10));
-            BaseStruct.EN = 1;
-            wrmsr(MSR_APIC_BASE, BaseStruct.raw);
-        }
-        else
-        {
-            BaseStruct.EN = 1;
-            wrmsr(MSR_APIC_BASE, BaseStruct.raw);
-        }
-
-        this->Write(APIC_TPR, 0x0);
-        // this->Write(APIC_SVR, this->Read(APIC_SVR) | 0x100); // 0x1FF or 0x100 ? on https://wiki.osdev.org/APIC is 0x100
-
-        if (!this->x2APICSupported)
-        {
-            this->Write(APIC_DFR, 0xF0000000);
-            this->Write(APIC_LDR, this->Read(APIC_ID));
-        }
-
-        ACPI::MADT *madt = (ACPI::MADT *)PowerManager->GetMADT();
-
-        for (size_t i = 0; i < madt->nmi.size(); i++)
-        {
-            if (madt->nmi[i]->processor != 0xFF && Core != madt->nmi[i]->processor)
-                return;
-
-            uint32_t nmi = 0x402;
-            if (madt->nmi[i]->flags & 2)
-                nmi |= 1 << 13;
-            if (madt->nmi[i]->flags & 8)
-                nmi |= 1 << 15;
-            if (madt->nmi[i]->lint == 0)
-                this->Write(APIC_LINT0, nmi);
-            else if (madt->nmi[i]->lint == 1)
-                this->Write(APIC_LINT1, nmi);
-        }
-
-        // Setup the spurrious interrupt vector
-        Spurious Spurious = {.raw = this->Read(APIC_SVR)};
-        Spurious.Vector = IRQ223; // TODO: Should I map the IRQ to something?
-        Spurious.Software = 1;
-        this->Write(APIC_SVR, Spurious.raw);
-
-        static int once = 0;
-        if (!once++)
-        {
-            // Disable PIT
-            outb(0x43, 0x28);
-            outb(0x40, 0x0);
-
-            // Disable PIC
-            outb(0x21, 0xFF);
-            outb(0xA1, 0xFF);
-        }
-    }
-
-    APIC::~APIC() {}
-
-    void Timer::OnInterruptReceived(TrapFrame *Frame) { UNUSED(Frame); }
-
-    void Timer::OneShot(uint32_t Vector, uint64_t Miliseconds)
-    {
-        SmartCriticalSection(APICLock);
-        LVTTimer timer = {.raw = 0};
-        timer.Vector = Vector;
-        timer.TimerMode = 0;
-        if (strcmp(CPU::Hypervisor(), x86_CPUID_VENDOR_TCG) != 0)
-            this->lapic->Write(APIC_TDCR, DivideBy128);
-        else
-            this->lapic->Write(APIC_TDCR, DivideBy16);
-        this->lapic->Write(APIC_TICR, Ticks * Miliseconds);
-        this->lapic->Write(APIC_TIMER, timer.raw);
-    }
-
-    Timer::Timer(APIC *apic) : Interrupts::Handler(IRQ0)
-    {
-        SmartCriticalSection(APICLock);
-        this->lapic = apic;
-        LVTTimerDivide Divider = DivideBy16;
-
-        trace("Initializing APIC timer on CPU %d", GetCurrentCPU()->ID);
-
-        this->lapic->Write(APIC_TDCR, Divider);
-        this->lapic->Write(APIC_TICR, 0xFFFFFFFF);
-
-        TimeManager->Sleep(1);
-
-        // Mask the timer
-        this->lapic->Write(APIC_TIMER, 0x10000 /* LVTTimer.Mask flag */);
-        Ticks = 0xFFFFFFFF - this->lapic->Read(APIC_TCCR);
-
-        // Config for IRQ0 timer
-        LVTTimer timer = {.raw = 0};
-        timer.Vector = IRQ0;
-        timer.Mask = Unmasked;
-        timer.TimerMode = LVTTimerMode::OneShot;
-
-        // Initialize APIC timer
-        this->lapic->Write(APIC_TDCR, Divider);
-        this->lapic->Write(APIC_TICR, Ticks);
-        this->lapic->Write(APIC_TIMER, timer.raw);
-        trace("%d APIC Timer %d ticks in.", GetCurrentCPU()->ID, Ticks);
-        KPrint("APIC Timer: \e8888FF%ld\eCCCCCC ticks.", Ticks);
-    }
-
-    Timer::~Timer()
-    {
-    }
-}
--- a/Kernel/Architecture/amd64/cpu/GlobalDescriptorTable.cpp
+++ b/Kernel/Architecture/amd64/cpu/GlobalDescriptorTable.cpp
@@ -1,164 +0,0 @@
-#include "gdt.hpp"
-
-#include <memory.hpp>
-#include <smp.hpp>
-#include <cpu.hpp>
-#include <debug.h>
-
-namespace GlobalDescriptorTable
-{
-    static GlobalDescriptorTableEntries GDTEntriesTemplate = {
-        // null
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.Raw = 0x0},
-         .Flags = {.Raw = 0x0},
-         .BaseHigh = 0x0},
-
-        // kernel code
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 1,
-                    .S = 1,
-                    .DPL = 0,
-                    .P = 1},
-         .Flags = {.Unknown = 0x0, .L = 1},
-         .BaseHigh = 0x0},
-
-        // kernel data
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 0,
-                    .S = 1,
-                    .DPL = 0,
-                    .P = 1},
-         .Flags = {.Raw = 0x0},
-         .BaseHigh = 0x0},
-
-        // user data
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 0,
-                    .S = 1,
-                    .DPL = 3,
-                    .P = 1},
-         .Flags = {.Raw = 0x0},
-         .BaseHigh = 0x0},
-
-        // user code
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 1,
-                    .S = 1,
-                    .DPL = 3,
-                    .P = 1},
-         .Flags = {.Unknown = 0x0, .L = 1},
-         .BaseHigh = 0x0},
-
-        // tss
-        {}};
-
-    GlobalDescriptorTableEntries GDTEntries[MAX_CPU];
-    GlobalDescriptorTableDescriptor gdt[MAX_CPU];
-
-    TaskStateSegment tss[MAX_CPU] = {
-        0,
-        {0, 0, 0},
-        0,
-        {0, 0, 0, 0, 0, 0, 0},
-        0,
-        0,
-        0,
-    };
-
-    void *CPUStackPointer[MAX_CPU];
-
-    SafeFunction void Init(int Core)
-    {
-        memcpy(&GDTEntries[Core], &GDTEntriesTemplate, sizeof(GlobalDescriptorTableEntries));
-        gdt[Core] = {.Length = sizeof(GlobalDescriptorTableEntries) - 1, .Entries = &GDTEntries[Core]};
-
-        debug("Kernel: Code Access: %ld; Data Access: %ld", GDTEntries[Core].Code.Access.Raw, GDTEntries[Core].Data.Access.Raw);
-        debug("Kernel: Code Flags: %ld; Data Flags: %ld", GDTEntries[Core].Code.Flags.Raw, GDTEntries[Core].Data.Flags.Raw);
-        debug("User: Code Access: %ld; Data Access: %ld", GDTEntries[Core].UserCode.Access.Raw, GDTEntries[Core].UserData.Access.Raw);
-        debug("User: Code Flags: %ld; Data Flags: %ld", GDTEntries[Core].UserCode.Flags.Raw, GDTEntries[Core].UserData.Flags.Raw);
-        CPU::x64::lgdt(&gdt[Core]);
-
-        asmv("movq %%rsp, %%rax\n"
-             "pushq $16\n"
-             "pushq %%rax\n"
-             "pushfq\n"
-             "pushq $8\n"
-             "pushq $1f\n"
-             "iretq\n"
-             "1:\n"
-             "movw $16, %%ax\n"
-             "movw %%ax, %%ds\n"
-             "movw %%ax, %%es\n" ::
-                 : "memory", "rax");
-
-        CPUStackPointer[Core] = KernelAllocator.RequestPages(TO_PAGES(STACK_SIZE));
-        memset(CPUStackPointer[Core], 0, STACK_SIZE);
-        debug("CPU %d Stack Pointer: %#lx", Core, CPUStackPointer[Core]);
-
-        uint64_t Base = (uint64_t)&tss[Core];
-        uint64_t Limit = Base + sizeof(TaskStateSegment);
-        gdt[Core].Entries->TaskStateSegment.Length = Limit & 0xFFFF;
-        gdt[Core].Entries->TaskStateSegment.BaseLow = Base & 0xFFFF;
-        gdt[Core].Entries->TaskStateSegment.BaseMiddle = (Base >> 16) & 0xFF;
-        gdt[Core].Entries->TaskStateSegment.BaseHigh = (Base >> 24) & 0xFF;
-        gdt[Core].Entries->TaskStateSegment.BaseUpper = (Base >> 32) & 0xFFFFFFFF;
-        gdt[Core].Entries->TaskStateSegment.Flags = {.A = 1, .RW = 0, .DC = 0, .E = 1, .S = 0, .DPL = 0, .P = 1};
-        gdt[Core].Entries->TaskStateSegment.Granularity = (0 << 4) | ((Limit >> 16) & 0xF);
-
-        tss[Core].IOMapBaseAddressOffset = sizeof(TaskStateSegment);
-        tss[Core].StackPointer[0] = (uint64_t)CPUStackPointer[Core] + STACK_SIZE;
-        tss[Core].InterruptStackTable[0] = (uint64_t)KernelAllocator.RequestPages(TO_PAGES(STACK_SIZE)) + STACK_SIZE;
-        tss[Core].InterruptStackTable[1] = (uint64_t)KernelAllocator.RequestPages(TO_PAGES(STACK_SIZE)) + STACK_SIZE;
-        tss[Core].InterruptStackTable[2] = (uint64_t)KernelAllocator.RequestPages(TO_PAGES(STACK_SIZE)) + STACK_SIZE;
-        memset((void *)(tss[Core].InterruptStackTable[0] - STACK_SIZE), 0, STACK_SIZE);
-        memset((void *)(tss[Core].InterruptStackTable[1] - STACK_SIZE), 0, STACK_SIZE);
-        memset((void *)(tss[Core].InterruptStackTable[2] - STACK_SIZE), 0, STACK_SIZE);
-
-        CPU::x64::ltr(GDT_TSS);
-        asmv("mov %%rsp, %0"
-             : "=r"(tss[Core].StackPointer[0]));
-
-        debug("GDT_KERNEL_CODE: %#lx", GDT_KERNEL_CODE);
-        debug("GDT_KERNEL_DATA: %#lx", GDT_KERNEL_DATA);
-        debug("GDT_USER_CODE: %#lx", GDT_USER_CODE);
-        debug("GDT_USER_DATA: %#lx", GDT_USER_DATA);
-        debug("GDT_TSS: %#lx", GDT_TSS);
-        debug("Global Descriptor Table initialized");
-    }
-
-    SafeFunction void SetKernelStack(void *Stack)
-    {
-        long CPUID = GetCurrentCPU()->ID;
-        if (Stack != nullptr)
-            tss[CPUID].StackPointer[0] = (uint64_t)Stack;
-        else
-            tss[CPUID].StackPointer[0] = (uint64_t)CPUStackPointer[CPUID] + STACK_SIZE;
-
-        // TODO: This may cause problems in the future I guess? This should be checked later
-        asmv("mov %%rsp, %0"
-             : "=r"(tss[CPUID].StackPointer[0]));
-    }
-}
--- a/Kernel/Architecture/amd64/cpu/InterruptDescriptorTable.cpp
+++ b/Kernel/Architecture/amd64/cpu/InterruptDescriptorTable.cpp
@@ -1,790 +0,0 @@
-#include "idt.hpp"
-
-#include <memory.hpp>
-#include <cpu.hpp>
-#include <debug.h>
-#include <io.h>
-
-#include "gdt.hpp"
-
-extern "C" void MainInterruptHandler(void *Data);
-extern "C" void ExceptionHandler(void *Data);
-
-namespace InterruptDescriptorTable
-{
-    static InterruptDescriptorTableEntry Entries[0x100];
-
-    InterruptDescriptorTableDescriptor idtd = {.Length = sizeof(Entries) - 1,
-                                               .Entries = Entries};
-
-    void SetEntry(uint8_t Index,
-                  void (*Base)(),
-                  InterruptDescriptorTableFlags Attribute,
-                  uint8_t InterruptStackTable,
-                  InterruptDescriptorTableFlags Ring,
-                  uint16_t SegmentSelector)
-    {
-        Entries[Index].BaseLow = (uint16_t)((uint64_t)Base & 0xFFFF);
-        Entries[Index].BaseHigh = (uint64_t)((uint64_t)Base >> 16 /* & 0xFFFF */);
-        Entries[Index].SegmentSelector = SegmentSelector;
-        Entries[Index].Flags = Attribute;
-        Entries[Index].Reserved1 = 0;
-        Entries[Index].Reserved2 = 0;
-        Entries[Index].Reserved3 = 0;
-        Entries[Index].InterruptStackTable = InterruptStackTable;
-        Entries[Index].Ring = Ring;
-        Entries[Index].Present = 1;
-    }
-
-    extern "C" __attribute__((naked, used, no_stack_protector)) void ExceptionHandlerStub()
-    {
-        asm(
-            // "cmp $0x1000, %rsp\n"    // Just in case the stack is corrupted
-            // "jng .skip_swap_check_1\n" /* if is not greater than */
-            // "cmpw $0x8, 0x8(%rsp)\n"
-            // "je .skip_swap_check_1\n"
-            // "swapgs\n"
-            // ".skip_swap_check_1:\n"
-
-            "cld\n" // clear direction flag
-
-            // push all registers
-            "pushq %rax\n"
-            "pushq %rbx\n"
-            "pushq %rcx\n"
-            "pushq %rdx\n"
-            "pushq %rsi\n"
-            "pushq %rdi\n"
-            "pushq %rbp\n"
-            "pushq %r8\n"
-            "pushq %r9\n"
-            "pushq %r10\n"
-            "pushq %r11\n"
-            "pushq %r12\n"
-            "pushq %r13\n"
-            "pushq %r14\n"
-            "pushq %r15\n"
-
-            "movq %rsp, %rdi\n"
-            "call ExceptionHandler\n"
-
-            // pop all registers
-            "popq %r15\n"
-            "popq %r14\n"
-            "popq %r13\n"
-            "popq %r12\n"
-            "popq %r11\n"
-            "popq %r10\n"
-            "popq %r9\n"
-            "popq %r8\n"
-            "popq %rbp\n"
-            "popq %rdi\n"
-            "popq %rsi\n"
-            "popq %rdx\n"
-            "popq %rcx\n"
-            "popq %rbx\n"
-            "popq %rax\n"
-
-            "addq $16, %rsp\n"
-
-            // "cmp $0x1000, %rsp\n"
-            // "jng .skip_swap_check_2\n"
-            // "cmpw $0x8, 0x8(%rsp)\n"
-            // "je .skip_swap_check_2\n"
-            // "swapgs\n"
-            // ".skip_swap_check_2:\n"
-
-            "iretq"); // pop CS RIP RFLAGS SS RSP
-    }
-
-    extern "C" void WarnSwapgs() { warn("swapgs"); }
-
-    // void *OriginalCR3;
-    extern "C" __attribute__((naked, used, no_stack_protector)) void InterruptHandlerStub()
-    {
-        // // Store cr3 to OriginalCR3
-        // asmv("mov %%cr3, %0"
-        //      : "=q"(OriginalCR3)
-        //      :
-        //      : "memory");
-        // // Set cr3 to KPT (Kernel Page Table)
-        // asmv("mov %0, %%cr3"
-        //      :
-        //      : "q"(KPT)
-        //      : "memory");
-
-        // GlobalDescriptorTable::SetKernelStack(nullptr);
-
-        asm(
-            // "cmp $0x1000, %rsp\n"
-            // "jng .skip_swap_check__1\n"
-            // "cmpw $0x8, 0x8(%rsp)\n"
-            // "je .skip_swap_check__1\n"
-            // "swapgs\n"
-            // "call WarnSwapgs\n"
-            // ".skip_swap_check__1:\n"
-
-            "cld\n"
-            "pushq %rax\n"
-            "pushq %rbx\n"
-            "pushq %rcx\n"
-            "pushq %rdx\n"
-            "pushq %rsi\n"
-            "pushq %rdi\n"
-            "pushq %rbp\n"
-            "pushq %r8\n"
-            "pushq %r9\n"
-            "pushq %r10\n"
-            "pushq %r11\n"
-            "pushq %r12\n"
-            "pushq %r13\n"
-            "pushq %r14\n"
-            "pushq %r15\n"
-
-            "movq %rsp, %rdi\n"
-            "call MainInterruptHandler\n");
-
-        // // Check if the current cr3 is the same as the KPT
-        // // If not, then we need to restore the cr3
-        // asmv("pushq %rax\n"        // push rax
-        //      "pushq %rbx\n"        // push rbx
-        //      "movq %cr3, %rbx\n"); // mov cr3 to rbx
-        // asmv("movq %0, %%rax\n"    // mov KPT to rax
-        //      :
-        //      : "q"(KPT)
-        //      : "memory");
-        // asmv("cmpq %rax, %rbx\n"         // compare cr3 to rax
-        //      "jne .skip_restore_cr3\n"); // if not equal, skip restore cr3
-        // asmv("movq %0, %%cr3\n" // restore cr3
-        //      :
-        //      : "q"(OriginalCR3)
-        //      : "memory");
-        // asm(".skip_restore_cr3:\n" // skip restore cr3 label
-        //     "popq %rax\n"          // KPT
-        //     "popq %rbx\n");        // cr3
-
-        asm("popq %r15\n"
-            "popq %r14\n"
-            "popq %r13\n"
-            "popq %r12\n"
-            "popq %r11\n"
-            "popq %r10\n"
-            "popq %r9\n"
-            "popq %r8\n"
-            "popq %rbp\n"
-            "popq %rdi\n"
-            "popq %rsi\n"
-            "popq %rdx\n"
-            "popq %rcx\n"
-            "popq %rbx\n"
-            "popq %rax\n"
-
-            "addq $16, %rsp\n"
-
-            // "cmp $0x1000, %rsp\n"
-            // "jng .skip_swap_check__2\n"
-            // "cmpw $0x8, 0x8(%rsp)\n"
-            // "je .skip_swap_check__2\n"
-            // "call WarnSwapgs\n"
-            // "swapgs\n"
-            // ".skip_swap_check__2:\n"
-
-            "iretq");
-    }
-
-#pragma region Exceptions
-
-#define EXCEPTION_HANDLER(num)                                                      \
-    __attribute__((naked, no_stack_protector)) static void InterruptHandler_##num() \
-    {                                                                               \
-        asm("pushq $0\npushq $" #num "\n"                                           \
-            "jmp ExceptionHandlerStub");                                            \
-    }
-
-#define EXCEPTION_ERROR_HANDLER(num)                                                \
-    __attribute__((naked, no_stack_protector)) static void InterruptHandler_##num() \
-    {                                                                               \
-        asm("pushq $" #num "\n"                                                     \
-            "jmp ExceptionHandlerStub");                                            \
-    }
-
-#define INTERRUPT_HANDLER(num)                                                     \
-    __attribute__((naked, used, no_stack_protector)) void InterruptHandler_##num() \
-    {                                                                              \
-        asm("pushq $0\npushq $" #num "\n"                                          \
-            "jmp InterruptHandlerStub\n");                                         \
-    }
-
-    /* ISR */
-
-    EXCEPTION_HANDLER(0x0);
-    EXCEPTION_HANDLER(0x1);
-    EXCEPTION_HANDLER(0x2);
-    EXCEPTION_HANDLER(0x3);
-    EXCEPTION_HANDLER(0x4);
-    EXCEPTION_HANDLER(0x5);
-    EXCEPTION_HANDLER(0x6);
-    EXCEPTION_HANDLER(0x7);
-    EXCEPTION_ERROR_HANDLER(0x8);
-    EXCEPTION_HANDLER(0x9);
-    EXCEPTION_ERROR_HANDLER(0xa);
-    EXCEPTION_ERROR_HANDLER(0xb);
-    EXCEPTION_ERROR_HANDLER(0xc);
-    EXCEPTION_ERROR_HANDLER(0xd);
-    EXCEPTION_ERROR_HANDLER(0xe);
-    EXCEPTION_HANDLER(0xf);
-    EXCEPTION_ERROR_HANDLER(0x10);
-    EXCEPTION_HANDLER(0x11);
-    EXCEPTION_HANDLER(0x12);
-    EXCEPTION_HANDLER(0x13);
-    EXCEPTION_HANDLER(0x14);
-    EXCEPTION_HANDLER(0x15);
-    EXCEPTION_HANDLER(0x16);
-    EXCEPTION_HANDLER(0x17);
-    EXCEPTION_HANDLER(0x18);
-    EXCEPTION_HANDLER(0x19);
-    EXCEPTION_HANDLER(0x1a);
-    EXCEPTION_HANDLER(0x1b);
-    EXCEPTION_HANDLER(0x1c);
-    EXCEPTION_HANDLER(0x1d);
-    EXCEPTION_HANDLER(0x1e);
-    EXCEPTION_HANDLER(0x1f);
-
-    /* IRQ */
-
-    INTERRUPT_HANDLER(0x20)
-    INTERRUPT_HANDLER(0x21)
-    INTERRUPT_HANDLER(0x22)
-    INTERRUPT_HANDLER(0x23)
-    INTERRUPT_HANDLER(0x24)
-    INTERRUPT_HANDLER(0x25)
-    INTERRUPT_HANDLER(0x26)
-    INTERRUPT_HANDLER(0x27)
-    INTERRUPT_HANDLER(0x28)
-    INTERRUPT_HANDLER(0x29)
-    INTERRUPT_HANDLER(0x2a)
-    INTERRUPT_HANDLER(0x2b)
-    INTERRUPT_HANDLER(0x2c)
-    INTERRUPT_HANDLER(0x2d)
-    INTERRUPT_HANDLER(0x2e)
-    INTERRUPT_HANDLER(0x2f)
-
-    /* Reserved by OS */
-
-    INTERRUPT_HANDLER(0x30)
-    INTERRUPT_HANDLER(0x31)
-    INTERRUPT_HANDLER(0x32)
-    INTERRUPT_HANDLER(0x33)
-    INTERRUPT_HANDLER(0x34)
-    INTERRUPT_HANDLER(0x35)
-    INTERRUPT_HANDLER(0x36)
-    INTERRUPT_HANDLER(0x37)
-    INTERRUPT_HANDLER(0x38)
-    INTERRUPT_HANDLER(0x39)
-    INTERRUPT_HANDLER(0x3a)
-    INTERRUPT_HANDLER(0x3b)
-    INTERRUPT_HANDLER(0x3c)
-    INTERRUPT_HANDLER(0x3d)
-
-    /* Free */
-
-    INTERRUPT_HANDLER(0x3e)
-    INTERRUPT_HANDLER(0x3f)
-    INTERRUPT_HANDLER(0x40)
-    INTERRUPT_HANDLER(0x41)
-    INTERRUPT_HANDLER(0x42)
-    INTERRUPT_HANDLER(0x43)
-    INTERRUPT_HANDLER(0x44)
-    INTERRUPT_HANDLER(0x45)
-    INTERRUPT_HANDLER(0x46)
-    INTERRUPT_HANDLER(0x47)
-    INTERRUPT_HANDLER(0x48)
-    INTERRUPT_HANDLER(0x49)
-    INTERRUPT_HANDLER(0x4a)
-    INTERRUPT_HANDLER(0x4b)
-    INTERRUPT_HANDLER(0x4c)
-    INTERRUPT_HANDLER(0x4d)
-    INTERRUPT_HANDLER(0x4e)
-    INTERRUPT_HANDLER(0x4f)
-    INTERRUPT_HANDLER(0x50)
-    INTERRUPT_HANDLER(0x51)
-    INTERRUPT_HANDLER(0x52)
-    INTERRUPT_HANDLER(0x53)
-    INTERRUPT_HANDLER(0x54)
-    INTERRUPT_HANDLER(0x55)
-    INTERRUPT_HANDLER(0x56)
-    INTERRUPT_HANDLER(0x57)
-    INTERRUPT_HANDLER(0x58)
-    INTERRUPT_HANDLER(0x59)
-    INTERRUPT_HANDLER(0x5a)
-    INTERRUPT_HANDLER(0x5b)
-    INTERRUPT_HANDLER(0x5c)
-    INTERRUPT_HANDLER(0x5d)
-    INTERRUPT_HANDLER(0x5e)
-    INTERRUPT_HANDLER(0x5f)
-    INTERRUPT_HANDLER(0x60)
-    INTERRUPT_HANDLER(0x61)
-    INTERRUPT_HANDLER(0x62)
-    INTERRUPT_HANDLER(0x63)
-    INTERRUPT_HANDLER(0x64)
-    INTERRUPT_HANDLER(0x65)
-    INTERRUPT_HANDLER(0x66)
-    INTERRUPT_HANDLER(0x67)
-    INTERRUPT_HANDLER(0x68)
-    INTERRUPT_HANDLER(0x69)
-    INTERRUPT_HANDLER(0x6a)
-    INTERRUPT_HANDLER(0x6b)
-    INTERRUPT_HANDLER(0x6c)
-    INTERRUPT_HANDLER(0x6d)
-    INTERRUPT_HANDLER(0x6e)
-    INTERRUPT_HANDLER(0x6f)
-    INTERRUPT_HANDLER(0x70)
-    INTERRUPT_HANDLER(0x71)
-    INTERRUPT_HANDLER(0x72)
-    INTERRUPT_HANDLER(0x73)
-    INTERRUPT_HANDLER(0x74)
-    INTERRUPT_HANDLER(0x75)
-    INTERRUPT_HANDLER(0x76)
-    INTERRUPT_HANDLER(0x77)
-    INTERRUPT_HANDLER(0x78)
-    INTERRUPT_HANDLER(0x79)
-    INTERRUPT_HANDLER(0x7a)
-    INTERRUPT_HANDLER(0x7b)
-    INTERRUPT_HANDLER(0x7c)
-    INTERRUPT_HANDLER(0x7d)
-    INTERRUPT_HANDLER(0x7e)
-    INTERRUPT_HANDLER(0x7f)
-    INTERRUPT_HANDLER(0x80)
-    INTERRUPT_HANDLER(0x81)
-    INTERRUPT_HANDLER(0x82)
-    INTERRUPT_HANDLER(0x83)
-    INTERRUPT_HANDLER(0x84)
-    INTERRUPT_HANDLER(0x85)
-    INTERRUPT_HANDLER(0x86)
-    INTERRUPT_HANDLER(0x87)
-    INTERRUPT_HANDLER(0x88)
-    INTERRUPT_HANDLER(0x89)
-    INTERRUPT_HANDLER(0x8a)
-    INTERRUPT_HANDLER(0x8b)
-    INTERRUPT_HANDLER(0x8c)
-    INTERRUPT_HANDLER(0x8d)
-    INTERRUPT_HANDLER(0x8e)
-    INTERRUPT_HANDLER(0x8f)
-    INTERRUPT_HANDLER(0x90)
-    INTERRUPT_HANDLER(0x91)
-    INTERRUPT_HANDLER(0x92)
-    INTERRUPT_HANDLER(0x93)
-    INTERRUPT_HANDLER(0x94)
-    INTERRUPT_HANDLER(0x95)
-    INTERRUPT_HANDLER(0x96)
-    INTERRUPT_HANDLER(0x97)
-    INTERRUPT_HANDLER(0x98)
-    INTERRUPT_HANDLER(0x99)
-    INTERRUPT_HANDLER(0x9a)
-    INTERRUPT_HANDLER(0x9b)
-    INTERRUPT_HANDLER(0x9c)
-    INTERRUPT_HANDLER(0x9d)
-    INTERRUPT_HANDLER(0x9e)
-    INTERRUPT_HANDLER(0x9f)
-    INTERRUPT_HANDLER(0xa0)
-    INTERRUPT_HANDLER(0xa1)
-    INTERRUPT_HANDLER(0xa2)
-    INTERRUPT_HANDLER(0xa3)
-    INTERRUPT_HANDLER(0xa4)
-    INTERRUPT_HANDLER(0xa5)
-    INTERRUPT_HANDLER(0xa6)
-    INTERRUPT_HANDLER(0xa7)
-    INTERRUPT_HANDLER(0xa8)
-    INTERRUPT_HANDLER(0xa9)
-    INTERRUPT_HANDLER(0xaa)
-    INTERRUPT_HANDLER(0xab)
-    INTERRUPT_HANDLER(0xac)
-    INTERRUPT_HANDLER(0xad)
-    INTERRUPT_HANDLER(0xae)
-    INTERRUPT_HANDLER(0xaf)
-    INTERRUPT_HANDLER(0xb0)
-    INTERRUPT_HANDLER(0xb1)
-    INTERRUPT_HANDLER(0xb2)
-    INTERRUPT_HANDLER(0xb3)
-    INTERRUPT_HANDLER(0xb4)
-    INTERRUPT_HANDLER(0xb5)
-    INTERRUPT_HANDLER(0xb6)
-    INTERRUPT_HANDLER(0xb7)
-    INTERRUPT_HANDLER(0xb8)
-    INTERRUPT_HANDLER(0xb9)
-    INTERRUPT_HANDLER(0xba)
-    INTERRUPT_HANDLER(0xbb)
-    INTERRUPT_HANDLER(0xbc)
-    INTERRUPT_HANDLER(0xbd)
-    INTERRUPT_HANDLER(0xbe)
-    INTERRUPT_HANDLER(0xbf)
-    INTERRUPT_HANDLER(0xc0)
-    INTERRUPT_HANDLER(0xc1)
-    INTERRUPT_HANDLER(0xc2)
-    INTERRUPT_HANDLER(0xc3)
-    INTERRUPT_HANDLER(0xc4)
-    INTERRUPT_HANDLER(0xc5)
-    INTERRUPT_HANDLER(0xc6)
-    INTERRUPT_HANDLER(0xc7)
-    INTERRUPT_HANDLER(0xc8)
-    INTERRUPT_HANDLER(0xc9)
-    INTERRUPT_HANDLER(0xca)
-    INTERRUPT_HANDLER(0xcb)
-    INTERRUPT_HANDLER(0xcc)
-    INTERRUPT_HANDLER(0xcd)
-    INTERRUPT_HANDLER(0xce)
-    INTERRUPT_HANDLER(0xcf)
-    INTERRUPT_HANDLER(0xd0)
-    INTERRUPT_HANDLER(0xd1)
-    INTERRUPT_HANDLER(0xd2)
-    INTERRUPT_HANDLER(0xd3)
-    INTERRUPT_HANDLER(0xd4)
-    INTERRUPT_HANDLER(0xd5)
-    INTERRUPT_HANDLER(0xd6)
-    INTERRUPT_HANDLER(0xd7)
-    INTERRUPT_HANDLER(0xd8)
-    INTERRUPT_HANDLER(0xd9)
-    INTERRUPT_HANDLER(0xda)
-    INTERRUPT_HANDLER(0xdb)
-    INTERRUPT_HANDLER(0xdc)
-    INTERRUPT_HANDLER(0xdd)
-    INTERRUPT_HANDLER(0xde)
-    INTERRUPT_HANDLER(0xdf)
-    INTERRUPT_HANDLER(0xe0)
-    INTERRUPT_HANDLER(0xe1)
-    INTERRUPT_HANDLER(0xe2)
-    INTERRUPT_HANDLER(0xe3)
-    INTERRUPT_HANDLER(0xe4)
-    INTERRUPT_HANDLER(0xe5)
-    INTERRUPT_HANDLER(0xe6)
-    INTERRUPT_HANDLER(0xe7)
-    INTERRUPT_HANDLER(0xe8)
-    INTERRUPT_HANDLER(0xe9)
-    INTERRUPT_HANDLER(0xea)
-    INTERRUPT_HANDLER(0xeb)
-    INTERRUPT_HANDLER(0xec)
-    INTERRUPT_HANDLER(0xed)
-    INTERRUPT_HANDLER(0xee)
-    INTERRUPT_HANDLER(0xef)
-    INTERRUPT_HANDLER(0xf0)
-    INTERRUPT_HANDLER(0xf1)
-    INTERRUPT_HANDLER(0xf2)
-    INTERRUPT_HANDLER(0xf3)
-    INTERRUPT_HANDLER(0xf4)
-    INTERRUPT_HANDLER(0xf5)
-    INTERRUPT_HANDLER(0xf6)
-    INTERRUPT_HANDLER(0xf7)
-    INTERRUPT_HANDLER(0xf8)
-    INTERRUPT_HANDLER(0xf9)
-    INTERRUPT_HANDLER(0xfa)
-    INTERRUPT_HANDLER(0xfb)
-    INTERRUPT_HANDLER(0xfc)
-    INTERRUPT_HANDLER(0xfd)
-    INTERRUPT_HANDLER(0xfe)
-    INTERRUPT_HANDLER(0xff)
-
-#pragma endregion Exceptions
-
-    void Init(int Core)
-    {
-        UNUSED(Core);
-        static int once = 0;
-        if (!once++)
-        {
-            // PIC
-            outb(0x20, 0x10 | 0x1);
-            outb(0x80, 0);
-            outb(0xA0, 0x10 | 0x10);
-            outb(0x80, 0);
-
-            outb(0x21, 0x20);
-            outb(0x80, 0);
-            outb(0xA1, 0x28);
-            outb(0x80, 0);
-
-            outb(0x21, 0x04);
-            outb(0x80, 0);
-            outb(0xA1, 0x02);
-            outb(0x80, 0);
-
-            outb(0x21, 1);
-            outb(0x80, 0);
-            outb(0xA1, 1);
-            outb(0x80, 0);
-
-            // Masking and disabling PIC
-            outb(0x21, 0xff);
-            outb(0x80, 0);
-            outb(0xA1, 0xff);
-        }
-
-        /* ISR */
-
-        SetEntry(0x0, InterruptHandler_0x0, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x1, InterruptHandler_0x1, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x2, InterruptHandler_0x2, FlagGate_32BIT_TRAP, 2, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x3, InterruptHandler_0x3, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x4, InterruptHandler_0x4, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x5, InterruptHandler_0x5, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x6, InterruptHandler_0x6, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x7, InterruptHandler_0x7, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x8, InterruptHandler_0x8, FlagGate_32BIT_TRAP, 3, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x9, InterruptHandler_0x9, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa, InterruptHandler_0xa, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb, InterruptHandler_0xb, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc, InterruptHandler_0xc, FlagGate_32BIT_TRAP, 3, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd, InterruptHandler_0xd, FlagGate_32BIT_TRAP, 3, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe, InterruptHandler_0xe, FlagGate_32BIT_TRAP, 3, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf, InterruptHandler_0xf, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x10, InterruptHandler_0x10, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x11, InterruptHandler_0x11, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x12, InterruptHandler_0x12, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x13, InterruptHandler_0x13, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x14, InterruptHandler_0x14, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x15, InterruptHandler_0x15, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x16, InterruptHandler_0x16, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x17, InterruptHandler_0x17, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x18, InterruptHandler_0x18, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x19, InterruptHandler_0x19, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x1a, InterruptHandler_0x1a, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x1b, InterruptHandler_0x1b, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x1c, InterruptHandler_0x1c, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x1d, InterruptHandler_0x1d, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x1e, InterruptHandler_0x1e, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x1f, InterruptHandler_0x1f, FlagGate_32BIT_TRAP, 1, FlagGate_RING0, GDT_KERNEL_CODE);
-
-        /* IRQ */
-
-        SetEntry(0x20, InterruptHandler_0x20, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x21, InterruptHandler_0x21, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x22, InterruptHandler_0x22, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x23, InterruptHandler_0x23, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x24, InterruptHandler_0x24, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x25, InterruptHandler_0x25, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x26, InterruptHandler_0x26, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x27, InterruptHandler_0x27, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x28, InterruptHandler_0x28, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x29, InterruptHandler_0x29, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x2a, InterruptHandler_0x2a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x2b, InterruptHandler_0x2b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x2c, InterruptHandler_0x2c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x2d, InterruptHandler_0x2d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x2e, InterruptHandler_0x2e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x2f, InterruptHandler_0x2f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-
-        /* Reserved by OS */
-
-        SetEntry(0x30, InterruptHandler_0x30, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x31, InterruptHandler_0x31, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x32, InterruptHandler_0x32, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x33, InterruptHandler_0x33, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x34, InterruptHandler_0x34, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x35, InterruptHandler_0x35, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x36, InterruptHandler_0x36, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x37, InterruptHandler_0x37, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x38, InterruptHandler_0x38, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x39, InterruptHandler_0x39, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x3a, InterruptHandler_0x3a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x3b, InterruptHandler_0x3b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x3c, InterruptHandler_0x3c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x3d, InterruptHandler_0x3d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-
-        /* Free */
-
-        SetEntry(0x3e, InterruptHandler_0x3e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x3f, InterruptHandler_0x3f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x40, InterruptHandler_0x40, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x41, InterruptHandler_0x41, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x42, InterruptHandler_0x42, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x43, InterruptHandler_0x43, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x44, InterruptHandler_0x44, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x45, InterruptHandler_0x45, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x46, InterruptHandler_0x46, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x47, InterruptHandler_0x47, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x48, InterruptHandler_0x48, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x49, InterruptHandler_0x49, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x4a, InterruptHandler_0x4a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x4b, InterruptHandler_0x4b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x4c, InterruptHandler_0x4c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x4d, InterruptHandler_0x4d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x4e, InterruptHandler_0x4e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x4f, InterruptHandler_0x4f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x50, InterruptHandler_0x50, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x51, InterruptHandler_0x51, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x52, InterruptHandler_0x52, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x53, InterruptHandler_0x53, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x54, InterruptHandler_0x54, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x55, InterruptHandler_0x55, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x56, InterruptHandler_0x56, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x57, InterruptHandler_0x57, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x58, InterruptHandler_0x58, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x59, InterruptHandler_0x59, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x5a, InterruptHandler_0x5a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x5b, InterruptHandler_0x5b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x5c, InterruptHandler_0x5c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x5d, InterruptHandler_0x5d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x5e, InterruptHandler_0x5e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x5f, InterruptHandler_0x5f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x60, InterruptHandler_0x60, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x61, InterruptHandler_0x61, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x62, InterruptHandler_0x62, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x63, InterruptHandler_0x63, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x64, InterruptHandler_0x64, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x65, InterruptHandler_0x65, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x66, InterruptHandler_0x66, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x67, InterruptHandler_0x67, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x68, InterruptHandler_0x68, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x69, InterruptHandler_0x69, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x6a, InterruptHandler_0x6a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x6b, InterruptHandler_0x6b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x6c, InterruptHandler_0x6c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x6d, InterruptHandler_0x6d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x6e, InterruptHandler_0x6e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x6f, InterruptHandler_0x6f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x70, InterruptHandler_0x70, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x71, InterruptHandler_0x71, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x72, InterruptHandler_0x72, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x73, InterruptHandler_0x73, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x74, InterruptHandler_0x74, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x75, InterruptHandler_0x75, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x76, InterruptHandler_0x76, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x77, InterruptHandler_0x77, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x78, InterruptHandler_0x78, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x79, InterruptHandler_0x79, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x7a, InterruptHandler_0x7a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x7b, InterruptHandler_0x7b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x7c, InterruptHandler_0x7c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x7d, InterruptHandler_0x7d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x7e, InterruptHandler_0x7e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x7f, InterruptHandler_0x7f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x80, InterruptHandler_0x80, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x81, InterruptHandler_0x81, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x82, InterruptHandler_0x82, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x83, InterruptHandler_0x83, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x84, InterruptHandler_0x84, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x85, InterruptHandler_0x85, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x86, InterruptHandler_0x86, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x87, InterruptHandler_0x87, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x88, InterruptHandler_0x88, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x89, InterruptHandler_0x89, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x8a, InterruptHandler_0x8a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x8b, InterruptHandler_0x8b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x8c, InterruptHandler_0x8c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x8d, InterruptHandler_0x8d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x8e, InterruptHandler_0x8e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x8f, InterruptHandler_0x8f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x90, InterruptHandler_0x90, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x91, InterruptHandler_0x91, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x92, InterruptHandler_0x92, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x93, InterruptHandler_0x93, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x94, InterruptHandler_0x94, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x95, InterruptHandler_0x95, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x96, InterruptHandler_0x96, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x97, InterruptHandler_0x97, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x98, InterruptHandler_0x98, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x99, InterruptHandler_0x99, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x9a, InterruptHandler_0x9a, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x9b, InterruptHandler_0x9b, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x9c, InterruptHandler_0x9c, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x9d, InterruptHandler_0x9d, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x9e, InterruptHandler_0x9e, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0x9f, InterruptHandler_0x9f, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa0, InterruptHandler_0xa0, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa1, InterruptHandler_0xa1, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa2, InterruptHandler_0xa2, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa3, InterruptHandler_0xa3, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa4, InterruptHandler_0xa4, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa5, InterruptHandler_0xa5, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa6, InterruptHandler_0xa6, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa7, InterruptHandler_0xa7, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa8, InterruptHandler_0xa8, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xa9, InterruptHandler_0xa9, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xaa, InterruptHandler_0xaa, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xab, InterruptHandler_0xab, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xac, InterruptHandler_0xac, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xad, InterruptHandler_0xad, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xae, InterruptHandler_0xae, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xaf, InterruptHandler_0xaf, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb0, InterruptHandler_0xb0, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb1, InterruptHandler_0xb1, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb2, InterruptHandler_0xb2, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb3, InterruptHandler_0xb3, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb4, InterruptHandler_0xb4, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb5, InterruptHandler_0xb5, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb6, InterruptHandler_0xb6, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb7, InterruptHandler_0xb7, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb8, InterruptHandler_0xb8, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xb9, InterruptHandler_0xb9, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xba, InterruptHandler_0xba, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xbb, InterruptHandler_0xbb, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xbc, InterruptHandler_0xbc, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xbd, InterruptHandler_0xbd, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xbe, InterruptHandler_0xbe, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xbf, InterruptHandler_0xbf, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc0, InterruptHandler_0xc0, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc1, InterruptHandler_0xc1, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc2, InterruptHandler_0xc2, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc3, InterruptHandler_0xc3, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc4, InterruptHandler_0xc4, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc5, InterruptHandler_0xc5, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc6, InterruptHandler_0xc6, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc7, InterruptHandler_0xc7, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc8, InterruptHandler_0xc8, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xc9, InterruptHandler_0xc9, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xca, InterruptHandler_0xca, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xcb, InterruptHandler_0xcb, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xcc, InterruptHandler_0xcc, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xcd, InterruptHandler_0xcd, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xce, InterruptHandler_0xce, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xcf, InterruptHandler_0xcf, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd0, InterruptHandler_0xd0, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd1, InterruptHandler_0xd1, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd2, InterruptHandler_0xd2, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd3, InterruptHandler_0xd3, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd4, InterruptHandler_0xd4, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd5, InterruptHandler_0xd5, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd6, InterruptHandler_0xd6, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd7, InterruptHandler_0xd7, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd8, InterruptHandler_0xd8, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xd9, InterruptHandler_0xd9, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xda, InterruptHandler_0xda, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xdb, InterruptHandler_0xdb, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xdc, InterruptHandler_0xdc, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xdd, InterruptHandler_0xdd, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xde, InterruptHandler_0xde, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xdf, InterruptHandler_0xdf, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe0, InterruptHandler_0xe0, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe1, InterruptHandler_0xe1, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe2, InterruptHandler_0xe2, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe3, InterruptHandler_0xe3, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe4, InterruptHandler_0xe4, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe5, InterruptHandler_0xe5, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe6, InterruptHandler_0xe6, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe7, InterruptHandler_0xe7, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe8, InterruptHandler_0xe8, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xe9, InterruptHandler_0xe9, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xea, InterruptHandler_0xea, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xeb, InterruptHandler_0xeb, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xec, InterruptHandler_0xec, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xed, InterruptHandler_0xed, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xee, InterruptHandler_0xee, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xef, InterruptHandler_0xef, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf0, InterruptHandler_0xf0, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf1, InterruptHandler_0xf1, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf2, InterruptHandler_0xf2, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf3, InterruptHandler_0xf3, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf4, InterruptHandler_0xf4, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf5, InterruptHandler_0xf5, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf6, InterruptHandler_0xf6, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf7, InterruptHandler_0xf7, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf8, InterruptHandler_0xf8, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xf9, InterruptHandler_0xf9, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xfa, InterruptHandler_0xfa, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xfb, InterruptHandler_0xfb, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xfc, InterruptHandler_0xfc, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xfd, InterruptHandler_0xfd, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xfe, InterruptHandler_0xfe, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        SetEntry(0xff, InterruptHandler_0xff, FlagGate_32BIT_TRAP, 0, FlagGate_RING0, GDT_KERNEL_CODE);
-        CPU::x64::lidt(&idtd);
-    }
-}
--- a/Kernel/Architecture/amd64/cpu/SMPTrampoline.asm
+++ b/Kernel/Architecture/amd64/cpu/SMPTrampoline.asm
@@ -1,113 +0,0 @@
-[bits 16]
-TRAMPOLINE_BASE equ 0x2000
-
-extern StartCPU
-global _trampoline_start
-_trampoline_start:
-    cli
-    mov ax, 0x0
-    mov ds, ax
-    mov es, ax
-    mov fs, ax
-    mov gs, ax
-    mov ss, ax
-    o32 lgdt [ProtectedMode_gdtr - _trampoline_start + TRAMPOLINE_BASE]
-    mov eax, cr0
-    or al, 0x1
-    mov cr0, eax
-    jmp 0x8:(Trampoline32 - _trampoline_start + TRAMPOLINE_BASE)
-
-[bits 32]
-section .text
-Trampoline32:
-    mov bx, 0x10
-    mov ds, bx
-    mov es, bx
-    mov ss, bx
-    mov eax, dword [0x500]
-    mov cr3, eax
-    mov eax, cr4
-    or eax, 1 << 5 ; Set the PAE-bit, which is the 6th bit (bit 5).
-    or eax, 1 << 7
-    mov cr4, eax
-    mov ecx, 0xc0000080
-    rdmsr
-    or eax,1 << 8 ; LME
-    wrmsr
-    mov eax, cr0
-    or eax, 1 << 31
-    mov cr0, eax
-    lgdt [LongMode_gdtr - _trampoline_start + TRAMPOLINE_BASE]
-    jmp 0x8:(Trampoline64 - _trampoline_start + TRAMPOLINE_BASE)
-
-[bits 64]
-Trampoline64:
-    mov ax, 0x10
-    mov ds, ax
-    mov es, ax
-    mov ss, ax
-    mov ax, 0x0
-    mov fs, ax
-    mov gs, ax
-    lgdt [0x580]
-    lidt [0x590]
-    mov rsp, [0x570]
-    mov rbp, 0x0 ; Terminate stack traces here.
-    ; Reset RFLAGS.
-    push 0x0
-    popf
-    mov rax, qword vcode64
-    call vcode64
-
-vcode64:
-    push rbp
-    ; Set up SSE
-    mov rax, cr0
-    ; btr eax, 2
-    ; bts eax, 1
-    ; mov cr0, rax
-    mov rax, cr4
-    bts eax, 9
-    bts eax, 10
-    mov cr4, rax
-    mov rax, qword TrampolineExit
-    call rax
-
-align 16
-LongMode_gdtr:
-    dw LongModeGDTEnd - LongModeGDTStart - 1
-    dq LongModeGDTStart - _trampoline_start + TRAMPOLINE_BASE
-
-align 16
-LongModeGDTStart:
-    dq 0 ; NULL segment
-    dq 0x00AF98000000FFFF ; Code segment
-    dq 0x00CF92000000FFFF ; Data segment
-LongModeGDTEnd:
-
-align 16
-ProtectedMode_gdtr:
-    dw ProtectedModeGDTEnd - ProtectedModeGDTStart - 1
-    dd ProtectedModeGDTStart - _trampoline_start + TRAMPOLINE_BASE
-
-align 16
-ProtectedModeGDTStart:
-    dq 0 ; NULL segment
-    dq 0x00CF9A000000FFFF ; Code segment
-    dq 0x00CF92000000FFFF ; Data segment
-ProtectedModeGDTEnd:
-
-align 16
-ProtectedMode_idtr:
-    dw 0
-    dd 0
-    dd 0
-    align 16
-
-global _trampoline_end
-_trampoline_end:
-
-TrampolineExit:
-    call StartCPU
-
-times 512 - ($-$$) db 0
--- a/Kernel/Architecture/amd64/cpu/SymmetricMultiprocessing.cpp
+++ b/Kernel/Architecture/amd64/cpu/SymmetricMultiprocessing.cpp
@@ -1,119 +0,0 @@
-#include <smp.hpp>
-
-#include <ints.hpp>
-#include <memory.hpp>
-#include <assert.h>
-#include <cpu.hpp>
-
-#include "../../../kernel.h"
-#include "../acpi.hpp"
-#include "apic.hpp"
-
-extern "C" uint64_t _trampoline_start, _trampoline_end;
-
-enum SMPTrampolineAddress
-{
-    PAGE_TABLE = 0x500,
-    START_ADDR = 0x520,
-    STACK = 0x570,
-    GDT = 0x580,
-    IDT = 0x590,
-    CORE = 0x600,
-    TRAMPOLINE_START = 0x2000
-};
-
-volatile bool CPUEnabled = false;
-
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-static __attribute__((aligned(PAGE_SIZE))) CPUData CPUs[MAX_CPU] = {0};
-
-SafeFunction CPUData *GetCPU(long id) { return &CPUs[id]; }
-
-SafeFunction CPUData *GetCurrentCPU()
-{
-    if (unlikely(!Interrupts::apic[0]))
-        return &CPUs[0]; /* No APIC means we are on the BSP. */
-    int CoreID = ((APIC::APIC *)Interrupts::apic[0])->Read(APIC::APIC_ID) >> 24;
-
-    if (unlikely((&CPUs[CoreID])->IsActive != true))
-    {
-        error("CPU %d is not active!", CoreID);
-        assert((&CPUs[0])->IsActive == true); /* We can't continue without the BSP. */
-        return &CPUs[0];
-    }
-
-    assert((&CPUs[CoreID])->Checksum == CPU_DATA_CHECKSUM); /* This should never happen. */
-    return &CPUs[CoreID];
-}
-
-extern "C" void StartCPU()
-{
-    CPU::Interrupts(CPU::Disable);
-    uint64_t CoreID = (int)*reinterpret_cast<int *>(CORE);
-    CPU::InitializeFeatures(CoreID);
-    // Initialize GDT and IDT
-    Interrupts::Initialize(CoreID);
-    Interrupts::Enable(CoreID);
-    Interrupts::InitializeTimer(CoreID);
-
-    CPU::Interrupts(CPU::Enable);
-    KPrint("\e058C19CPU \e8888FF%d \e058C19is online", CoreID);
-    CPUEnabled = true;
-    CPU::Halt(true);
-}
-
-namespace SMP
-{
-    int CPUCores = 0;
-
-    void Initialize(void *madt)
-    {
-        int Cores = ((ACPI::MADT *)madt)->CPUCores + 1;
-
-        if (Config.Cores > ((ACPI::MADT *)madt)->CPUCores + 1)
-            KPrint("More cores requested than available. Using %d cores", ((ACPI::MADT *)madt)->CPUCores + 1);
-        else if (Config.Cores != 0)
-            Cores = Config.Cores;
-
-        CPUCores = Cores;
-
-        for (int i = 0; i < Cores; i++)
-        {
-            debug("Initializing CPU %d", i);
-            if ((((APIC::APIC *)Interrupts::apic[0])->Read(APIC::APIC_ID) >> 24) != ((ACPI::MADT *)madt)->lapic[i]->ACPIProcessorId)
-            {
-                ((APIC::APIC *)Interrupts::apic[0])->Write(APIC::APIC_ICRHI, (((ACPI::MADT *)madt)->lapic[i]->APICId << 24));
-                ((APIC::APIC *)Interrupts::apic[0])->Write(APIC::APIC_ICRLO, 0x500);
-
-                Memory::Virtual().Map(0x0, 0x0, Memory::PTFlag::RW | Memory::PTFlag::US);
-
-                uint64_t TrampolineLength = (uintptr_t)&_trampoline_end - (uintptr_t)&_trampoline_start;
-                for (uint64_t i = 0; i < (TrampolineLength / PAGE_SIZE) + 2; i++)
-                    Memory::Virtual().Map((void *)(TRAMPOLINE_START + (i * PAGE_SIZE)), (void *)(TRAMPOLINE_START + (i * PAGE_SIZE)), Memory::PTFlag::RW | Memory::PTFlag::US);
-
-                memcpy((void *)TRAMPOLINE_START, &_trampoline_start, TrampolineLength);
-
-                POKE(volatile uint64_t, PAGE_TABLE) = CPU::x64::readcr3().raw;
-                POKE(volatile uint64_t, STACK) = (uint64_t)KernelAllocator.RequestPages(TO_PAGES(STACK_SIZE)) + STACK_SIZE;
-                POKE(volatile uint64_t, CORE) = i;
-
-                asmv("sgdt [0x580]\n"
-                     "sidt [0x590]\n");
-
-                POKE(volatile uint64_t, START_ADDR) = (uintptr_t)&StartCPU;
-
-                ((APIC::APIC *)Interrupts::apic[0])->SendInitIPI(((ACPI::MADT *)madt)->lapic[i]->APICId);
-                ((APIC::APIC *)Interrupts::apic[0])->SendStartupIPI(((ACPI::MADT *)madt)->lapic[i]->APICId, TRAMPOLINE_START);
-
-                while (!CPUEnabled)
-                    CPU::Pause();
-
-                trace("CPU %d loaded.", ((ACPI::MADT *)madt)->lapic[i]->APICId);
-                KernelAllocator.FreePages((void *)*reinterpret_cast<long *>(STACK), TO_PAGES(STACK_SIZE));
-                CPUEnabled = false;
-            }
-            else
-                KPrint("\e058C19CPU \e8888FF%d \e058C19is the BSP", ((ACPI::MADT *)madt)->lapic[i]->APICId);
-        }
-    }
-}
--- a/Kernel/Architecture/amd64/cpu/apic.hpp
+++ b/Kernel/Architecture/amd64/cpu/apic.hpp
@@ -1,337 +0,0 @@
-#ifndef __FENNIX_KERNEL_APIC_H__
-#define __FENNIX_KERNEL_APIC_H__
-
-#include <types.h>
-
-#include <ints.hpp>
-#include <cpu.hpp>
-
-namespace APIC
-{
-    enum APICRegisters
-    {
-        // source from: https://github.com/pdoane/osdev/blob/master/intr/local_apic.c
-        APIC_ID = 0x20,       // Local APIC ID
-        APIC_VER = 0x30,      // Local APIC Version
-        APIC_TPR = 0x80,      // Task Priority
-        APIC_APR = 0x90,      // Arbitration Priority
-        APIC_PPR = 0xA0,      // Processor Priority
-        APIC_EOI = 0xB0,      // EOI
-        APIC_RRD = 0xC0,      // Remote Read
-        APIC_LDR = 0xD0,      // Logical Destination
-        APIC_DFR = 0xE0,      // Destination Format
-        APIC_SVR = 0xF0,      // Spurious Interrupt Vector
-        APIC_ISR = 0x100,     // In-Service (8 registers)
-        APIC_TMR = 0x180,     // Trigger Mode (8 registers)
-        APIC_IRR = 0x200,     // Interrupt Request (8 registers)
-        APIC_ESR = 0x280,     // Error Status
-        APIC_ICRLO = 0x300,   // Interrupt Command
-        APIC_ICRHI = 0x310,   // Interrupt Command [63:32]
-        APIC_TIMER = 0x320,   // LVT Timer
-        APIC_THERMAL = 0x330, // LVT Thermal Sensor
-        APIC_PERF = 0x340,    // LVT Performance Counter
-        APIC_LINT0 = 0x350,   // LVT LINT0
-        APIC_LINT1 = 0x360,   // LVT LINT1
-        APIC_ERROR = 0x370,   // LVT Error
-        APIC_TICR = 0x380,    // Initial Count (for Timer)
-        APIC_TCCR = 0x390,    // Current Count (for Timer)
-        APIC_TDCR = 0x3E0,    // Divide Configuration (for Timer)
-    };
-
-    enum IOAPICRegisters
-    {
-        GetIOAPICVersion = 0x1
-    };
-
-    enum IOAPICFlags
-    {
-        ActiveHighLow = 2,
-        EdgeLevel = 8
-    };
-
-    enum APICDeliveryMode
-    {
-        Fixed = 0b000,
-        LowestPriority = 0b001, /* Reserved */
-        SMI = 0b010,
-        APIC_DELIVERY_MODE_RESERVED0 = 0b011, /* Reserved */
-        NMI = 0b100,
-        INIT = 0b101,
-        Startup = 0b110,
-        ExtINT = 0b111 /* Reserved */
-    };
-
-    enum APICDestinationMode
-    {
-        Physical = 0b0,
-        Logical = 0b1
-    };
-
-    enum APICDeliveryStatus
-    {
-        Idle = 0b0,
-        SendPending = 0b1
-    };
-
-    enum APICLevel
-    {
-        DeAssert = 0b0,
-        Assert = 0b1
-    };
-
-    enum APICTriggerMode
-    {
-        Edge = 0b0,
-        Level = 0b1
-    };
-
-    enum APICDestinationShorthand
-    {
-        NoShorthand = 0b00,
-        Self = 0b01,
-        AllIncludingSelf = 0b10,
-        AllExcludingSelf = 0b11
-    };
-
-    enum LVTTimerDivide
-    {
-        DivideBy2 = 0b000,
-        DivideBy4 = 0b001,
-        DivideBy8 = 0b010,
-        DivideBy16 = 0b011,
-        DivideBy32 = 0b100,
-        DivideBy64 = 0b101,
-        DivideBy128 = 0b110,
-        DivideBy1 = 0b111
-    };
-
-    enum LVTTimerMask
-    {
-        Unmasked = 0b0,
-        Masked = 0b1
-    };
-
-    enum LVTTimerMode
-    {
-        OneShot = 0b00,
-        Periodic = 0b01,
-        TSCDeadline = 0b10
-    };
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Interrupt Vector */
-            uint64_t Vector : 8;
-            /** @brief Reserved */
-            uint64_t Reserved0 : 4;
-            /**
-             * @brief Delivery Status
-             *
-             * 0: Idle
-             * 1: Send Pending
-             */
-            uint64_t DeliveryStatus : 1;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 3;
-            /**
-             * @brief Mask
-             *
-             * 0: Not masked
-             * 1: Masked
-             */
-            uint64_t Mask : 1;
-            /** @brief Timer Mode
-             *
-             * 0: One-shot
-             * 1: Periodic
-             * 2: TSC-Deadline
-             */
-            uint64_t TimerMode : 1;
-            /** @brief Reserved */
-            uint64_t Reserved2 : 14;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) LVTTimer;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Spurious Vector */
-            uint64_t Vector : 8;
-            /** @brief Enable or disable APIC software */
-            uint64_t Software : 1;
-            /** @brief Focus Processor Checking */
-            uint64_t FocusProcessorChecking : 1;
-            /** @brief Reserved */
-            uint64_t Reserved : 2;
-            /** @brief Disable EOI Broadcast */
-            uint64_t DisableEOIBroadcast : 1;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 19;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) Spurious;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Interrupt Vector */
-            uint64_t Vector : 8;
-            /** @brief Delivery Mode */
-            uint64_t DeliveryMode : 3;
-            /** @brief Destination Mode
-             *
-             * 0: Physical
-             * 1: Logical
-             */
-            uint64_t DestinationMode : 1;
-            /** @brief Delivery Status
-             *
-             * @note Reserved when in x2APIC mode
-             */
-            uint64_t DeliveryStatus : 1;
-            /** @brief Reserved */
-            uint64_t Reserved0 : 1;
-            /** @brief Level
-             *
-             * 0: Deassert
-             * 1: Assert
-             */
-            uint64_t Level : 1;
-            /** @brief Trigger Mode
-             *
-             * 0: Edge
-             * 1: Level
-             */
-            uint64_t TriggerMode : 1;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 2;
-            /** @brief Destination Shorthand
-             *
-             * 0: No shorthand
-             * 1: Self
-             * 2: All including self
-             * 3: All excluding self
-             */
-            uint64_t DestinationShorthand : 2;
-            /** @brief Reserved */
-            uint64_t Reserved2 : 12;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) InterruptCommandRegisterLow;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Reserved */
-            uint64_t Reserved0 : 24;
-            /** @brief Destination */
-            uint64_t Destination : 8;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) InterruptCommandRegisterHigh;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Interrupt Vector */
-            uint64_t Vector : 8;
-            /** @brief Delivery Mode */
-            uint64_t DeliveryMode : 3;
-            /** @brief Destination Mode
-             *
-             * 0: Physical
-             * 1: Logical
-             */
-            uint64_t DestinationMode : 1;
-            /** @brief Delivery Status */
-            uint64_t DeliveryStatus : 1;
-            /** @brief Interrupt Input Pin Polarity
-             *
-             * 0: Active High
-             * 1: Active Low
-             */
-            uint64_t Polarity : 1;
-            /** @brief Remote IRR */
-            uint64_t RemoteIRR : 1;
-            /** @brief Trigger Mode
-             *
-             * 0: Edge
-             * 1: Level
-             */
-            uint64_t TriggerMode : 1;
-            /** @brief Mask */
-            uint64_t Mask : 1;
-            /** @brief Reserved */
-            uint64_t Reserved0 : 15;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 24;
-            /** @brief Destination */
-            uint64_t DestinationID : 8;
-        };
-        struct
-        {
-            uint64_t Low;
-            uint64_t High;
-        } split;
-        uint64_t raw;
-    } __attribute__((packed)) IOAPICRedirectEntry;
-
-    typedef union
-    {
-        struct
-        {
-            uint64_t Version : 8;
-            uint64_t Reserved : 8;
-            uint64_t MaximumRedirectionEntry : 8;
-            uint64_t Reserved2 : 8;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) IOAPICVersion;
-
-    class APIC
-    {
-    private:
-        bool x2APICSupported = false;
-        uint64_t APICBaseAddress = 0;
-
-    public:
-        uint32_t Read(uint32_t Register);
-        void Write(uint32_t Register, uint32_t Value);
-        void IOWrite(uint64_t Base, uint32_t Register, uint32_t Value);
-        uint32_t IORead(uint64_t Base, uint32_t Register);
-        void EOI();
-        void RedirectIRQs(int CPU = 0);
-        void WaitForIPI();
-        void IPI(uint8_t CPU, InterruptCommandRegisterLow icr);
-        void SendInitIPI(uint8_t CPU);
-        void SendStartupIPI(uint8_t CPU, uint64_t StartupAddress);
-        uint32_t IOGetMaxRedirect(uint32_t APICID);
-        void RawRedirectIRQ(uint8_t Vector, uint32_t GSI, uint16_t Flags, int CPU, int Status);
-        void RedirectIRQ(int CPU, uint8_t IRQ, int Status);
-        APIC(int Core);
-        ~APIC();
-    };
-
-    class Timer : public Interrupts::Handler
-    {
-    private:
-        APIC *lapic;
-        uint64_t Ticks = 0;
-        void OnInterruptReceived(CPU::x64::TrapFrame *Frame);
-
-    public:
-        uint64_t GetTicks() { return Ticks; }
-        void OneShot(uint32_t Vector, uint64_t Miliseconds);
-        Timer(APIC *apic);
-        ~Timer();
-    };
-}
-
-#endif // !__FENNIX_KERNEL_APIC_H__
--- a/Kernel/Architecture/amd64/cpu/gdt.hpp
+++ b/Kernel/Architecture/amd64/cpu/gdt.hpp
@@ -1,146 +0,0 @@
-#ifndef __FENNIX_KERNEL_GDT_H__
-#define __FENNIX_KERNEL_GDT_H__
-
-#include <types.h>
-
-namespace GlobalDescriptorTable
-{
-    /** @brief The GDT Access Table
-     * @details For more information, see https://wiki.osdev.org/Global_Descriptor_Table
-     */
-    union GlobalDescriptorTableAccess
-    {
-        struct
-        {
-            /** @brief Access bit.
-             * @note The CPU sets this bit to 1 when the segment is accessed.
-             */
-            uint8_t A : 1;
-
-            /** @brief Readable bit for code segments, writable bit for data segments.
-             * @details For code segments, this bit must be 1 for the segment to be readable.
-             * @details For data segments, this bit must be 1 for the segment to be writable.
-             */
-            uint8_t RW : 1;
-
-            /** @brief Direction bit for data segments, conforming bit for code segments.
-             * @details For data segments, this bit must be 1 for the segment to grow up (higher addresses).
-             * @details For code segments, this bit must be 1 for code in the segment to be able to be executed from an equal or lower privilege level.
-             */
-            uint8_t DC : 1;
-
-            /** @brief Executable bit.
-             * @details This bit must be 1 for code-segment descriptors.
-             * @details This bit must be 0 for data-segment and system descriptors.
-             */
-            uint8_t E : 1;
-
-            /** @brief Descriptor type.
-             * @details This bit must be 0 for system descriptors.
-             * @details This bit must be 1 for code or data segment descriptor.
-             */
-            uint8_t S : 1;
-
-            /** @brief Descriptor privilege level.
-             * @details This field determines the privilege level of the segment.
-             * @details 0 = kernel mode, 3 = user mode.
-             */
-            uint8_t DPL : 2;
-
-            /** @brief Present bit.
-             * @details This bit must be 1 for all valid descriptors.
-             */
-            uint8_t P : 1;
-        } __attribute__((packed));
-        uint8_t Raw;
-    };
-
-    union GlobalDescriptorTableFlags
-    {
-        // TODO: Add more flags.
-        struct
-        {
-            /** @brief Unknown. */
-            uint8_t Unknown : 5;
-
-            /** @brief Long mode.
-             * @details If the long mode bit is clear, the segment is in 32-bit protected mode.
-             * @details If the long mode bit is set, the segment is in 64-bit long mode.
-             */
-            uint8_t L : 1;
-        } __attribute__((packed));
-        uint8_t Raw;
-    };
-
-    typedef struct _TaskStateSegmentEntry
-    {
-        /* LOW */
-        uint16_t Length;
-        uint16_t BaseLow;
-        uint8_t BaseMiddle;
-        GlobalDescriptorTableAccess Flags;
-        uint8_t Granularity;
-        uint8_t BaseHigh;
-        /* HIGH */
-        uint32_t BaseUpper;
-        uint32_t Reserved;
-    } __attribute__((packed)) TaskStateSegmentEntry;
-
-    typedef struct _TaskStateSegment
-    {
-        uint32_t Reserved0 __attribute__((aligned(16)));
-        uint64_t StackPointer[3];
-        uint64_t Reserved1;
-        uint64_t InterruptStackTable[7];
-        uint64_t Reserved2;
-        uint16_t Reserved3;
-        uint16_t IOMapBaseAddressOffset;
-    } __attribute__((packed)) TaskStateSegment;
-
-    typedef struct _GlobalDescriptorTableEntry
-    {
-        /** @brief Length */
-        uint16_t Length;
-        /** @brief Low Base */
-        uint16_t BaseLow;
-        /** @brief Middle Base */
-        uint8_t BaseMiddle;
-        /** @brief Access */
-        GlobalDescriptorTableAccess Access;
-        /** @brief Flags */
-        GlobalDescriptorTableFlags Flags;
-        /** @brief High Base */
-        uint8_t BaseHigh;
-    } __attribute__((packed)) GlobalDescriptorTableEntry;
-
-    typedef struct _GlobalDescriptorTableEntries
-    {
-        GlobalDescriptorTableEntry Null;
-        GlobalDescriptorTableEntry Code;
-        GlobalDescriptorTableEntry Data;
-        GlobalDescriptorTableEntry UserData;
-        GlobalDescriptorTableEntry UserCode;
-        TaskStateSegmentEntry TaskStateSegment;
-    } __attribute__((packed)) GlobalDescriptorTableEntries;
-
-    typedef struct _GlobalDescriptorTableDescriptor
-    {
-        /** @brief GDT entries length */
-        uint16_t Length;
-        /** @brief GDT entries address */
-        GlobalDescriptorTableEntries *Entries;
-    } __attribute__((packed)) GlobalDescriptorTableDescriptor;
-
-    extern void *CPUStackPointer[];
-    extern TaskStateSegment tss[];
-    void Init(int Core);
-    void SetKernelStack(void *Stack);
-}
-
-#define GDT_KERNEL_CODE offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, Code)
-#define GDT_KERNEL_DATA offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, Data)
-#define GDT_USER_CODE (offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, UserCode) | 3)
-#define GDT_USER_DATA (offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, UserData) | 3)
-#define GDT_TSS (offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, TaskStateSegment) | 3)
-
-#endif // !__FENNIX_KERNEL_GDT_H__
--- a/Kernel/Architecture/amd64/cpu/idt.hpp
+++ b/Kernel/Architecture/amd64/cpu/idt.hpp
@@ -1,46 +0,0 @@
-#ifndef __FENNIX_KERNEL_IDT_H__
-#define __FENNIX_KERNEL_IDT_H__
-
-#include <types.h>
-
-namespace InterruptDescriptorTable
-{
-    typedef enum _InterruptDescriptorTableFlags
-    {
-        FlagGate_TASK = 0b101,
-        FlagGate_16BIT_INT = 0b110,
-        FlagGate_16BIT_TRAP = 0b111,
-        FlagGate_32BIT_INT = 0b1110,
-        FlagGate_32BIT_TRAP = 0b1111,
-        FlagGate_RING0 = 0b0,
-        FlagGate_RING1 = 0b1,
-        FlagGate_RING2 = 0b10,
-        FlagGate_RING3 = 0b11,
-        FlagGate_PRESENT = 0b1, // Not sure if this is correct.
-    } InterruptDescriptorTableFlags;
-
-    typedef struct _InterruptDescriptorTableEntry
-    {
-        uint64_t BaseLow : 16;
-        uint64_t SegmentSelector : 16;
-        uint64_t InterruptStackTable : 3;
-        uint64_t Reserved1 : 5;
-        InterruptDescriptorTableFlags Flags : 4;
-        uint64_t Reserved2 : 1;
-        uint64_t Ring : 2;
-        uint64_t Present : 1;
-        uint64_t BaseHigh : 48;
-        uint64_t Reserved3 : 32;
-    } __attribute__((packed)) InterruptDescriptorTableEntry;
-
-    typedef struct _InterruptDescriptorTableDescriptor
-    {
-        uint16_t Length;
-        InterruptDescriptorTableEntry *Entries;
-    } __attribute__((packed)) InterruptDescriptorTableDescriptor;
-
-    void SetEntry(uint8_t Index, void (*Base)(), InterruptDescriptorTableFlags Attribute, uint8_t InterruptStackTable, InterruptDescriptorTableFlags Ring, uint16_t SegmentSelector);
-    void Init(int Core);
-}
-
-#endif // !__FENNIX_KERNEL_IDT_H__
--- a/Kernel/Architecture/amd64/linker.ld
+++ b/Kernel/Architecture/amd64/linker.ld
@@ -1,80 +0,0 @@
-OUTPUT_FORMAT(elf64-x86-64)
-OUTPUT_ARCH(i386:x86-64)
-
-KERNEL_LMA = 16M;
-KERNEL_VMA = 0xFFFFFFFF80000000;
-
-ENTRY(_start)
-
-SECTIONS
-{
-    . = KERNEL_LMA;
-
-    .multiboot2 :
-    {
-        *(.multiboot2 .multiboot2.*)
-    }
-
-    .bootstrap :
-    {
-        *(.bootstrap.text .bootstrap.text.*)
-        *(.bootstrap.data .bootstrap.data.*)
-        *(.bootstrap.rodata .bootstrap.rodata.*)
-        *(.bootstrap.bss .bootstrap.bss.*)
-    }
-
-    . += KERNEL_VMA;
-
-    _kernel_start = .;
-    .text : AT(ADDR(.text) - KERNEL_VMA)
-    {
-        *(.text .text.*)
-    }
-    _kernel_text_end = ALIGN(CONSTANT(MAXPAGESIZE));
-    . += CONSTANT(MAXPAGESIZE);
-
-    .data : AT(ADDR(.data) - KERNEL_VMA)
-    {
-        *(.data .data.*)
-    }
-    _kernel_data_end = ALIGN(CONSTANT(MAXPAGESIZE));
-    . += CONSTANT(MAXPAGESIZE);
-
-    .rodata : AT(ADDR(.rodata) - KERNEL_VMA)
-    {
-        *(.rodata .rodata.*)
-    }
-    _kernel_rodata_end = ALIGN(CONSTANT(MAXPAGESIZE));
-    . += CONSTANT(MAXPAGESIZE);
-
-    .init_array : AT(ADDR(.init_array) - KERNEL_VMA)
-    {
-        PROVIDE_HIDDEN(__init_array_start = .);
-        KEEP(*(.init_array .ctors))
-        KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
-        PROVIDE_HIDDEN (__init_array_end = .);
-    }
-
-    .fini_array : AT(ADDR(.fini_array) - KERNEL_VMA)
-    {
-        PROVIDE_HIDDEN(__fini_array_start = .);
-        KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
-        KEEP(*(.fini_array .dtors))
-        PROVIDE_HIDDEN (__fini_array_end = .);
-    }
-    . += CONSTANT(MAXPAGESIZE);
-
-    .bss : AT(ADDR(.bss) - KERNEL_VMA)
-    {
-        *(COMMON)
-        *(.bss .bss.*)
-    }
-    . += CONSTANT(MAXPAGESIZE);
-    _kernel_end = ALIGN(CONSTANT(MAXPAGESIZE));
-
-    /DISCARD/ :
-    {
-        *(.comment*)
-        *(.note*)
-    }
-}
--- a/Kernel/Architecture/amd64/runtime/crt0.c
+++ b/Kernel/Architecture/amd64/runtime/crt0.c
@@ -1,15 +0,0 @@
-// #include <types.h>
-
-// #include <debug.h>
-
-// int Entry(void *Info);
-
-// void _start(void *Raw)
-// {
-//     error("Todo");
-//     while (1)
-//         asmv("hlt");
-//     Entry(NULL);
-//     return;
-// }
-// C stuff
--- a/Kernel/Architecture/amd64/runtime/crt1.c
+++ b/Kernel/Architecture/amd64/runtime/crt1.c
@@ -1,15 +0,0 @@
-#include <types.h>
-
-#include <debug.h>
-
-int Entry(void *Info);
-
-void _start(void *Raw)
-{
-    UNUSED(Raw);
-    error("ERROR! INVALID BOOT PROTOCOL!");
-    while (1)
-        asmv("hlt");
-    Entry(NULL);
-    return;
-}
--- a/Kernel/Architecture/amd64/runtime/crtbegin.c
+++ b/Kernel/Architecture/amd64/runtime/crtbegin.c
@@ -1 +0,0 @@
-// C++ constructor/destructor stuff
--- a/Kernel/Architecture/amd64/runtime/crtend.c
+++ b/Kernel/Architecture/amd64/runtime/crtend.c
@@ -1 +0,0 @@
-// C++ constructor/destructor stuff
--- a/Kernel/Architecture/amd64/runtime/crti.S
+++ b/Kernel/Architecture/amd64/runtime/crti.S
@@ -1,13 +0,0 @@
-.section .init
-.global _init
-.type _init, @function
-_init:
-	push %rbp
-	movq %rsp, %rbp
-
-.section .fini
-.global _fini
-.type _fini, @function
-_fini:
-	push %rbp
-	movq %rsp, %rbp
--- a/Kernel/Architecture/amd64/runtime/crtn.S
+++ b/Kernel/Architecture/amd64/runtime/crtn.S
@@ -1,7 +0,0 @@
-.section .init
-	popq %rbp
-	ret
-
-.section .fini
-	popq %rbp
-	ret
--- a/Kernel/Architecture/amd64/rust-target.json
+++ b/Kernel/Architecture/amd64/rust-target.json
@@ -1,21 +0,0 @@
-{
-    "llvm-target": "x86_64-unknown-none",
-    "data-layout": "e-m:e-i64:64-f80:128-n8:16:32:64-S128",
-    "cpu": "x86-64",
-    "arch": "x86_64",
-    "features": "-mmx,-sse,+soft-float",
-    "target-endian": "little",
-    "target-pointer-width": "64",
-    "target-c-int-width": "32",
-    "os": "none",
-    "linker-flavor": "ld",
-    "pre-link-args": {
-        "ld": [
-            "-m64"
-        ]
-    },
-    "no-compiler-rt": true,
-    "disable-redzone": true,
-    "eliminate-frame-pointer": false,
-    "morestack": false
-}
--- a/Kernel/Architecture/i686/ArithmeticOperations.c
+++ b/Kernel/Architecture/i686/ArithmeticOperations.c
@@ -1,327 +0,0 @@
-/* Source: https://github.com/glitchub/arith64 */
-#define arith64_u64 unsigned long long int
-#define arith64_s64 signed long long int
-#define arith64_u32 unsigned int
-#define arith64_s32 int
-
-typedef union
-{
-    arith64_u64 u64;
-    arith64_s64 s64;
-    struct
-    {
-#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-        arith64_u32 hi;
-        arith64_u32 lo;
-#else
-        arith64_u32 lo;
-        arith64_u32 hi;
-#endif
-    } u32;
-    struct
-    {
-#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-        arith64_s32 hi;
-        arith64_s32 lo;
-#else
-        arith64_s32 lo;
-        arith64_s32 hi;
-#endif
-    } s32;
-} arith64_word;
-
-#define arith64_hi(n) (arith64_word){.u64 = n}.u32.hi
-#define arith64_lo(n) (arith64_word){.u64 = n}.u32.lo
-#define arith64_neg(a, b) (((a) ^ ((((arith64_s64)(b)) >= 0) - 1)) + (((arith64_s64)(b)) < 0))
-#define arith64_abs(a) arith64_neg(a, a)
-
-arith64_s64 __absvdi2(arith64_s64 a)
-{
-    return arith64_abs(a);
-}
-
-arith64_s64 __ashldi3(arith64_s64 a, int b)
-{
-    arith64_word w = {.s64 = a};
-
-    b &= 63;
-
-    if (b >= 32)
-    {
-        w.u32.hi = w.u32.lo << (b - 32);
-        w.u32.lo = 0;
-    }
-    else if (b)
-    {
-        w.u32.hi = (w.u32.lo >> (32 - b)) | (w.u32.hi << b);
-        w.u32.lo <<= b;
-    }
-    return w.s64;
-}
-
-arith64_s64 __ashrdi3(arith64_s64 a, int b)
-{
-    arith64_word w = {.s64 = a};
-
-    b &= 63;
-
-    if (b >= 32)
-    {
-        w.s32.lo = w.s32.hi >> (b - 32);
-        w.s32.hi >>= 31; // 0xFFFFFFFF or 0
-    }
-    else if (b)
-    {
-        w.u32.lo = (w.u32.hi << (32 - b)) | (w.u32.lo >> b);
-        w.s32.hi >>= b;
-    }
-    return w.s64;
-}
-
-int __clzsi2(arith64_u32 a)
-{
-    int b, n = 0;
-    b = !(a & 0xffff0000) << 4;
-    n += b;
-    a <<= b;
-    b = !(a & 0xff000000) << 3;
-    n += b;
-    a <<= b;
-    b = !(a & 0xf0000000) << 2;
-    n += b;
-    a <<= b;
-    b = !(a & 0xc0000000) << 1;
-    n += b;
-    a <<= b;
-    return n + !(a & 0x80000000);
-}
-
-int __clzdi2(arith64_u64 a)
-{
-    int b, n = 0;
-    b = !(a & 0xffffffff00000000ULL) << 5;
-    n += b;
-    a <<= b;
-    b = !(a & 0xffff000000000000ULL) << 4;
-    n += b;
-    a <<= b;
-    b = !(a & 0xff00000000000000ULL) << 3;
-    n += b;
-    a <<= b;
-    b = !(a & 0xf000000000000000ULL) << 2;
-    n += b;
-    a <<= b;
-    b = !(a & 0xc000000000000000ULL) << 1;
-    n += b;
-    a <<= b;
-    return n + !(a & 0x8000000000000000ULL);
-}
-
-int __ctzsi2(arith64_u32 a)
-{
-    int b, n = 0;
-    b = !(a & 0x0000ffff) << 4;
-    n += b;
-    a >>= b;
-    b = !(a & 0x000000ff) << 3;
-    n += b;
-    a >>= b;
-    b = !(a & 0x0000000f) << 2;
-    n += b;
-    a >>= b;
-    b = !(a & 0x00000003) << 1;
-    n += b;
-    a >>= b;
-    return n + !(a & 0x00000001);
-}
-
-int __ctzdi2(arith64_u64 a)
-{
-    int b, n = 0;
-    b = !(a & 0x00000000ffffffffULL) << 5;
-    n += b;
-    a >>= b;
-    b = !(a & 0x000000000000ffffULL) << 4;
-    n += b;
-    a >>= b;
-    b = !(a & 0x00000000000000ffULL) << 3;
-    n += b;
-    a >>= b;
-    b = !(a & 0x000000000000000fULL) << 2;
-    n += b;
-    a >>= b;
-    b = !(a & 0x0000000000000003ULL) << 1;
-    n += b;
-    a >>= b;
-    return n + !(a & 0x0000000000000001ULL);
-}
-
-arith64_u64 __divmoddi4(arith64_u64 a, arith64_u64 b, arith64_u64 *c)
-{
-    if (b > a)
-    {
-        if (c)
-            *c = a;
-        return 0;
-    }
-    if (!arith64_hi(b))
-    {
-        if (b == 0)
-        {
-            volatile char x = 0;
-            x = 1 / x;
-        }
-        if (b == 1)
-        {
-            if (c)
-                *c = 0;
-            return a;
-        }
-        if (!arith64_hi(a))
-        {
-            if (c)
-                *c = arith64_lo(a) % arith64_lo(b);
-            return arith64_lo(a) / arith64_lo(b);
-        }
-    }
-
-    char bits = __clzdi2(b) - __clzdi2(a) + 1;
-    arith64_u64 rem = a >> bits;
-    a <<= 64 - bits;
-    arith64_u64 wrap = 0;
-    while (bits-- > 0)
-    {
-        rem = (rem << 1) | (a >> 63);
-        a = (a << 1) | (wrap & 1);
-        wrap = ((arith64_s64)(b - rem - 1) >> 63);
-        rem -= b & wrap;
-    }
-    if (c)
-        *c = rem;
-    return (a << 1) | (wrap & 1);
-}
-
-arith64_s64 __divdi3(arith64_s64 a, arith64_s64 b)
-{
-    arith64_u64 q = __divmoddi4(arith64_abs(a), arith64_abs(b), (void *)0);
-    return arith64_neg(q, a ^ b);
-}
-
-int __ffsdi2(arith64_u64 a) { return a ? __ctzdi2(a) + 1 : 0; }
-
-arith64_u64 __lshrdi3(arith64_u64 a, int b)
-{
-    arith64_word w = {.u64 = a};
-
-    b &= 63;
-
-    if (b >= 32)
-    {
-        w.u32.lo = w.u32.hi >> (b - 32);
-        w.u32.hi = 0;
-    }
-    else if (b)
-    {
-        w.u32.lo = (w.u32.hi << (32 - b)) | (w.u32.lo >> b);
-        w.u32.hi >>= b;
-    }
-    return w.u64;
-}
-
-arith64_s64 __moddi3(arith64_s64 a, arith64_s64 b)
-{
-    arith64_u64 r;
-    __divmoddi4(arith64_abs(a), arith64_abs(b), &r);
-    return arith64_neg(r, a);
-}
-
-int __popcountsi2(arith64_u32 a)
-{
-
-    a = a - ((a >> 1) & 0x55555555);
-    a = ((a >> 2) & 0x33333333) + (a & 0x33333333);
-    a = (a + (a >> 4)) & 0x0F0F0F0F;
-    a = (a + (a >> 16));
-
-    return (a + (a >> 8)) & 63;
-}
-
-int __popcountdi2(arith64_u64 a)
-{
-
-    a = a - ((a >> 1) & 0x5555555555555555ULL);
-    a = ((a >> 2) & 0x3333333333333333ULL) + (a & 0x3333333333333333ULL);
-    a = (a + (a >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
-    a = (a + (a >> 32));
-    a = (a + (a >> 16));
-
-    return (a + (a >> 8)) & 127;
-}
-
-arith64_u64 __udivdi3(arith64_u64 a, arith64_u64 b) { return __divmoddi4(a, b, (void *)0); }
-
-arith64_u64 __umoddi3(arith64_u64 a, arith64_u64 b)
-{
-    arith64_u64 r;
-    __divmoddi4(a, b, &r);
-    return r;
-}
-
-/* Good documentation: https://splichal.eu/scripts/sphinx/gccint/_build/html/the-gcc-low-level-runtime-library/routines-for-floating-point-emulation.html */
-
-double __adddf3(double a, double b) { return a + b; }
-double __muldf3(double a, double b) { return a * b; }
-double __floatsidf(int i) { return (double)i; }
-int __ltdf2(double a, double b) { return a < b; }
-int __gtdf2(double a, double b) { return a > b; }
-int __nedf2(double a, double b) { return a != b; }
-int __eqdf2(double a, double b) { return a == b; }
-double __floatdidf(long i) { return (double)i; }
-double __divdf3(double a, double b) { return a / b; }
-double __subdf3(double a, double b) { return a - b; }
-int __gedf2(double a, double b) { return a >= b; }
-int __fixdfsi(double a) { return (int)a; }
-long __fixdfdi(double a) { return (long)a; }
-int __ledf2(double a, double b) { return a <= b; }
-
-/* FIXME: Check if these functions are implemented correctly */
-
-typedef long long int64_t;
-typedef unsigned long long uint64_t;
-typedef unsigned int uint32_t;
-typedef struct
-{
-    uint64_t value;
-} atomic_uint64_t;
-
-uint64_t __atomic_load_8(const atomic_uint64_t *p)
-{
-    uint64_t value;
-    __asm__ volatile("lock cmpxchg8b %1"
-                     : "=A"(value)
-                     : "m"(*p)
-                     : "memory");
-    return value;
-}
-
-void __atomic_store_8(atomic_uint64_t *p, uint64_t value)
-{
-    __asm__ volatile("lock cmpxchg8b %0"
-                     : "=m"(p->value)
-                     : "a"((uint32_t)value), "d"((uint32_t)(value >> 32)), "m"(*p)
-                     : "memory");
-}
-
-/* FIXME: __fixsfsi is not implemented correctly(?) */
-int __fixsfsi(float a) { return (int)a; }
-
-int __ltsf2(float a, float b) { return a < b; }
-int __eqsf2(float a, float b) { return a == b; }
-float __divsf3(float a, float b) { return a / b; }
-double __extendsfdf2(float a) { return (double)a; }
-float __truncdfsf2(double a) { return (float)a; }
-float __subsf3(float a, float b) { return a - b; }
-float __floatsisf(int a) { return (float)a; }
-int __fixunssfsi(float a) { return (int)a; }
-float __mulsf3(float a, float b) { return a * b; }
-float __addsf3(float a, float b) { return a + b; }
--- a/Kernel/Architecture/i686/Bootstrap/MB2.asm
+++ b/Kernel/Architecture/i686/Bootstrap/MB2.asm
@@ -1,54 +0,0 @@
-; https://wiki.osdev.org/Higher_Half_x86_Bare_Bones
-; https://wiki.osdev.org/Higher_Half_x86_Bare_Bones_(Backup)
-
-KERNEL_VIRTUAL_BASE equ 0xC0000000 ; 3GB
-KERNEL_STACK_SIZE equ 0x4000 ; 16KB
-
-extern Multiboot2Entry
-extern BootPageTable
-global MB2_start
-
-section .text
-MB2_start:
-	cli
-    mov word [0xb8F00], 0x072E ; .
-
-	mov ecx, (BootPageTable - KERNEL_VIRTUAL_BASE)
-	mov cr3, ecx
-
-    mov word [0xb8F02], 0x072E ; .
-
-	mov ecx, cr4
-	or ecx, 0x00000010 ; Set PSE in CR4
-	mov cr4, ecx
-
-    mov word [0xb8F04], 0x072E ; .
-
-	mov ecx, cr0
-	or ecx, 0x80000000 ; Set PG in CR0
-	mov cr0, ecx
-
-    mov word [0xb8F06], 0x072E ; .
-
-	lea ecx, [HigherHalfStart]
-	jmp ecx
-
-HigherHalfStart:
-    mov word [0xb8F08], 0x072E ; .
-    mov dword [BootPageTable], 0
-    invlpg [0]
-
-	mov esp, KernelStack + KERNEL_STACK_SIZE
-
-	push eax ; Multiboot2 Magic
-	add ebx, KERNEL_VIRTUAL_BASE
-	push ebx ; Multiboot2 Header
-	call Multiboot2Entry
-Loop:
-	hlt
-    jmp Loop
-
-section .bss
-align 16
-KernelStack: 
-	resb KERNEL_STACK_SIZE
--- a/Kernel/Architecture/i686/Bootstrap/MB2Header.asm
+++ b/Kernel/Architecture/i686/Bootstrap/MB2Header.asm
@@ -1,41 +0,0 @@
-section .multiboot2
-align 4096
-HEADER_START:
-    dd 0xE85250D6
-    dd 0
-    dd (HEADER_END - HEADER_START)
-    dd 0x100000000 - (HEADER_END - HEADER_START) - 0 - 0xE85250D6
-align 8
-MB2_INFO_REQUEST_TAG_START:
-    dw 1
-    dw 0
-    dd MB2_INFO_REQUEST_TAG_END - MB2_INFO_REQUEST_TAG_START
-    dd 1 ; Command Line
-    dd 2 ; Boot Loader Name
-    dd 3 ; Module
-    dd 4 ; Basic Memory Information
-    dd 5 ; BIOS Boot Device
-    dd 6 ; Memory Map
-    dd 7 ; VBE
-    dd 8 ; Framebuffer
-    dd 9 ; ELF Sections
-    dd 10 ; APM Table
-    dd 11 ; EFI 32-bit System Table Pointer
-    dd 12 ; EFI 64-bit System Table Pointer
-    ; dd 13 ; SMBIOS
-    dd 14 ; ACPI Old
-    dd 15 ; ACPI New
-    dd 16 ; Network
-    dd 17 ; EFI Memory Map
-    dd 18 ; EFI Boot Services Notifier
-    dd 19 ; EFI 32-bit Image Handle Pointer
-    dd 20 ; EFI 64-bit Image Handle Pointer
-    dd 21 ; Load Base Address
-MB2_INFO_REQUEST_TAG_END:
-align 8
-MB2_TAG_START:
-    dw 0
-    dw 0
-    dd MB2_TAG_END - MB2_TAG_START
-MB2_TAG_END:
-HEADER_END:
--- a/Kernel/Architecture/i686/Bootstrap/MB2PageTable.asm
+++ b/Kernel/Architecture/i686/Bootstrap/MB2PageTable.asm
@@ -1,13 +0,0 @@
-KERNEL_VIRTUAL_BASE equ 0xC0000000 ; 3GB
-KERNEL_PAGE_NUMBER equ (KERNEL_VIRTUAL_BASE >> 22) ; 768
-
-section .data
-global BootPageTable
-align 0x1000
-BootPageTable:
-    dd 0x00000083
-    dd 0x00000083
-    times (KERNEL_PAGE_NUMBER - 2) dd 0
-    dd 0x00000083
-    dd 0x00000083
-    times (1024 - KERNEL_PAGE_NUMBER - 2) dd 0
--- a/Kernel/Architecture/i686/Bootstrap/Multiboot2.cpp
+++ b/Kernel/Architecture/i686/Bootstrap/Multiboot2.cpp
@@ -1,339 +0,0 @@
-#include <types.h>
-
-#include <boot/protocols/multiboot2.h>
-#include <memory.hpp>
-#include <io.h>
-
-#include "../../../kernel.h"
-
-BootInfo mb2binfo;
-
-enum VideoType
-{
-    VIDEO_TYPE_NONE = 0x00,
-    VIDEO_TYPE_COLOUR = 0x20,
-    VIDEO_TYPE_MONOCHROME = 0x30,
-};
-
-uint16_t GetBiosAreaHardware()
-{
-    const uint16_t *BIOSDataAreaDetectedHardware = (const uint16_t *)0x410;
-    return *BIOSDataAreaDetectedHardware;
-}
-
-enum VideoType GetVideoType() { return (enum VideoType)(GetBiosAreaHardware() & 0x30); }
-
-void GetSMBIOS()
-{
-    unsigned char *SMBIOSAddress = (unsigned char *)0xF0000;
-    while ((unsigned int)(unsigned long)SMBIOSAddress < 0x100000)
-    {
-        if (SMBIOSAddress[0] == '_' &&
-            SMBIOSAddress[1] == 'S' &&
-            SMBIOSAddress[2] == 'M' &&
-            SMBIOSAddress[3] == '_')
-        {
-            unsigned char Checksum = 0;
-            int Length = SMBIOSAddress[5];
-            for (int i = 0; i < Length; i++)
-                Checksum += SMBIOSAddress[i];
-
-            if (Checksum == 0)
-                break;
-        }
-        SMBIOSAddress += 16;
-    }
-
-    if ((unsigned int)(unsigned long)SMBIOSAddress == 0x100000)
-    {
-        // No SMBIOS found
-    }
-}
-
-void ProcessMB2(unsigned long Info)
-{
-    uint8_t *VideoBuffer = (uint8_t *)0xB8F00 + 0xC0000000;
-    int pos = 0;
-    auto InfoAddress = Info;
-    for (auto Tag = (struct multiboot_tag *)((uint8_t *)InfoAddress + 8);
-         ;
-         Tag = (struct multiboot_tag *)((multiboot_uint8_t *)Tag + ((Tag->size + 7) & ~7)))
-    {
-        VideoBuffer[pos++] = '.';
-        VideoBuffer[pos++] = 0x2;
-
-        if (Tag->type == MULTIBOOT_TAG_TYPE_END)
-        {
-            debug("End of multiboot2 tags");
-            break;
-        }
-
-        switch (Tag->type)
-        {
-        case MULTIBOOT_TAG_TYPE_CMDLINE:
-        {
-            strncpy(mb2binfo.Kernel.CommandLine,
-                    ((multiboot_tag_string *)Tag)->string,
-                    strlen(((multiboot_tag_string *)Tag)->string));
-            debug("Kernel command line: %s", mb2binfo.Kernel.CommandLine);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME:
-        {
-            strncpy(mb2binfo.Bootloader.Name,
-                    ((multiboot_tag_string *)Tag)->string,
-                    strlen(((multiboot_tag_string *)Tag)->string));
-            debug("Bootloader name: %s", mb2binfo.Bootloader.Name);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_MODULE:
-        {
-            multiboot_tag_module *module = (multiboot_tag_module *)Tag;
-            static int module_count = 0;
-            mb2binfo.Modules[module_count++].Address = (void *)module->mod_start;
-            mb2binfo.Modules[module_count++].Size = module->size;
-            strncpy(mb2binfo.Modules[module_count++].Path, "(null)", 6);
-            strncpy(mb2binfo.Modules[module_count++].CommandLine, module->cmdline,
-                    strlen(module->cmdline));
-            debug("Module: %s", mb2binfo.Modules[module_count++].Path);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO:
-        {
-            multiboot_tag_basic_meminfo *meminfo = (multiboot_tag_basic_meminfo *)Tag;
-            fixme("basic_meminfo->[mem_lower: %#x, mem_upper: %#x]",
-                  meminfo->mem_lower, meminfo->mem_upper);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_BOOTDEV:
-        {
-            multiboot_tag_bootdev *bootdev = (multiboot_tag_bootdev *)Tag;
-            fixme("bootdev->[biosdev: %#x, slice: %#x, part: %#x]",
-                  bootdev->biosdev, bootdev->slice, bootdev->part);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_MMAP:
-        {
-            multiboot_tag_mmap *mmap = (multiboot_tag_mmap *)Tag;
-            uint32_t EntryCount = mmap->size / sizeof(multiboot_mmap_entry);
-            mb2binfo.Memory.Entries = EntryCount;
-            for (uint32_t i = 0; i < EntryCount; i++)
-            {
-                if (EntryCount > MAX_MEMORY_ENTRIES)
-                {
-                    warn("Too many memory entries, skipping the rest...");
-                    break;
-                }
-                multiboot_mmap_entry entry = mmap->entries[i];
-                mb2binfo.Memory.Size += entry.len;
-                switch (entry.type)
-                {
-                case MULTIBOOT_MEMORY_AVAILABLE:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = Usable;
-                    break;
-                case MULTIBOOT_MEMORY_RESERVED:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = Reserved;
-                    break;
-                case MULTIBOOT_MEMORY_ACPI_RECLAIMABLE:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = ACPIReclaimable;
-                    break;
-                case MULTIBOOT_MEMORY_NVS:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = ACPINVS;
-                    break;
-                case MULTIBOOT_MEMORY_BADRAM:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = BadMemory;
-                    break;
-                default:
-                    mb2binfo.Memory.Entry[i].BaseAddress = (void *)entry.addr;
-                    mb2binfo.Memory.Entry[i].Length = entry.len;
-                    mb2binfo.Memory.Entry[i].Type = Unknown;
-                    break;
-                }
-                debug("Memory entry: [BaseAddress: %#x, Length: %#x, Type: %d]",
-                      mb2binfo.Memory.Entry[i].BaseAddress,
-                      mb2binfo.Memory.Entry[i].Length,
-                      mb2binfo.Memory.Entry[i].Type);
-            }
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_VBE:
-        {
-            multiboot_tag_vbe *vbe = (multiboot_tag_vbe *)Tag;
-            fixme("vbe->[vbe_mode: %#x, vbe_interface_seg: %#x, vbe_interface_off: %#x, vbe_interface_len: %#x]",
-                  vbe->vbe_mode, vbe->vbe_interface_seg, vbe->vbe_interface_off, vbe->vbe_interface_len);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
-        {
-            multiboot_tag_framebuffer *fb = (multiboot_tag_framebuffer *)Tag;
-            static int fb_count = 0;
-            mb2binfo.Framebuffer[fb_count].BaseAddress = (void *)fb->common.framebuffer_addr;
-            mb2binfo.Framebuffer[fb_count].Width = fb->common.framebuffer_width;
-            mb2binfo.Framebuffer[fb_count].Height = fb->common.framebuffer_height;
-            mb2binfo.Framebuffer[fb_count].Pitch = fb->common.framebuffer_pitch;
-            mb2binfo.Framebuffer[fb_count].BitsPerPixel = fb->common.framebuffer_bpp;
-            mb2binfo.Framebuffer[fb_count].MemoryModel = fb->common.framebuffer_type;
-            switch (fb->common.framebuffer_type)
-            {
-            case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED:
-            {
-                fixme("indexed");
-                break;
-            }
-            case MULTIBOOT_FRAMEBUFFER_TYPE_RGB:
-            {
-                mb2binfo.Framebuffer[fb_count].RedMaskSize = fb->framebuffer_red_mask_size;
-                mb2binfo.Framebuffer[fb_count].RedMaskShift = fb->framebuffer_red_field_position;
-                mb2binfo.Framebuffer[fb_count].GreenMaskSize = fb->framebuffer_green_mask_size;
-                mb2binfo.Framebuffer[fb_count].GreenMaskShift = fb->framebuffer_green_field_position;
-                mb2binfo.Framebuffer[fb_count].BlueMaskSize = fb->framebuffer_blue_mask_size;
-                mb2binfo.Framebuffer[fb_count].BlueMaskShift = fb->framebuffer_blue_field_position;
-                break;
-            }
-            case MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT:
-            {
-                fixme("ega_text");
-                break;
-            }
-            }
-            debug("Framebuffer %d: %dx%d %d bpp", Tag, fb->common.framebuffer_width, fb->common.framebuffer_height, fb->common.framebuffer_bpp);
-            debug("More info:\nAddress: %p\nPitch: %lld\nMemoryModel: %d\nRedMaskSize: %d\nRedMaskShift: %d\nGreenMaskSize: %d\nGreenMaskShift: %d\nBlueMaskSize: %d\nBlueMaskShift: %d",
-                  fb->common.framebuffer_addr, fb->common.framebuffer_pitch, fb->common.framebuffer_type,
-                  fb->framebuffer_red_mask_size, fb->framebuffer_red_field_position, fb->framebuffer_green_mask_size,
-                  fb->framebuffer_green_field_position, fb->framebuffer_blue_mask_size, fb->framebuffer_blue_field_position);
-            fb_count++;
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_ELF_SECTIONS:
-        {
-            multiboot_tag_elf_sections *elf = (multiboot_tag_elf_sections *)Tag;
-            fixme("elf_sections->[num=%d, size=%d, entsize=%d, shndx=%d]",
-                  elf->num, elf->size, elf->entsize, elf->shndx);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_APM:
-        {
-            multiboot_tag_apm *apm = (multiboot_tag_apm *)Tag;
-            fixme("apm->[version: %d, cseg: %d, offset: %d, cseg_16: %d, dseg: %d, flags: %d, cseg_len: %d, cseg_16_len: %d, dseg_len: %d]",
-                  apm->version, apm->cseg, apm->offset, apm->cseg_16, apm->dseg, apm->flags, apm->cseg_len, apm->cseg_16_len, apm->dseg_len);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI32:
-        {
-            multiboot_tag_efi32 *efi32 = (multiboot_tag_efi32 *)Tag;
-            fixme("efi32->[pointer: %p, size: %d]", efi32->pointer, efi32->size);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI64:
-        {
-            multiboot_tag_efi64 *efi64 = (multiboot_tag_efi64 *)Tag;
-            fixme("efi64->[pointer: %p, size: %d]", efi64->pointer, efi64->size);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_SMBIOS:
-        {
-            multiboot_tag_smbios *smbios = (multiboot_tag_smbios *)Tag;
-            fixme("smbios->[major: %d, minor: %d]", smbios->major, smbios->minor);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_ACPI_OLD:
-        {
-            mb2binfo.RSDP = (BootInfo::RSDPInfo *)((multiboot_tag_old_acpi *)Tag)->rsdp;
-            debug("OLD ACPI RSDP: %p", mb2binfo.RSDP);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_ACPI_NEW:
-        {
-            mb2binfo.RSDP = (BootInfo::RSDPInfo *)((multiboot_tag_new_acpi *)Tag)->rsdp;
-            debug("NEW ACPI RSDP: %p", mb2binfo.RSDP);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_NETWORK:
-        {
-            multiboot_tag_network *net = (multiboot_tag_network *)Tag;
-            fixme("network->[dhcpack: %p]", net->dhcpack);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI_MMAP:
-        {
-            multiboot_tag_efi_mmap *efi_mmap = (multiboot_tag_efi_mmap *)Tag;
-            fixme("efi_mmap->[descr_size: %d, descr_vers: %d, efi_mmap: %p]",
-                  efi_mmap->descr_size, efi_mmap->descr_vers, efi_mmap->efi_mmap);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI_BS:
-        {
-            fixme("efi_bs->[%p] (unknown structure)", Tag);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI32_IH:
-        {
-            multiboot_tag_efi32_ih *efi32_ih = (multiboot_tag_efi32_ih *)Tag;
-            fixme("efi32_ih->[pointer: %p]", efi32_ih->pointer);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_EFI64_IH:
-        {
-            multiboot_tag_efi64_ih *efi64_ih = (multiboot_tag_efi64_ih *)Tag;
-            fixme("efi64_ih->[pointer: %p]", efi64_ih->pointer);
-            break;
-        }
-        case MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR:
-        {
-            multiboot_tag_load_base_addr *load_base_addr = (multiboot_tag_load_base_addr *)Tag;
-            mb2binfo.Kernel.PhysicalBase = (void *)load_base_addr->load_base_addr;
-            mb2binfo.Kernel.VirtualBase = (void *)(load_base_addr->load_base_addr + 0xC0000000);
-            debug("Kernel base: %p (physical) %p (virtual)", mb2binfo.Kernel.PhysicalBase, mb2binfo.Kernel.VirtualBase);
-            break;
-        }
-        default:
-        {
-            error("Unknown multiboot2 tag type: %d", Tag->type);
-            break;
-        }
-        }
-    }
-}
-
-EXTERNC void Multiboot2Entry(unsigned long Info, unsigned int Magic)
-{
-    if (Info == NULL || Magic == NULL)
-    {
-        if (Magic == NULL)
-            error("Multiboot magic is NULL");
-        if (Info == NULL)
-            error("Multiboot info is NULL");
-        CPU::Stop();
-    }
-    else if (Magic != MULTIBOOT2_BOOTLOADER_MAGIC)
-    {
-        error("Multiboot magic is invalid (%#x != %#x)", Magic, MULTIBOOT2_BOOTLOADER_MAGIC);
-        CPU::Stop();
-    }
-
-    uint64_t div = 1193180 / 1000;
-    outb(0x43, 0xB6);
-    outb(0x42, (uint8_t)div);
-    outb(0x42, (uint8_t)(div >> 8));
-    uint8_t tmp = inb(0x61);
-    if (tmp != (tmp | 3))
-        outb(0x61, tmp | 3);
-
-    ProcessMB2(Info);
-
-    tmp = inb(0x61) & 0xFC;
-    outb(0x61, tmp);
-
-    CPU::Stop();
-    Entry(&mb2binfo);
-}
--- a/Kernel/Architecture/i686/Interrupts/8259PIC.cpp
+++ b/Kernel/Architecture/i686/Interrupts/8259PIC.cpp
@@ -1,123 +0,0 @@
-#include "pic.hpp"
-
-#include <io.h>
-
-namespace PIC
-{
-    PIC::PIC(uint8_t MasterCommandPort, uint8_t MasterDataPort, uint8_t SlaveCommandPort, uint8_t SlaveDataPort, uint8_t MasterOffset, uint8_t SlaveOffset)
-    {
-        this->MasterCommandPort = MasterCommandPort;
-        this->MasterDataPort = MasterDataPort;
-        this->SlaveCommandPort = SlaveCommandPort;
-        this->SlaveDataPort = SlaveDataPort;
-        this->MasterOffset = MasterOffset;
-        this->SlaveOffset = SlaveOffset;
-
-        MasterMask = 0xFF;
-        SlaveMask = 0xFF;
-
-        // ICW1
-        outb(MasterCommandPort, 0x11);
-        outb(SlaveCommandPort, 0x11);
-
-        // ICW2
-        outb(MasterDataPort, MasterOffset);
-        outb(SlaveDataPort, SlaveOffset);
-
-        // ICW3
-        outb(MasterDataPort, 0x04);
-        outb(SlaveDataPort, 0x02);
-
-        // ICW4
-        outb(MasterDataPort, 0x01);
-        outb(SlaveDataPort, 0x01);
-
-        // OCW1
-        outb(MasterDataPort, MasterMask);
-        outb(SlaveDataPort, SlaveMask);
-    }
-
-    PIC::~PIC()
-    {
-        outb(MasterDataPort, 0xFF);
-        outb(SlaveDataPort, 0xFF);
-    }
-
-    void PIC::Mask(uint8_t IRQ)
-    {
-        uint16_t Port;
-        uint8_t Value;
-
-        if (IRQ < 8)
-        {
-            Port = MasterDataPort;
-            Value = MasterMask & ~(1 << IRQ);
-            MasterMask = Value;
-        }
-        else
-        {
-            Port = SlaveDataPort;
-            Value = SlaveMask & ~(1 << (IRQ - 8));
-            SlaveMask = Value;
-        }
-
-        outb(Port, Value);
-    }
-
-    void PIC::Unmask(uint8_t IRQ)
-    {
-        uint16_t Port;
-        uint8_t Value;
-
-        if (IRQ < 8)
-        {
-            Port = MasterDataPort;
-            Value = MasterMask | (1 << IRQ);
-            MasterMask = Value;
-        }
-        else
-        {
-            Port = SlaveDataPort;
-            Value = SlaveMask | (1 << (IRQ - 8));
-            SlaveMask = Value;
-        }
-
-        outb(Port, Value);
-    }
-
-    void PIC::SendEOI(uint8_t IRQ)
-    {
-        if (IRQ >= 8)
-            outb(SlaveCommandPort, 0x20);
-
-        outb(MasterCommandPort, 0x20);
-    }
-
-    PIT::PIT(uint16_t Port, uint16_t Frequency)
-    {
-        this->Port = Port;
-        this->Frequency = Frequency;
-    }
-
-    PIT::~PIT()
-    {
-    }
-
-    void PIT::PrepareSleep(uint32_t Milliseconds)
-    {
-        uint16_t Divisor = 1193182 / Frequency;
-        uint8_t Low = (uint8_t)(Divisor & 0xFF);
-        uint8_t High = (uint8_t)((Divisor >> 8) & 0xFF);
-
-        outb(Port + 3, 0x36);
-        outb(Port + 0, Low);
-        outb(Port + 1, High);
-    }
-
-    void PIT::PerformSleep()
-    {
-        uint8_t Value = inb(Port + 0);
-        while (Value != 0)
-            Value = inb(Port + 0);
-    }
-}
--- a/Kernel/Architecture/i686/Interrupts/pic.hpp
+++ b/Kernel/Architecture/i686/Interrupts/pic.hpp
@@ -1,42 +0,0 @@
-#ifndef __FENNIX_KERNEL_8259PIC_H__
-#define __FENNIX_KERNEL_8259PIC_H__
-
-#include <types.h>
-
-namespace PIC
-{
-    class PIC
-    {
-    private:
-        uint8_t MasterCommandPort;
-        uint8_t MasterDataPort;
-        uint8_t SlaveCommandPort;
-        uint8_t SlaveDataPort;
-        uint8_t MasterOffset;
-        uint8_t SlaveOffset;
-        uint8_t MasterMask;
-        uint8_t SlaveMask;
-
-    public:
-        PIC(uint8_t MasterCommandPort, uint8_t MasterDataPort, uint8_t SlaveCommandPort, uint8_t SlaveDataPort, uint8_t MasterOffset, uint8_t SlaveOffset);
-        ~PIC();
-        void Mask(uint8_t IRQ);
-        void Unmask(uint8_t IRQ);
-        void SendEOI(uint8_t IRQ);
-    };
-
-    class PIT
-    {
-    private:
-        uint16_t Port;
-        uint16_t Frequency;
-
-    public:
-        PIT(uint16_t Port, uint16_t Frequency);
-        ~PIT();
-        void PrepareSleep(uint32_t Milliseconds);
-        void PerformSleep();
-    };
-}
-
-#endif // !__FENNIX_KERNEL_8259PIC_H__
--- a/Kernel/Architecture/i686/SystemCalls.cpp
+++ b/Kernel/Architecture/i686/SystemCalls.cpp
@@ -1,13 +0,0 @@
-#include <syscalls.hpp>
-
-#include <cpu.hpp>
-
-#include "cpu/gdt.hpp"
-
-using namespace CPU::x32;
-
-extern "C" uint32_t SystemCallsHandler(SyscallsFrame *regs);
-
-void InitializeSystemCalls()
-{
-}
--- a/Kernel/Architecture/i686/cpu/GlobalDescriptorTable.cpp
+++ b/Kernel/Architecture/i686/cpu/GlobalDescriptorTable.cpp
@@ -1,99 +0,0 @@
-#include "gdt.hpp"
-
-#include <memory.hpp>
-#include <smp.hpp>
-#include <cpu.hpp>
-#include <debug.h>
-
-namespace GlobalDescriptorTable
-{
-    static GlobalDescriptorTableEntries GDTEntriesTemplate = {
-        // null
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.Raw = 0x0},
-         .Flags = {.Raw = 0x0},
-         .BaseHigh = 0x0},
-
-        // kernel code
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 1,
-                    .S = 1,
-                    .DPL = 0,
-                    .P = 1},
-         .Flags = {.Unknown = 0x0, .L = 1},
-         .BaseHigh = 0x0},
-
-        // kernel data
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 0,
-                    .S = 1,
-                    .DPL = 0,
-                    .P = 1},
-         .Flags = {.Raw = 0x0},
-         .BaseHigh = 0x0},
-
-        // user data
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 0,
-                    .S = 1,
-                    .DPL = 3,
-                    .P = 1},
-         .Flags = {.Raw = 0x0},
-         .BaseHigh = 0x0},
-
-        // user code
-        {.Length = 0x0,
-         .BaseLow = 0x0,
-         .BaseMiddle = 0x0,
-         .Access = {.A = 0,
-                    .RW = 1,
-                    .DC = 0,
-                    .E = 1,
-                    .S = 1,
-                    .DPL = 3,
-                    .P = 1},
-         .Flags = {.Unknown = 0x0, .L = 1},
-         .BaseHigh = 0x0},
-
-        // tss
-        {}};
-
-    GlobalDescriptorTableEntries GDTEntries[MAX_CPU];
-    GlobalDescriptorTableDescriptor gdt[MAX_CPU];
-
-    TaskStateSegment tss[MAX_CPU] = {
-        0,
-        {0, 0, 0},
-        0,
-        {0, 0, 0, 0, 0, 0, 0},
-        0,
-        0,
-    };
-
-    void *CPUStackPointer[MAX_CPU];
-
-    SafeFunction void Init(int Core)
-    {
-    }
-
-    SafeFunction void SetKernelStack(void *Stack)
-    {
-    }
-}
--- a/Kernel/Architecture/i686/cpu/SymmetricMultiprocessing.cpp
+++ b/Kernel/Architecture/i686/cpu/SymmetricMultiprocessing.cpp
@@ -1,37 +0,0 @@
-#include <smp.hpp>
-
-#include <ints.hpp>
-#include <memory.hpp>
-#include <assert.h>
-#include <cpu.hpp>
-
-#include "../../../kernel.h"
-
-volatile bool CPUEnabled = false;
-
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-static __attribute__((aligned(PAGE_SIZE))) CPUData CPUs[MAX_CPU] = {0};
-
-CPUData *GetCPU(uint64_t id) { return &CPUs[id]; }
-
-CPUData *GetCurrentCPU()
-{
-    uint64_t ret = 0;
-    if (!(&CPUs[ret])->IsActive)
-    {
-        error("CPU %d is not active!", ret);
-        return &CPUs[0];
-    }
-    assert((&CPUs[ret])->Checksum == CPU_DATA_CHECKSUM);
-    return &CPUs[ret];
-}
-
-namespace SMP
-{
-    int CPUCores = 0;
-
-    void Initialize(void *madt)
-    {
-        fixme("SMP::Initialize() is not implemented!");
-    }
-}
--- a/Kernel/Architecture/i686/cpu/apic.hpp
+++ b/Kernel/Architecture/i686/cpu/apic.hpp
@@ -1,337 +0,0 @@
-#ifndef __FENNIX_KERNEL_APIC_H__
-#define __FENNIX_KERNEL_APIC_H__
-
-#include <types.h>
-
-#include <ints.hpp>
-#include <cpu.hpp>
-
-namespace APIC
-{
-    enum APICRegisters
-    {
-        // source from: https://github.com/pdoane/osdev/blob/master/intr/local_apic.c
-        APIC_ID = 0x20,       // Local APIC ID
-        APIC_VER = 0x30,      // Local APIC Version
-        APIC_TPR = 0x80,      // Task Priority
-        APIC_APR = 0x90,      // Arbitration Priority
-        APIC_PPR = 0xA0,      // Processor Priority
-        APIC_EOI = 0xB0,      // EOI
-        APIC_RRD = 0xC0,      // Remote Read
-        APIC_LDR = 0xD0,      // Logical Destination
-        APIC_DFR = 0xE0,      // Destination Format
-        APIC_SVR = 0xF0,      // Spurious Interrupt Vector
-        APIC_ISR = 0x100,     // In-Service (8 registers)
-        APIC_TMR = 0x180,     // Trigger Mode (8 registers)
-        APIC_IRR = 0x200,     // Interrupt Request (8 registers)
-        APIC_ESR = 0x280,     // Error Status
-        APIC_ICRLO = 0x300,   // Interrupt Command
-        APIC_ICRHI = 0x310,   // Interrupt Command [63:32]
-        APIC_TIMER = 0x320,   // LVT Timer
-        APIC_THERMAL = 0x330, // LVT Thermal Sensor
-        APIC_PERF = 0x340,    // LVT Performance Counter
-        APIC_LINT0 = 0x350,   // LVT LINT0
-        APIC_LINT1 = 0x360,   // LVT LINT1
-        APIC_ERROR = 0x370,   // LVT Error
-        APIC_TICR = 0x380,    // Initial Count (for Timer)
-        APIC_TCCR = 0x390,    // Current Count (for Timer)
-        APIC_TDCR = 0x3E0,    // Divide Configuration (for Timer)
-    };
-
-    enum IOAPICRegisters
-    {
-        GetIOAPICVersion = 0x1
-    };
-
-    enum IOAPICFlags
-    {
-        ActiveHighLow = 2,
-        EdgeLevel = 8
-    };
-
-    enum APICDeliveryMode
-    {
-        Fixed = 0b000,
-        LowestPriority = 0b001, /* Reserved */
-        SMI = 0b010,
-        APIC_DELIVERY_MODE_RESERVED0 = 0b011, /* Reserved */
-        NMI = 0b100,
-        INIT = 0b101,
-        Startup = 0b110,
-        ExtINT = 0b111 /* Reserved */
-    };
-
-    enum APICDestinationMode
-    {
-        Physical = 0b0,
-        Logical = 0b1
-    };
-
-    enum APICDeliveryStatus
-    {
-        Idle = 0b0,
-        SendPending = 0b1
-    };
-
-    enum APICLevel
-    {
-        DeAssert = 0b0,
-        Assert = 0b1
-    };
-
-    enum APICTriggerMode
-    {
-        Edge = 0b0,
-        Level = 0b1
-    };
-
-    enum APICDestinationShorthand
-    {
-        NoShorthand = 0b00,
-        Self = 0b01,
-        AllIncludingSelf = 0b10,
-        AllExcludingSelf = 0b11
-    };
-
-    enum LVTTimerDivide
-    {
-        DivideBy2 = 0b000,
-        DivideBy4 = 0b001,
-        DivideBy8 = 0b010,
-        DivideBy16 = 0b011,
-        DivideBy32 = 0b100,
-        DivideBy64 = 0b101,
-        DivideBy128 = 0b110,
-        DivideBy1 = 0b111
-    };
-
-    enum LVTTimerMask
-    {
-        Unmasked = 0b0,
-        Masked = 0b1
-    };
-
-    enum LVTTimerMode
-    {
-        OneShot = 0b00,
-        Periodic = 0b01,
-        TSCDeadline = 0b10
-    };
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Interrupt Vector */
-            uint64_t Vector : 8;
-            /** @brief Reserved */
-            uint64_t Reserved0 : 4;
-            /**
-             * @brief Delivery Status
-             *
-             * 0: Idle
-             * 1: Send Pending
-             */
-            uint64_t DeliveryStatus : 1;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 3;
-            /**
-             * @brief Mask
-             *
-             * 0: Not masked
-             * 1: Masked
-             */
-            uint64_t Mask : 1;
-            /** @brief Timer Mode
-             *
-             * 0: One-shot
-             * 1: Periodic
-             * 2: TSC-Deadline
-             */
-            uint64_t TimerMode : 1;
-            /** @brief Reserved */
-            uint64_t Reserved2 : 14;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) LVTTimer;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Spurious Vector */
-            uint64_t Vector : 8;
-            /** @brief Enable or disable APIC software */
-            uint64_t Software : 1;
-            /** @brief Focus Processor Checking */
-            uint64_t FocusProcessorChecking : 1;
-            /** @brief Reserved */
-            uint64_t Reserved : 2;
-            /** @brief Disable EOI Broadcast */
-            uint64_t DisableEOIBroadcast : 1;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 19;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) Spurious;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Interrupt Vector */
-            uint64_t Vector : 8;
-            /** @brief Delivery Mode */
-            uint64_t DeliveryMode : 3;
-            /** @brief Destination Mode
-             *
-             * 0: Physical
-             * 1: Logical
-             */
-            uint64_t DestinationMode : 1;
-            /** @brief Delivery Status
-             *
-             * @note Reserved when in x2APIC mode
-             */
-            uint64_t DeliveryStatus : 1;
-            /** @brief Reserved */
-            uint64_t Reserved0 : 1;
-            /** @brief Level
-             *
-             * 0: Deassert
-             * 1: Assert
-             */
-            uint64_t Level : 1;
-            /** @brief Trigger Mode
-             *
-             * 0: Edge
-             * 1: Level
-             */
-            uint64_t TriggerMode : 1;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 2;
-            /** @brief Destination Shorthand
-             *
-             * 0: No shorthand
-             * 1: Self
-             * 2: All including self
-             * 3: All excluding self
-             */
-            uint64_t DestinationShorthand : 2;
-            /** @brief Reserved */
-            uint64_t Reserved2 : 12;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) InterruptCommandRegisterLow;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Reserved */
-            uint64_t Reserved0 : 24;
-            /** @brief Destination */
-            uint64_t Destination : 8;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) InterruptCommandRegisterHigh;
-
-    typedef union
-    {
-        struct
-        {
-            /** @brief Interrupt Vector */
-            uint64_t Vector : 8;
-            /** @brief Delivery Mode */
-            uint64_t DeliveryMode : 3;
-            /** @brief Destination Mode
-             *
-             * 0: Physical
-             * 1: Logical
-             */
-            uint64_t DestinationMode : 1;
-            /** @brief Delivery Status */
-            uint64_t DeliveryStatus : 1;
-            /** @brief Interrupt Input Pin Polarity
-             *
-             * 0: Active High
-             * 1: Active Low
-             */
-            uint64_t Polarity : 1;
-            /** @brief Remote IRR */
-            uint64_t RemoteIRR : 1;
-            /** @brief Trigger Mode
-             *
-             * 0: Edge
-             * 1: Level
-             */
-            uint64_t TriggerMode : 1;
-            /** @brief Mask */
-            uint64_t Mask : 1;
-            /** @brief Reserved */
-            uint64_t Reserved0 : 15;
-            /** @brief Reserved */
-            uint64_t Reserved1 : 24;
-            /** @brief Destination */
-            uint64_t DestinationID : 8;
-        };
-        struct
-        {
-            uint64_t Low;
-            uint64_t High;
-        } split;
-        uint64_t raw;
-    } __attribute__((packed)) IOAPICRedirectEntry;
-
-    typedef union
-    {
-        struct
-        {
-            uint64_t Version : 8;
-            uint64_t Reserved : 8;
-            uint64_t MaximumRedirectionEntry : 8;
-            uint64_t Reserved2 : 8;
-        };
-        uint64_t raw;
-    } __attribute__((packed)) IOAPICVersion;
-
-    class APIC
-    {
-    private:
-        bool x2APICSupported = false;
-        uint64_t APICBaseAddress = 0;
-
-    public:
-        uint32_t Read(uint32_t Register);
-        void Write(uint32_t Register, uint32_t Value);
-        void IOWrite(uint64_t Base, uint32_t Register, uint32_t Value);
-        uint32_t IORead(uint64_t Base, uint32_t Register);
-        void EOI();
-        void RedirectIRQs(int CPU = 0);
-        void WaitForIPI();
-        void IPI(uint8_t CPU, InterruptCommandRegisterLow icr);
-        void SendInitIPI(uint8_t CPU);
-        void SendStartupIPI(uint8_t CPU, uint64_t StartupAddress);
-        uint32_t IOGetMaxRedirect(uint32_t APICID);
-        void RawRedirectIRQ(uint8_t Vector, uint32_t GSI, uint16_t Flags, int CPU, int Status);
-        void RedirectIRQ(int CPU, uint8_t IRQ, int Status);
-        APIC(int Core);
-        ~APIC();
-    };
-
-    class Timer : public Interrupts::Handler
-    {
-    private:
-        APIC *lapic;
-        uint64_t Ticks = 0;
-        void OnInterruptReceived(CPU::x32::TrapFrame *Frame);
-
-    public:
-        uint64_t GetTicks() { return Ticks; }
-        void OneShot(uint32_t Vector, uint64_t Miliseconds);
-        Timer(APIC *apic);
-        ~Timer();
-    };
-}
-
-#endif // !__FENNIX_KERNEL_APIC_H__
--- a/Kernel/Architecture/i686/cpu/gdt.hpp
+++ b/Kernel/Architecture/i686/cpu/gdt.hpp
@@ -1,145 +0,0 @@
-#ifndef __FENNIX_KERNEL_GDT_H__
-#define __FENNIX_KERNEL_GDT_H__
-
-#include <types.h>
-
-namespace GlobalDescriptorTable
-{
-    /** @brief The GDT Access Table
-     * @details For more information, see https://wiki.osdev.org/Global_Descriptor_Table
-     */
-    union GlobalDescriptorTableAccess
-    {
-        struct
-        {
-            /** @brief Access bit.
-             * @note The CPU sets this bit to 1 when the segment is accessed.
-             */
-            uint8_t A : 1;
-
-            /** @brief Readable bit for code segments, writable bit for data segments.
-             * @details For code segments, this bit must be 1 for the segment to be readable.
-             * @details For data segments, this bit must be 1 for the segment to be writable.
-             */
-            uint8_t RW : 1;
-
-            /** @brief Direction bit for data segments, conforming bit for code segments.
-             * @details For data segments, this bit must be 1 for the segment to grow up (higher addresses).
-             * @details For code segments, this bit must be 1 for code in the segment to be able to be executed from an equal or lower privilege level.
-             */
-            uint8_t DC : 1;
-
-            /** @brief Executable bit.
-             * @details This bit must be 1 for code-segment descriptors.
-             * @details This bit must be 0 for data-segment and system descriptors.
-             */
-            uint8_t E : 1;
-
-            /** @brief Descriptor type.
-             * @details This bit must be 0 for system descriptors.
-             * @details This bit must be 1 for code or data segment descriptor.
-             */
-            uint8_t S : 1;
-
-            /** @brief Descriptor privilege level.
-             * @details This field determines the privilege level of the segment.
-             * @details 0 = kernel mode, 3 = user mode.
-             */
-            uint8_t DPL : 2;
-
-            /** @brief Present bit.
-             * @details This bit must be 1 for all valid descriptors.
-             */
-            uint8_t P : 1;
-        } __attribute__((packed));
-        uint8_t Raw;
-    };
-
-    union GlobalDescriptorTableFlags
-    {
-        // TODO: Add more flags.
-        struct
-        {
-            /** @brief Unknown. */
-            uint8_t Unknown : 5;
-
-            /** @brief Long mode.
-             * @details If the long mode bit is clear, the segment is in 32-bit protected mode.
-             * @details If the long mode bit is set, the segment is in 64-bit long mode.
-             */
-            uint8_t L : 1;
-        } __attribute__((packed));
-        uint8_t Raw;
-    };
-
-    typedef struct _TaskStateSegmentEntry
-    {
-        /* LOW */
-        uint16_t Length;
-        uint16_t BaseLow;
-        uint8_t BaseMiddle;
-        GlobalDescriptorTableAccess Flags;
-        uint8_t Granularity;
-        uint8_t BaseHigh;
-        /* HIGH */
-        uint32_t BaseUpper;
-        uint32_t Reserved;
-    } __attribute__((packed)) TaskStateSegmentEntry;
-
-    typedef struct _TaskStateSegment
-    {
-        uint32_t Reserved0 __attribute__((aligned(16)));
-        uint64_t StackPointer[3];
-        uint64_t Reserved1;
-        uint64_t InterruptStackTable[7];
-        uint16_t Reserved2;
-        uint16_t IOMapBaseAddressOffset;
-    } __attribute__((packed)) TaskStateSegment;
-
-    typedef struct _GlobalDescriptorTableEntry
-    {
-        /** @brief Length */
-        uint16_t Length;
-        /** @brief Low Base */
-        uint16_t BaseLow;
-        /** @brief Middle Base */
-        uint8_t BaseMiddle;
-        /** @brief Access */
-        GlobalDescriptorTableAccess Access;
-        /** @brief Flags */
-        GlobalDescriptorTableFlags Flags;
-        /** @brief High Base */
-        uint8_t BaseHigh;
-    } __attribute__((packed)) GlobalDescriptorTableEntry;
-
-    typedef struct _GlobalDescriptorTableEntries
-    {
-        GlobalDescriptorTableEntry Null;
-        GlobalDescriptorTableEntry Code;
-        GlobalDescriptorTableEntry Data;
-        GlobalDescriptorTableEntry UserData;
-        GlobalDescriptorTableEntry UserCode;
-        TaskStateSegmentEntry TaskStateSegment;
-    } __attribute__((packed)) GlobalDescriptorTableEntries;
-
-    typedef struct _GlobalDescriptorTableDescriptor
-    {
-        /** @brief GDT entries length */
-        uint16_t Length;
-        /** @brief GDT entries address */
-        GlobalDescriptorTableEntries *Entries;
-    } __attribute__((packed)) GlobalDescriptorTableDescriptor;
-
-    extern void *CPUStackPointer[];
-    extern TaskStateSegment tss[];
-    void Init(int Core);
-    void SetKernelStack(void *Stack);
-}
-
-#define GDT_KERNEL_CODE offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, Code)
-#define GDT_KERNEL_DATA offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, Data)
-#define GDT_USER_CODE (offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, UserCode) | 3)
-#define GDT_USER_DATA (offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, UserData) | 3)
-#define GDT_TSS (offsetof(GlobalDescriptorTable::GlobalDescriptorTableEntries, TaskStateSegment) | 3)
-
-#endif // !__FENNIX_KERNEL_GDT_H__
--- a/Kernel/Architecture/i686/cpu/idt.hpp
+++ b/Kernel/Architecture/i686/cpu/idt.hpp
@@ -1,11 +0,0 @@
-#ifndef __FENNIX_KERNEL_IDT_H__
-#define __FENNIX_KERNEL_IDT_H__
-
-#include <types.h>
-
-namespace InterruptDescriptorTable
-{
-    void Init(int Core);
-}
-
-#endif // !__FENNIX_KERNEL_IDT_H__
--- a/Kernel/Architecture/i686/linker.ld
+++ b/Kernel/Architecture/i686/linker.ld
@@ -1,59 +0,0 @@
-OUTPUT_FORMAT(elf32-i386)
-OUTPUT_ARCH(i386)
-
-ENTRY(MB2_start)
-
-SECTIONS
-{
-    . = 0xC0100000;
-    _kernel_start = .;
-
-    .text ALIGN(4096) : AT(ADDR(.text) - 0xC0000000)
-    {
-        *(.multiboot2)
-        *(.text .text.*)
-    }
-    _kernel_text_end = .;
-
-    .data ALIGN (4096) : AT(ADDR(.data) - 0xC0000000)
-    {
-        *(.data .data.*)
-    }
-    _kernel_data_end = .;
-
-    .rodata ALIGN (4096) : AT(ADDR(.rodata) - 0xC0000000)
-    {
-        *(.rodata .rodata.*)
-    }
-    _kernel_rodata_end = .;
-
-    .init_array :
-    {
-        PROVIDE_HIDDEN(__init_array_start = .);
-        KEEP(*(.init_array .ctors))
-        KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
-        PROVIDE_HIDDEN (__init_array_end = .);
-    }
-
-    .fini_array :
-    {
-        PROVIDE_HIDDEN(__fini_array_start = .);
-        KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
-        KEEP(*(.fini_array .dtors))
-        PROVIDE_HIDDEN (__fini_array_end = .);
-    }
-    . += CONSTANT(MAXPAGESIZE);
-
-    .bss ALIGN (4096) : AT(ADDR(.bss) - 0xC0000000)
-    {
-        *(COMMON)
-        *(.bss .bss.*)
-    }
-    _kernel_end = .;
-
-    /DISCARD/ :
-    {
-        *(.comment*)
-        *(.note*)
-    }
-}
--- a/Kernel/Architecture/i686/runtime/crt0.c
+++ b/Kernel/Architecture/i686/runtime/crt0.c
@@ -1,15 +0,0 @@
-// #include <types.h>
-
-// #include <debug.h>
-
-// int Entry(void *Info);
-
-// void _start(void *Raw)
-// {
-//     error("Todo");
-//     while (1)
-//         asmv("hlt");
-//     Entry(NULL);
-//     return;
-// }
-// C stuff
--- a/Kernel/Architecture/i686/runtime/crt1.c
+++ b/Kernel/Architecture/i686/runtime/crt1.c
@@ -1,15 +0,0 @@
-#include <types.h>
-
-#include <debug.h>
-
-int Entry(void *Info);
-
-void _start(void *Raw)
-{
-    UNUSED(Raw);
-    error("ERROR! INVALID BOOT PROTOCOL!");
-    while (1)
-        asmv("hlt");
-    Entry(NULL);
-    return;
-}
--- a/Kernel/Architecture/i686/runtime/crtbegin.c
+++ b/Kernel/Architecture/i686/runtime/crtbegin.c
@@ -1 +0,0 @@
-// C++ constructor/destructor stuff
--- a/Kernel/Architecture/i686/runtime/crtend.c
+++ b/Kernel/Architecture/i686/runtime/crtend.c
@@ -1 +0,0 @@
-// C++ constructor/destructor stuff
--- a/Kernel/Architecture/i686/runtime/crti.S
+++ b/Kernel/Architecture/i686/runtime/crti.S
@@ -1,13 +0,0 @@
-.section .init
-.global _init
-.type _init, @function
-_init:
-	push %ebp
-	mov %esp, %ebp
-
-.section .fini
-.global _fini
-.type _fini, @function
-_fini:
-	push %ebp
-	mov %esp, %ebp
--- a/Kernel/Architecture/i686/runtime/crtn.S
+++ b/Kernel/Architecture/i686/runtime/crtn.S
@@ -1,7 +0,0 @@
-.section .init
-	pop %ebp
-	ret
-
-.section .fini
-	pop %ebp
-	ret
--- a/Kernel/CREDITS.md
+++ b/Kernel/CREDITS.md
@@ -0,0 +1,125 @@
+# Credits and References
+
+This project has been influenced and inspired by other projects and resources.
+
+License information can be found in the [LICENSES.md](LICENSES.md) file.
+
+## General
+- [OSDev Wiki](https://wiki.osdev.org/Main_Page)
+- [GCC x86 Built-in Functions](https://gcc.gnu.org/onlinedocs/gcc/x86-Built-in-Functions.html#x86-Built-in-Functions)
+- [GCC Common Function Attributes](https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes)
+- [LemonOS Project](https://github.com/LemonOSProject/LemonOS)
+- [ToaruOS](https://github.com/klange/toaruos)
+- [Various SIMD functions](https://wiki.osdev.org/User:01000101/optlib/)
+
+## C++ STL
+- [cppreference.com](https://cppreference.com)
+
+## Virtual terminal
+- [vtconsole](https://github.com/sleepy-monax/vtconsole)
+
+## Font
+- [Tamsyn Font](http://www.fial.com/~scott/tamsyn-font/)
+
+## CPU XCR0 Structure
+- [CPU Registers x86 - XCR0](https://wiki.osdev.org/CPU_Registers_x86#XCR0)
+
+## CPUID 0x7
+- [CPUID](https://en.wikipedia.org/wiki/CPUID)
+
+## Network
+- [Beej's Guide to Network Programming](https://web.archive.org/web/20051210132103/http://users.pcnet.ro/dmoroian/beej/Beej.html)
+- [UDP Socket Programming](https://web.archive.org/web/20060229214053/http://www.cs.rutgers.edu/~pxk/417/notes/sockets/udp.html)
+- [EtherType](https://en.wikipedia.org/wiki/EtherType)
+- [Linux Network Packet Reception](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/performance_tuning_guide/s-network-packet-reception)
+- [Linux Kernel Networking Labs](https://linux-kernel-labs.github.io/refs/heads/master/labs/networking.html)
+- [smoltcp](https://github.com/smoltcp-rs/smoltcp)
+- [Understanding Linux Network Internals](https://www.cs.unh.edu/~cruse/cs326f04/RTL8139D_DataSheet.pdf)
+- [Address Resolution Protocol (ARP)](https://en.wikipedia.org/wiki/Address_Resolution_Protocol)
+- [C++ Operators](https://en.cppreference.com/w/cpp/language/operators)
+- [Dynamic Host Configuration Protocol (DHCP)](https://en.wikipedia.org/wiki/Dynamic_Host_Configuration_Protocol)
+- [RTL8139 Programmer's Guide](https://www.cs.usfca.edu/~cruse/cs326f04/RTL8139_ProgrammersGuide.pdf)
+- [RTL8139CP Datasheet](http://realtek.info/pdf/rtl8139cp.pdf)
+- [IPv4](https://en.wikipedia.org/wiki/IPv4)
+- [ICMP Parameters](https://www.iana.org/assignments/icmp-parameters/icmp-parameters.xhtml)
+
+## Loading ELF Shared Libraries and Dynamic Linking
+- [How To Write Shared Libraries](https://www.akkadia.org/drepper/dsohowto.pdf)
+- [Dynamic Linker](https://wiki.osdev.org/Dynamic_Linker)
+- [Nightingale OS](https://github.com/tyler569/nightingale)
+- [PLT and GOT: The Key to Code Sharing and Dynamic Libraries](https://www.technovelty.org/linux/plt-and-got-the-key-to-code-sharing-and-dynamic-libraries.html)
+- [YouTube Video on Dynamic Linking](https://www.youtube.com/watch?v=kUk5pw4w0h4)
+- [Oracle: Position Independent Code](https://docs.oracle.com/cd/E19683-01/817-3677/chapter6-42444/index.html)
+- [PLT and GOT Explained](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got)
+
+## Inter-Process Communication (IPC)
+- [Oracle IPC](https://docs.oracle.com/cd/E19048-01/chorus5/806-6897/architecture-103/index.html)
+- [Inter-Process Communication in OS](https://www.scaler.com/topics/operating-system/inter-process-communication-in-os/)
+- [IPC on Wikipedia](https://en.wikipedia.org/wiki/Inter-process_communication)
+- [GeeksforGeeks IPC Guide](https://www.geeksforgeeks.org/inter-process-communication-ipc/)
+
+## PCI (Peripheral Component Interconnect)
+- [OSDev PCI](https://wiki.osdev.org/PCI)
+- [PCI Configuration Space](https://en.wikipedia.org/wiki/PCI_configuration_space)
+
+## Audio
+- [FFmpeg Audio Types](https://trac.ffmpeg.org/wiki/audio%20types)
+- [AC97 on OSDev](https://wiki.osdev.org/AC97)
+- [AC97 Revision 2.3 Specification](https://inst.eecs.berkeley.edu//~cs150/Documents/ac97_r23.pdf)
+
+## Intrinsics (x86)
+- [Microsoft x86 Intrinsics](https://learn.microsoft.com/en-us/cpp/intrinsics/x86-intrinsics-list)
+- [Intel Intrinsics Guide](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html)
+
+## CPUID Information
+- [AMD CPUID Instruction](https://www.amd.com/system/files/TechDocs/40332.pdf)
+- [CPUID Instruction Note](https://www.scss.tcd.ie/~jones/CS4021/processor-identification-cpuid-instruction-note.pdf)
+
+## SMBIOS (System Management BIOS)
+- [DMTF DSP0134](https://www.dmtf.org/dsp/DSP0134)
+- [DSP0134 Version 3.6.0](https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.6.0.pdf)
+- [OSDev SMBIOS](https://wiki.osdev.org/System_Management_BIOS)
+
+## EDBA (Effective Direct Bus Access)
+- [Memory Map (x86)](https://wiki.osdev.org/Memory_Map_(x86))
+
+## UMIP, SMAP, and SMEP
+- [Control Register on Wikipedia](https://en.wikipedia.org/wiki/Control_register)
+- [Control Register and UMIP](https://web.archive.org/web/20160312223150/http://ncsi.com/nsatc11/presentations/wednesday/emerging_technologies/fischer.pdf)
+- [Supervisor Mode Access Prevention (SMEP)](https://en.wikipedia.org/wiki/Supervisor_Mode_Access_Prevention)
+
+## Atomic Operations
+- [C++ Atomic Operations](https://en.cppreference.com/w/cpp/atomic/atomic)
+
+## ELF (Executable and Linkable Format)
+- [ELF Header Format](https://www.sco.com/developers/gabi/latest/ch4.eheader.html)
+- [ELF File Format Specification](https://refspecs.linuxfoundation.org/elf/elf.pdf)
+- [Oracle: Executable and Linkable Format](https://docs.oracle.com/cd/E19683-01/817-3677/chapter6-42444/index.html)
+- [Oracle: ELF Program Headers](https://docs.oracle.com/cd/E19683-01/816-1386/chapter6-83432/index.html)
+- [YouTube Video on ELF](https://www.youtube.com/watch?v=nC1U1LJQL8o)
+- [Stevens' UNIX Network Programming](https://stevens.netmeister.org/631/elf.html)
+- [Linux Kernel ELF Header](https://github.com/torvalds/linux/blob/master/include/uapi/linux/elf.h)
+
+## C++ ABI (Application Binary Interface)
+- [GCC libstdc++ Source](https://github.com/gcc-mirror/gcc/tree/master/libstdc%2B%2B-v3)
+- [Itanium C++ ABI](https://itanium-cxx-abi.github.io/cxx-abi/abi.html)
+
+## signal.h
+- [POSIX signal.h](https://pubs.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html)
+- [Linux signal(7) Manual](https://man7.org/linux/man-pages/man7/signal.7.html)
+
+## PS/2
+- [Scan Codes](https://www.win.tue.nl/~aeb/linux/kbd/scancodes-11.html)
+- [PS/2 Keyboard on OSDev](https://wiki.osdev.org/PS2_Keyboard)
+- [PS/2 Mouse on OSDev](https://wiki.osdev.org/PS2_Mouse)
+- [Mouse Input on OSDev](https://wiki.osdev.org/Mouse_Input)
+- [I/O Ports on OSDev](https://wiki.osdev.org/I/O_ports)
+- [PS/2 Controller on OSDev](https://wiki.osdev.org/%228042%22_PS/2_Controller)
+- [AIP on OSDev](https://wiki.osdev.org/Advanced_Integrated_Peripheral)
+
+## UART
+- [Interfacing the Serial / RS232 Port V5.0](http://www.senet.com.au/~cpeacock)
+
+---
+
+Special thanks to all contributors and the creators of the referenced projects and resources!
--- a/Kernel/Core/CPU.cpp
+++ b/Kernel/Core/CPU.cpp
@@ -1,489 +0,0 @@
-#include <cpu.hpp>
-
-#include <memory.hpp>
-#include <convert.h>
-#include <debug.h>
-#include <smp.hpp>
-
-#include "../kernel.h"
-
-namespace CPU
-{
-	static bool SSEEnabled = false;
-
-	char *Vendor()
-	{
-		static char Vendor[13];
-#if defined(a64)
-		uint32_t eax, ebx, ecx, edx;
-		x64::cpuid(0x0, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Vendor + 0, &ebx, 4);
-		memcpy_unsafe(Vendor + 4, &edx, 4);
-		memcpy_unsafe(Vendor + 8, &ecx, 4);
-#elif defined(a32)
-		uint32_t eax, ebx, ecx, edx;
-		x32::cpuid(0x0, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Vendor + 0, &ebx, 4);
-		memcpy_unsafe(Vendor + 4, &edx, 4);
-		memcpy_unsafe(Vendor + 8, &ecx, 4);
-#elif defined(aa64)
-		asmv("mrs %0, MIDR_EL1"
-			 : "=r"(Vendor[0]));
-#endif
-		return Vendor;
-	}
-
-	char *Name()
-	{
-		static char Name[49];
-#if defined(a64)
-		uint32_t eax, ebx, ecx, edx;
-		x64::cpuid(0x80000002, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Name + 0, &eax, 4);
-		memcpy_unsafe(Name + 4, &ebx, 4);
-		memcpy_unsafe(Name + 8, &ecx, 4);
-		memcpy_unsafe(Name + 12, &edx, 4);
-		x64::cpuid(0x80000003, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Name + 16, &eax, 4);
-		memcpy_unsafe(Name + 20, &ebx, 4);
-		memcpy_unsafe(Name + 24, &ecx, 4);
-		memcpy_unsafe(Name + 28, &edx, 4);
-		x64::cpuid(0x80000004, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Name + 32, &eax, 4);
-		memcpy_unsafe(Name + 36, &ebx, 4);
-		memcpy_unsafe(Name + 40, &ecx, 4);
-		memcpy_unsafe(Name + 44, &edx, 4);
-#elif defined(a32)
-		uint32_t eax, ebx, ecx, edx;
-		x32::cpuid(0x80000002, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Name + 0, &eax, 4);
-		memcpy_unsafe(Name + 4, &ebx, 4);
-		memcpy_unsafe(Name + 8, &ecx, 4);
-		memcpy_unsafe(Name + 12, &edx, 4);
-		x32::cpuid(0x80000003, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Name + 16, &eax, 4);
-		memcpy_unsafe(Name + 20, &ebx, 4);
-		memcpy_unsafe(Name + 24, &ecx, 4);
-		memcpy_unsafe(Name + 28, &edx, 4);
-		x32::cpuid(0x80000004, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Name + 32, &eax, 4);
-		memcpy_unsafe(Name + 36, &ebx, 4);
-		memcpy_unsafe(Name + 40, &ecx, 4);
-		memcpy_unsafe(Name + 44, &edx, 4);
-#elif defined(aa64)
-		asmv("mrs %0, MIDR_EL1"
-			 : "=r"(Name[0]));
-#endif
-		return Name;
-	}
-
-	char *Hypervisor()
-	{
-		static char Hypervisor[13];
-#if defined(a64)
-		uint32_t eax, ebx, ecx, edx;
-		x64::cpuid(0x40000000, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Hypervisor + 0, &ebx, 4);
-		memcpy_unsafe(Hypervisor + 4, &ecx, 4);
-		memcpy_unsafe(Hypervisor + 8, &edx, 4);
-#elif defined(a32)
-		uint32_t eax, ebx, ecx, edx;
-		x64::cpuid(0x40000000, &eax, &ebx, &ecx, &edx);
-		memcpy_unsafe(Hypervisor + 0, &ebx, 4);
-		memcpy_unsafe(Hypervisor + 4, &ecx, 4);
-		memcpy_unsafe(Hypervisor + 8, &edx, 4);
-#elif defined(aa64)
-		asmv("mrs %0, MIDR_EL1"
-			 : "=r"(Hypervisor[0]));
-#endif
-		return Hypervisor;
-	}
-
-	bool Interrupts(InterruptsType Type)
-	{
-		switch (Type)
-		{
-		case Check:
-		{
-			uintptr_t Flags;
-#if defined(a64)
-			asmv("pushfq");
-			asmv("popq %0"
-				 : "=r"(Flags));
-			return Flags & (1 << 9);
-#elif defined(a32)
-			asmv("pushfl");
-			asmv("popl %0"
-				 : "=r"(Flags));
-			return Flags & (1 << 9);
-#elif defined(aa64)
-			asmv("mrs %0, daif"
-				 : "=r"(Flags));
-			return !(Flags & (1 << 2));
-#endif
-		}
-		case Enable:
-		{
-#if defined(a64) || defined(a32)
-			asmv("sti");
-#elif defined(aa64)
-			asmv("msr daifclr, #2");
-#endif
-			return true;
-		}
-		case Disable:
-		{
-#if defined(a64) || defined(a32)
-			asmv("cli");
-#elif defined(aa64)
-			asmv("msr daifset, #2");
-#endif
-			return true;
-		}
-		}
-		return false;
-	}
-
-	void *PageTable(void *PT)
-	{
-#if defined(a64)
-		if (PT)
-			asmv("movq %0, %%cr3"
-				 :
-				 : "r"(PT));
-		else
-			asmv("movq %%cr3, %0"
-				 : "=r"(PT));
-#elif defined(a32)
-		if (PT)
-			asmv("movl %0, %%cr3"
-				 :
-				 : "r"(PT));
-		else
-			asmv("movl %%cr3, %0"
-				 : "=r"(PT));
-#elif defined(aa64)
-		if (PT)
-			asmv("msr ttbr0_el1, %0"
-				 :
-				 : "r"(PT));
-		else
-			asmv("mrs %0, ttbr0_el1"
-				 : "=r"(PT));
-#endif
-		return PT;
-	}
-
-	void InitializeFeatures(long Core)
-	{
-		bool PGESupport = false;
-		bool SSESupport = false;
-#if defined(a64)
-		static int BSP = 0;
-		x64::CR0 cr0 = x64::readcr0();
-		x64::CR4 cr4 = x64::readcr4();
-
-		if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_AMD) == 0)
-		{
-#if defined(a64)
-			CPU::x64::AMD::CPUID0x1 cpuid1amd;
-#elif defined(a32)
-			CPU::x32::AMD::CPUID0x1 cpuid1amd;
-#endif
-#if defined(a64) || defined(a32)
-			asmv("cpuid"
-				 : "=a"(cpuid1amd.EAX.raw), "=b"(cpuid1amd.EBX.raw), "=c"(cpuid1amd.ECX.raw), "=d"(cpuid1amd.EDX.raw)
-				 : "a"(0x1));
-#endif
-			if (cpuid1amd.EDX.PGE)
-				PGESupport = true;
-			if (cpuid1amd.EDX.SSE)
-				SSESupport = true;
-		}
-		else if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_INTEL) == 0)
-		{
-#if defined(a64)
-			CPU::x64::Intel::CPUID0x1 cpuid1intel;
-#elif defined(a32)
-			CPU::x32::Intel::CPUID0x1 cpuid1intel;
-#endif
-#if defined(a64) || defined(a32)
-			asmv("cpuid"
-				 : "=a"(cpuid1intel.EAX.raw), "=b"(cpuid1intel.EBX.raw), "=c"(cpuid1intel.ECX.raw), "=d"(cpuid1intel.EDX.raw)
-				 : "a"(0x1));
-#endif
-			if (cpuid1intel.EDX.PGE)
-				PGESupport = true;
-			if (cpuid1intel.EDX.SSE)
-				SSESupport = true;
-		}
-
-		if (Config.SIMD == false)
-		{
-			debug("Disabling SSE support...");
-			SSESupport = false;
-		}
-
-		if (PGESupport)
-		{
-			debug("Enabling global pages support...");
-			if (!BSP)
-				KPrint("Global Pages is supported.");
-			cr4.PGE = 1;
-		}
-
-		bool SSEEnableAfter = false;
-
-		/* Not sure if my code is not working properly or something else is the issue. */
-		if ((strcmp(Hypervisor(), x86_CPUID_VENDOR_TCG) != 0 &&
-			 strcmp(Hypervisor(), x86_CPUID_VENDOR_VIRTUALBOX) != 0) &&
-			SSESupport)
-		{
-			debug("Enabling SSE support...");
-			if (!BSP)
-				KPrint("SSE is supported.");
-			cr0.EM = 0;
-			cr0.MP = 1;
-			cr4.OSFXSR = 1;
-			cr4.OSXMMEXCPT = 1;
-
-			CPUData *CoreData = GetCPU(Core);
-			CoreData->Data.FPU = (CPU::x64::FXState *)KernelAllocator.RequestPages(TO_PAGES(sizeof(CPU::x64::FXState)));
-			memset(CoreData->Data.FPU, 0, FROM_PAGES(TO_PAGES(sizeof(CPU::x64::FXState))));
-			CoreData->Data.FPU->mxcsr = 0b0001111110000000;
-			CoreData->Data.FPU->mxcsrmask = 0b1111111110111111;
-			CoreData->Data.FPU->fcw = 0b0000001100111111;
-			CPU::x64::fxrstor(CoreData->Data.FPU);
-
-			SSEEnableAfter = true;
-		}
-
-		if (!BSP)
-			KPrint("Enabling CPU cache.");
-
-		cr0.NW = 0;
-		cr0.CD = 0;
-		cr0.WP = 1;
-
-		x64::writecr0(cr0);
-
-		// FIXME: I don't think this is reporting correctly. This has to be fixed asap.
-		debug("Enabling UMIP, SMEP & SMAP support...");
-		uint32_t eax, ebx, ecx, edx;
-		x64::cpuid(0x1, &eax, &ebx, &ecx, &edx);
-		if (edx & (1 << 2)) // https://en.wikipedia.org/wiki/Control_register
-		{
-			if (!BSP)
-				KPrint("UMIP is supported.");
-			debug("UMIP is supported.");
-			// cr4.UMIP = 1;
-		}
-		if (edx & (1 << 7)) // https://en.wikipedia.org/wiki/Control_register#SMEP
-							// https://web.archive.org/web/20160312223150/http://ncsi.com/nsatc11/presentations/wednesday/emerging_technologies/fischer.pdf
-		{
-			if (!BSP)
-				KPrint("SMEP is supported.");
-			debug("SMEP is supported.");
-			// cr4.SMEP = 1;
-		}
-		if (edx & (1 << 20)) // https://en.wikipedia.org/wiki/Supervisor_Mode_Access_Prevention
-		{
-			if (!BSP)
-				KPrint("SMAP is supported.");
-			debug("SMAP is supported.");
-			// cr4.SMAP = 1;
-		}
-		if (strcmp(Hypervisor(), x86_CPUID_VENDOR_VIRTUALBOX) != 0 &&
-			strcmp(Hypervisor(), x86_CPUID_VENDOR_TCG) != 0)
-		{
-			debug("Writing CR4...");
-			x64::writecr4(cr4);
-			debug("Wrote CR4.");
-		}
-		else
-		{
-			if (!BSP)
-			{
-				if (strcmp(Hypervisor(), x86_CPUID_VENDOR_VIRTUALBOX) == 0)
-					KPrint("VirtualBox detected. Not using UMIP, SMEP & SMAP");
-				else if (strcmp(Hypervisor(), x86_CPUID_VENDOR_TCG) == 0)
-					KPrint("QEMU (TCG) detected. Not using UMIP, SMEP & SMAP");
-			}
-		}
-		debug("Enabling PAT support...");
-		x64::wrmsr(x64::MSR_CR_PAT, 0x6 | (0x0 << 8) | (0x1 << 16));
-		if (!BSP++)
-			trace("Features for BSP initialized.");
-		if (SSEEnableAfter)
-			SSEEnabled = true;
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-	}
-
-	uintptr_t Counter()
-	{
-		// TODO: Get the counter from the x2APIC or any other timer that is available. (TSC is not available on all CPUs)
-		uintptr_t Counter;
-#if defined(a64)
-		asmv("rdtsc"
-			 : "=A"(Counter));
-#elif defined(a32)
-		asmv("rdtsc"
-			 : "=A"(Counter));
-#elif defined(aa64)
-		asmv("mrs %0, cntvct_el0"
-			 : "=r"(Counter));
-#endif
-		return Counter;
-	}
-
-	x86SIMDType CheckSIMD()
-	{
-#if defined(a32)
-		return SIMD_NONE; /* TODO: Support x86 SIMD on x32 */
-#endif
-
-		if (unlikely(!SSEEnabled))
-			return SIMD_NONE;
-
-		static x86SIMDType SIMDType = SIMD_NONE;
-
-		if (likely(SIMDType != SIMD_NONE))
-			return SIMDType;
-
-		if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_AMD) == 0)
-		{
-#if defined(a64)
-			CPU::x64::AMD::CPUID0x1 cpuid1amd;
-#elif defined(a32)
-			CPU::x32::AMD::CPUID0x1 cpuid1amd;
-#endif
-#if defined(a64) || defined(a32)
-			asmv("cpuid"
-				 : "=a"(cpuid1amd.EAX.raw), "=b"(cpuid1amd.EBX.raw), "=c"(cpuid1amd.ECX.raw), "=d"(cpuid1amd.EDX.raw)
-				 : "a"(0x1));
-#endif
-			if (cpuid1amd.ECX.SSE4_2)
-				SIMDType = SIMD_SSE42;
-			else if (cpuid1amd.ECX.SSE4_1)
-				SIMDType = SIMD_SSE41;
-			else if (cpuid1amd.ECX.SSE3)
-				SIMDType = SIMD_SSE3;
-			else if (cpuid1amd.EDX.SSE2)
-				SIMDType = SIMD_SSE2;
-			else if (cpuid1amd.EDX.SSE)
-				SIMDType = SIMD_SSE;
-
-#ifdef DEBUG
-			if (cpuid1amd.ECX.SSE4_2)
-				debug("SSE4.2 is supported.");
-			if (cpuid1amd.ECX.SSE4_1)
-				debug("SSE4.1 is supported.");
-			if (cpuid1amd.ECX.SSE3)
-				debug("SSE3 is supported.");
-			if (cpuid1amd.EDX.SSE2)
-				debug("SSE2 is supported.");
-			if (cpuid1amd.EDX.SSE)
-				debug("SSE is supported.");
-#endif
-
-			return SIMDType;
-		}
-		else if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_INTEL) == 0)
-		{
-#if defined(a64)
-			CPU::x64::Intel::CPUID0x1 cpuid1intel;
-#elif defined(a32)
-			CPU::x32::Intel::CPUID0x1 cpuid1intel;
-#endif
-#if defined(a64) || defined(a32)
-			asmv("cpuid"
-				 : "=a"(cpuid1intel.EAX.raw), "=b"(cpuid1intel.EBX.raw), "=c"(cpuid1intel.ECX.raw), "=d"(cpuid1intel.EDX.raw)
-				 : "a"(0x1));
-#endif
-			if (cpuid1intel.ECX.SSE4_2)
-				SIMDType = SIMD_SSE42;
-			else if (cpuid1intel.ECX.SSE4_1)
-				SIMDType = SIMD_SSE41;
-			else if (cpuid1intel.ECX.SSE3)
-				SIMDType = SIMD_SSE3;
-			else if (cpuid1intel.EDX.SSE2)
-				SIMDType = SIMD_SSE2;
-			else if (cpuid1intel.EDX.SSE)
-				SIMDType = SIMD_SSE;
-
-#ifdef DEBUG
-			if (cpuid1intel.ECX.SSE4_2)
-				debug("SSE4.2 is supported.");
-			if (cpuid1intel.ECX.SSE4_1)
-				debug("SSE4.1 is supported.");
-			if (cpuid1intel.ECX.SSE3)
-				debug("SSE3 is supported.");
-			if (cpuid1intel.EDX.SSE2)
-				debug("SSE2 is supported.");
-			if (cpuid1intel.EDX.SSE)
-				debug("SSE is supported.");
-#endif
-
-			return SIMDType;
-		}
-
-		return SIMD_NONE;
-	}
-
-	bool CheckSIMD(x86SIMDType Type)
-	{
-		if (unlikely(!SSEEnabled))
-			return false;
-
-		if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_AMD) == 0)
-		{
-#if defined(a64)
-			CPU::x64::AMD::CPUID0x1 cpuid1amd;
-#elif defined(a32)
-			CPU::x32::AMD::CPUID0x1 cpuid1amd;
-#endif
-#if defined(a64) || defined(a32)
-			asmv("cpuid"
-				 : "=a"(cpuid1amd.EAX.raw), "=b"(cpuid1amd.EBX.raw), "=c"(cpuid1amd.ECX.raw), "=d"(cpuid1amd.EDX.raw)
-				 : "a"(0x1));
-#endif
-			if (Type == SIMD_SSE42)
-				return cpuid1amd.ECX.SSE4_2;
-			else if (Type == SIMD_SSE41)
-				return cpuid1amd.ECX.SSE4_1;
-			else if (Type == SIMD_SSE3)
-				return cpuid1amd.ECX.SSE3;
-			else if (Type == SIMD_SSE2)
-				return cpuid1amd.EDX.SSE2;
-			else if (Type == SIMD_SSE)
-				return cpuid1amd.EDX.SSE;
-		}
-		else if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_INTEL) == 0)
-		{
-#if defined(a64)
-			CPU::x64::Intel::CPUID0x1 cpuid1intel;
-#elif defined(a32)
-			CPU::x32::Intel::CPUID0x1 cpuid1intel;
-#endif
-#if defined(a64) || defined(a32)
-			asmv("cpuid"
-				 : "=a"(cpuid1intel.EAX.raw), "=b"(cpuid1intel.EBX.raw), "=c"(cpuid1intel.ECX.raw), "=d"(cpuid1intel.EDX.raw)
-				 : "a"(0x1));
-#endif
-			if (Type == SIMD_SSE42)
-				return cpuid1intel.ECX.SSE4_2;
-			else if (Type == SIMD_SSE41)
-				return cpuid1intel.ECX.SSE4_1;
-			else if (Type == SIMD_SSE3)
-				return cpuid1intel.ECX.SSE3;
-			else if (Type == SIMD_SSE2)
-				return cpuid1intel.EDX.SSE2;
-			else if (Type == SIMD_SSE)
-				return cpuid1intel.EDX.SSE;
-		}
-
-		return false;
-	}
-}
--- a/Kernel/Core/Crash/CrashDetails.cpp
+++ b/Kernel/Core/Crash/CrashDetails.cpp
@@ -1,324 +0,0 @@
-#include "../crashhandler.hpp"
-#include "chfcts.hpp"
-
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../kernel.h"
-
-static const char *PageFaultDescriptions[8] = {
-    "Supervisory process tried to read a non-present page entry\n",
-    "Supervisory process tried to read a page and caused a protection fault\n",
-    "Supervisory process tried to write to a non-present page entry\n",
-    "Supervisory process tried to write a page and caused a protection fault\n",
-    "User process tried to read a non-present page entry\n",
-    "User process tried to read a page and caused a protection fault\n",
-    "User process tried to write to a non-present page entry\n",
-    "User process tried to write a page and caused a protection fault\n"};
-
-SafeFunction void DivideByZeroExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Divide by zero exception\n");
-    UNUSED(Frame);
-}
-
-SafeFunction void DebugExceptionHandler(CHArchTrapFrame *Frame)
-{
-    CrashHandler::EHPrint("Kernel triggered debug exception.\n");
-    UNUSED(Frame);
-}
-
-SafeFunction void NonMaskableInterruptExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("NMI exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void BreakpointExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Breakpoint exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void OverflowExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Overflow exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void BoundRangeExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Bound range exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void InvalidOpcodeExceptionHandler(CHArchTrapFrame *Frame)
-{
-    CrashHandler::EHPrint("Kernel tried to execute an invalid opcode.\n");
-    UNUSED(Frame);
-}
-
-SafeFunction void DeviceNotAvailableExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Device not available exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void DoubleFaultExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Double fault exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void CoprocessorSegmentOverrunExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Coprocessor segment overrun exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void InvalidTSSExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Invalid TSS exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void SegmentNotPresentExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Segment not present exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void StackFaultExceptionHandler(CHArchTrapFrame *Frame)
-{
-    CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
-#if defined(a64)
-    CrashHandler::EHPrint("Stack segment fault at address %#lx\n", Frame->rip);
-#elif defined(a32)
-    CrashHandler::EHPrint("Stack segment fault at address %#lx\n", Frame->eip);
-#elif defined(aa64)
-#endif
-    CrashHandler::EHPrint("External: %d\n", SelCode.External);
-    CrashHandler::EHPrint("Table: %d\n", SelCode.Table);
-    CrashHandler::EHPrint("Index: %#x\n", SelCode.Idx);
-    CrashHandler::EHPrint("Error code: %#lx\n", Frame->ErrorCode);
-}
-
-SafeFunction void GeneralProtectionExceptionHandler(CHArchTrapFrame *Frame)
-{
-    CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
-    // switch (SelCode.Table)
-    // {
-    // case CPU::x64::0b00:
-    //     memcpy(desc_tmp, "GDT", 3);
-    //     break;
-    // case CPU::x64::0b01:
-    //     memcpy(desc_tmp, "IDT", 3);
-    //     break;
-    // case CPU::x64::0b10:
-    //     memcpy(desc_tmp, "LDT", 3);
-    //     break;
-    // case CPU::x64::0b11:
-    //     memcpy(desc_tmp, "IDT", 3);
-    //     break;
-    // default:
-    //     memcpy(desc_tmp, "Unknown", 7);
-    //     break;
-    // }
-    CrashHandler::EHPrint("Kernel performed an illegal operation.\n");
-    CrashHandler::EHPrint("External: %d\n", SelCode.External);
-    CrashHandler::EHPrint("Table: %d\n", SelCode.Table);
-    CrashHandler::EHPrint("Index: %#x\n", SelCode.Idx);
-}
-
-SafeFunction void PageFaultExceptionHandler(CHArchTrapFrame *Frame)
-{
-    CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode};
-#if defined(a64)
-    CrashHandler::EHPrint("\eAFAFAFAn exception occurred at %#lx by %#lx\n", CrashHandler::PageFaultAddress, Frame->rip);
-#elif defined(a32)
-    CrashHandler::EHPrint("\eAFAFAFAn exception occurred at %#lx by %#lx\n", CrashHandler::PageFaultAddress, Frame->eip);
-#elif defined(aa64)
-#endif
-    CrashHandler::EHPrint("Page: %s\n", params.P ? "Present" : "Not Present");
-    CrashHandler::EHPrint("Write Operation: %s\n", params.W ? "Read-Only" : "Read-Write");
-    CrashHandler::EHPrint("Processor Mode: %s\n", params.U ? "User-Mode" : "Kernel-Mode");
-    CrashHandler::EHPrint("CPU Reserved Bits: %s\n", params.R ? "Reserved" : "Unreserved");
-    CrashHandler::EHPrint("Caused By An Instruction Fetch: %s\n", params.I ? "Yes" : "No");
-    CrashHandler::EHPrint("Caused By A Protection-Key Violation: %s\n", params.PK ? "Yes" : "No");
-    CrashHandler::EHPrint("Caused By A Shadow Stack Access: %s\n", params.SS ? "Yes" : "No");
-    CrashHandler::EHPrint("Caused By An SGX Violation: %s\n", params.SGX ? "Yes" : "No");
-    if (Frame->ErrorCode & 0x00000008)
-        CrashHandler::EHPrint("One or more page directory entries contain reserved bits which are set to 1.\n");
-    else
-        CrashHandler::EHPrint(PageFaultDescriptions[Frame->ErrorCode & 0b111]);
-
-#ifdef DEBUG
-    uintptr_t CheckPageFaultAddress = 0;
-    CheckPageFaultAddress = CrashHandler::PageFaultAddress;
-    if (CheckPageFaultAddress == 0)
-#ifdef a64
-        CheckPageFaultAddress = Frame->rip;
-#elif defined(a32)
-        CheckPageFaultAddress = Frame->eip;
-#elif defined(aa64)
-        CheckPageFaultAddress = 0;
-#endif
-
-#if defined(a64)
-    Memory::Virtual vma = Memory::Virtual(((Memory::PageTable4 *)CPU::x64::readcr3().raw));
-#elif defined(a32)
-    Memory::Virtual vma = Memory::Virtual(((Memory::PageTable4 *)CPU::x32::readcr3().raw));
-#elif defined(aa64)
-#endif
-    bool PageAvailable = vma.Check((void *)CheckPageFaultAddress);
-    debug("Page available (Check(...)): %s. %s",
-          PageAvailable ? "Yes" : "No",
-          (params.P && !PageAvailable) ? "CR2 == Present; Check() != Present??????" : "CR2 confirms Check() result.");
-
-    if (PageAvailable)
-    {
-        bool Present = vma.Check((void *)CheckPageFaultAddress);
-        bool ReadWrite = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::RW);
-        bool User = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::US);
-        bool WriteThrough = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::PWT);
-        bool CacheDisabled = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::PCD);
-        bool Accessed = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::A);
-        bool Dirty = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::D);
-        bool Global = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::G);
-        /* ... */
-
-        debug("Page available: %s", Present ? "Yes" : "No");
-        debug("Page read/write: %s", ReadWrite ? "Yes" : "No");
-        debug("Page user/kernel: %s", User ? "User" : "Kernel");
-        debug("Page write-through: %s", WriteThrough ? "Yes" : "No");
-        debug("Page cache disabled: %s", CacheDisabled ? "Yes" : "No");
-        debug("Page accessed: %s", Accessed ? "Yes" : "No");
-        debug("Page dirty: %s", Dirty ? "Yes" : "No");
-        debug("Page global: %s", Global ? "Yes" : "No");
-
-        if (Present)
-        {
-            uintptr_t CheckPageFaultLinearAddress = (uintptr_t)CheckPageFaultAddress;
-            CheckPageFaultLinearAddress &= 0xFFFFFFFFFFFFF000;
-            debug("%#lx -> %#lx", CheckPageFaultAddress, CheckPageFaultLinearAddress);
-
-            Memory::Virtual::PageMapIndexer Index = Memory::Virtual::PageMapIndexer((uintptr_t)CheckPageFaultLinearAddress);
-            debug("Index for %#lx is PML:%d PDPTE:%d PDE:%d PTE:%d",
-                  CheckPageFaultLinearAddress,
-                  Index.PMLIndex,
-                  Index.PDPTEIndex,
-                  Index.PDEIndex,
-                  Index.PTEIndex);
-#if defined(a64)
-            Memory::PageMapLevel4 PML4 = ((Memory::PageTable4 *)CPU::x64::readcr3().raw)->Entries[Index.PMLIndex];
-#elif defined(a32)
-            Memory::PageMapLevel4 PML4 = ((Memory::PageTable4 *)CPU::x32::readcr3().raw)->Entries[Index.PMLIndex];
-#elif defined(aa64)
-#endif
-
-            Memory::PageDirectoryPointerTableEntryPtr *PDPTE = (Memory::PageDirectoryPointerTableEntryPtr *)((uintptr_t)PML4.GetAddress() << 12);
-            Memory::PageDirectoryEntryPtr *PDE = (Memory::PageDirectoryEntryPtr *)((uintptr_t)PDPTE->Entries[Index.PDPTEIndex].GetAddress() << 12);
-            Memory::PageTableEntryPtr *PTE = (Memory::PageTableEntryPtr *)((uintptr_t)PDE->Entries[Index.PDEIndex].GetAddress() << 12);
-
-            debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s NX:%s Address:%#lx",
-                  Index.PMLIndex, 0, 0, 0,
-                  PML4.Present ? "1" : "0",
-                  PML4.ReadWrite ? "1" : "0",
-                  PML4.UserSupervisor ? "1" : "0",
-                  PML4.WriteThrough ? "1" : "0",
-                  PML4.CacheDisable ? "1" : "0",
-                  PML4.Accessed ? "1" : "0",
-                  PML4.ExecuteDisable ? "1" : "0",
-                  PML4.GetAddress() << 12);
-
-            debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s NX:%s Address:%#lx",
-                  Index.PMLIndex, Index.PDPTEIndex, 0, 0,
-                  PDPTE->Entries[Index.PDPTEIndex].Present ? "1" : "0",
-                  PDPTE->Entries[Index.PDPTEIndex].ReadWrite ? "1" : "0",
-                  PDPTE->Entries[Index.PDPTEIndex].UserSupervisor ? "1" : "0",
-                  PDPTE->Entries[Index.PDPTEIndex].WriteThrough ? "1" : "0",
-                  PDPTE->Entries[Index.PDPTEIndex].CacheDisable ? "1" : "0",
-                  PDPTE->Entries[Index.PDPTEIndex].Accessed ? "1" : "0",
-                  PDPTE->Entries[Index.PDPTEIndex].ExecuteDisable ? "1" : "0",
-                  PDPTE->Entries[Index.PDPTEIndex].GetAddress() << 12);
-
-            debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s NX:%s Address:%#lx",
-                  Index.PMLIndex, Index.PDPTEIndex, Index.PDEIndex, 0,
-                  PDE->Entries[Index.PDEIndex].Present ? "1" : "0",
-                  PDE->Entries[Index.PDEIndex].ReadWrite ? "1" : "0",
-                  PDE->Entries[Index.PDEIndex].UserSupervisor ? "1" : "0",
-                  PDE->Entries[Index.PDEIndex].WriteThrough ? "1" : "0",
-                  PDE->Entries[Index.PDEIndex].CacheDisable ? "1" : "0",
-                  PDE->Entries[Index.PDEIndex].Accessed ? "1" : "0",
-                  PDE->Entries[Index.PDEIndex].ExecuteDisable ? "1" : "0",
-                  PDE->Entries[Index.PDEIndex].GetAddress() << 12);
-
-            debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s D:%s PAT:%s G:%s PK:%d NX:%s Address:%#lx",
-                  Index.PMLIndex, Index.PDPTEIndex, Index.PDEIndex, Index.PTEIndex,
-                  PTE->Entries[Index.PTEIndex].Present ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].ReadWrite ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].UserSupervisor ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].WriteThrough ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].CacheDisable ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].Accessed ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].Dirty ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].PageAttributeTable ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].Global ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].ProtectionKey,
-                  PTE->Entries[Index.PTEIndex].ExecuteDisable ? "1" : "0",
-                  PTE->Entries[Index.PTEIndex].GetAddress() << 12);
-        }
-    }
-#endif
-}
-
-SafeFunction void x87FloatingPointExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("x87 floating point exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void AlignmentCheckExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Alignment check exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void MachineCheckExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Machine check exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void SIMDFloatingPointExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("SIMD floating point exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void VirtualizationExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Virtualization exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void SecurityExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Security exception");
-    UNUSED(Frame);
-}
-
-SafeFunction void UnknownExceptionHandler(CHArchTrapFrame *Frame)
-{
-    fixme("Unknown exception");
-    UNUSED(Frame);
-}
--- a/Kernel/Core/Crash/CrashHandler.cpp
+++ b/Kernel/Core/Crash/CrashHandler.cpp
--- a/Kernel/Core/Crash/KBDrv.cpp
+++ b/Kernel/Core/Crash/KBDrv.cpp
@@ -1,165 +0,0 @@
-#include "../crashhandler.hpp"
-#include "chfcts.hpp"
-
-#include <display.hpp>
-#include <convert.h>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-#include <io.h>
-
-#if defined(a64)
-#include "../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../kernel.h"
-
-const char sc_ascii_low[] = {'?', '?', '1', '2', '3', '4', '5', '6',
-                             '7', '8', '9', '0', '-', '=', '?', '?', 'q', 'w', 'e', 'r', 't', 'y',
-                             'u', 'i', 'o', 'p', '[', ']', '?', '?', 'a', 's', 'd', 'f', 'g',
-                             'h', 'j', 'k', 'l', ';', '\'', '`', '?', '\\', 'z', 'x', 'c', 'v',
-                             'b', 'n', 'm', ',', '.', '/', '?', '?', '?', ' '};
-
-const char sc_ascii_high[] = {'?', '?', '!', '@', '#', '$', '%', '^',
-                              '&', '*', '(', ')', '_', '+', '?', '?', 'Q', 'W', 'E', 'R', 'T', 'Y',
-                              'U', 'I', 'O', 'P', '{', '}', '?', '?', 'A', 'S', 'D', 'F', 'G',
-                              'H', 'J', 'K', 'L', ';', '\"', '~', '?', '|', 'Z', 'X', 'C', 'V',
-                              'B', 'N', 'M', '<', '>', '?', '?', '?', '?', ' '};
-
-static int LowerCase = true;
-
-static inline int GetLetterFromScanCode(uint8_t ScanCode)
-{
-    if (ScanCode & 0x80)
-    {
-        switch (ScanCode)
-        {
-        case KEY_U_LSHIFT:
-            LowerCase = true;
-            return KEY_INVALID;
-        case KEY_U_RSHIFT:
-            LowerCase = true;
-            return KEY_INVALID;
-        default:
-            return KEY_INVALID;
-        }
-    }
-    else
-    {
-        switch (ScanCode)
-        {
-        case KEY_D_RETURN:
-            return '\n';
-        case KEY_D_LSHIFT:
-            LowerCase = false;
-            return KEY_INVALID;
-        case KEY_D_RSHIFT:
-            LowerCase = false;
-            return KEY_INVALID;
-        case KEY_D_BACKSPACE:
-            return ScanCode;
-        default:
-        {
-            if (ScanCode > 0x39)
-                break;
-            if (LowerCase)
-                return sc_ascii_low[ScanCode];
-            else
-                return sc_ascii_high[ScanCode];
-        }
-        }
-    }
-    return KEY_INVALID;
-}
-
-namespace CrashHandler
-{
-    CrashKeyboardDriver::CrashKeyboardDriver() : Interrupts::Handler(CPU::x86::IRQ1)
-    {
-        while (inb(0x64) & 0x1)
-            inb(0x60);
-
-        outb(0x64, 0xAE);
-        outb(0x64, 0x20);
-        uint8_t ret = (inb(0x60) | 1) & ~0x10;
-        outb(0x64, 0x60);
-        outb(0x60, ret);
-        outb(0x60, 0xF4);
-
-        outb(0x21, 0xFD);
-        outb(0xA1, 0xFF);
-        CPU::Interrupts(CPU::Enable); // Just to be sure.
-    }
-
-    CrashKeyboardDriver::~CrashKeyboardDriver()
-    {
-        error("CrashKeyboardDriver::~CrashKeyboardDriver() called!");
-    }
-
-    int BackSpaceLimit = 0;
-    static char UserInputBuffer[1024];
-
-#if defined(a64)
-    SafeFunction void CrashKeyboardDriver::OnInterruptReceived(CPU::x64::TrapFrame *Frame)
-#elif defined(a32)
-    SafeFunction void CrashKeyboardDriver::OnInterruptReceived(CPU::x32::TrapFrame *Frame)
-#elif defined(aa64)
-    SafeFunction void CrashKeyboardDriver::OnInterruptReceived(void *Frame)
-#endif
-    {
-        UNUSED(Frame);
-        uint8_t scanCode = inb(0x60);
-        if (scanCode == KEY_D_TAB ||
-            scanCode == KEY_D_LCTRL ||
-            scanCode == KEY_D_LALT ||
-            scanCode == KEY_U_LCTRL ||
-            scanCode == KEY_U_LALT)
-            return;
-
-        switch (scanCode)
-        {
-        case KEY_D_UP:
-        case KEY_D_LEFT:
-        case KEY_D_RIGHT:
-        case KEY_D_DOWN:
-            ArrowInput(scanCode);
-        }
-
-        int key = GetLetterFromScanCode(scanCode);
-        if (key != KEY_INVALID)
-        {
-            if (key == KEY_D_BACKSPACE)
-            {
-                if (BackSpaceLimit > 0)
-                {
-                    Display->Print('\b', SBIdx);
-                    backspace(UserInputBuffer);
-                    BackSpaceLimit--;
-                }
-            }
-            else if (key == '\n')
-            {
-                UserInput(UserInputBuffer);
-                BackSpaceLimit = 0;
-                UserInputBuffer[0] = '\0';
-            }
-            else
-            {
-                append(UserInputBuffer, key);
-                Display->Print(key, SBIdx);
-                BackSpaceLimit++;
-            }
-            Display->SetBuffer(SBIdx); // Update as we type.
-        }
-    }
-
-    SafeFunction void HookKeyboard()
-    {
-        CrashKeyboardDriver kbd; // We don't want to allocate memory.
-        asmv("KeyboardHookLoop: nop; jmp KeyboardHookLoop;");
-        // CPU::Halt(true); // This is an infinite loop.
-    }
-}
--- a/Kernel/Core/Crash/SFrame.cpp
+++ b/Kernel/Core/Crash/SFrame.cpp
@@ -1,120 +0,0 @@
-#include "../crashhandler.hpp"
-#include "chfcts.hpp"
-
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../kernel.h"
-
-namespace CrashHandler
-{
-    struct StackFrame
-    {
-        struct StackFrame *rbp;
-        uintptr_t rip;
-    };
-
-    SafeFunction void TraceFrames(CHArchTrapFrame *Frame, int Count, SymbolResolver::Symbols *SymHandle, bool Kernel)
-    {
-        if (!Memory::Virtual().Check(Frame))
-        {
-            EHPrint("Invalid frame pointer: %p\n", Frame);
-            return;
-        }
-
-#if defined(a64)
-        struct StackFrame *frames = (struct StackFrame *)Frame->rbp; // (struct StackFrame *)__builtin_frame_address(0);
-        if (!Memory::Virtual().Check((void *)Frame->rbp))
-#elif defined(a32)
-        struct StackFrame *frames = (struct StackFrame *)Frame->ebp; // (struct StackFrame *)__builtin_frame_address(0);
-        if (!Memory::Virtual().Check((void *)Frame->ebp))
-#elif defined(aa64)
-#endif
-        {
-            #if defined(a64)
-            EHPrint("Invalid rbp pointer: %p\n", Frame->rbp);
-            #elif defined(a32)
-            EHPrint("Invalid ebp pointer: %p\n", Frame->ebp);
-            #elif defined(aa64)
-#endif
-            return;
-        }
-
-        if (!Memory::Virtual().Check(SymHandle))
-        {
-            EHPrint("Invalid symbol handle: %p\n", SymHandle);
-            return;
-        }
-
-        debug("\nStack tracing... %p %d %p %d", Frame, Count, frames, Kernel);
-        EHPrint("\e7981FC\nStack Trace:\n");
-        if (!frames || !frames->rip || !frames->rbp)
-        {
-#if defined(a64)
-            EHPrint("\e2565CC%p", (void *)Frame->rip);
-#elif defined(a32)
-            EHPrint("\e2565CC%p", (void *)Frame->eip);
-#elif defined(aa64)
-#endif
-            EHPrint("\e7925CC-");
-#if defined(a64)
-            EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->rip));
-#elif defined(a32)
-            EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->eip));
-#elif defined(aa64)
-#endif
-            EHPrint("\e7981FC <- Exception");
-            EHPrint("\eFF0000\n< No stack trace available. >\n");
-        }
-        else
-        {
-#if defined(a64)
-            EHPrint("\e2565CC%p", (void *)Frame->rip);
-            EHPrint("\e7925CC-");
-            if ((Frame->rip >= 0xFFFFFFFF80000000 && Frame->rip <= (uintptr_t)&_kernel_end) || !Kernel)
-                EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->rip));
-            else
-                EHPrint("Outside Kernel");
-#elif defined(a32)
-            EHPrint("\e2565CC%p", (void *)Frame->eip);
-            EHPrint("\e7925CC-");
-            if ((Frame->eip >= 0xC0000000 && Frame->eip <= (uintptr_t)&_kernel_end) || !Kernel)
-                EHPrint("\eAA25CC%s", SymHandle->GetSymbolFromAddress(Frame->eip));
-            else
-                EHPrint("Outside Kernel");
-#elif defined(aa64)
-#endif
-            EHPrint("\e7981FC <- Exception");
-            for (int frame = 0; frame < Count; ++frame)
-            {
-                if (!frames->rip)
-                    break;
-                EHPrint("\n\e2565CC%p", (void *)frames->rip);
-                EHPrint("\e7925CC-");
-#if defined(a64)
-                if ((frames->rip >= 0xFFFFFFFF80000000 && frames->rip <= (uintptr_t)&_kernel_end) || !Kernel)
-#elif defined(a32)
-                if ((frames->rip >= 0xC0000000 && frames->rip <= (uintptr_t)&_kernel_end) || !Kernel)
-#elif defined(aa64)
-#endif
-                    EHPrint("\e25CCC9%s", SymHandle->GetSymbolFromAddress(frames->rip));
-                else
-                    EHPrint("\eFF4CA9Outside Kernel");
-
-                if (!Memory::Virtual().Check(frames->rbp))
-                    return;
-                frames = frames->rbp;
-            }
-        }
-        EHPrint("\n");
-    }
-}
--- a/Kernel/Core/Crash/Screens/Console.cpp
+++ b/Kernel/Core/Crash/Screens/Console.cpp
@@ -1,25 +0,0 @@
-#include "../../crashhandler.hpp"
-#include "../chfcts.hpp"
-
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../../kernel.h"
-
-namespace CrashHandler
-{
-    SafeFunction void DisplayConsoleScreen(CRData data)
-    {
-        EHPrint("TODO");
-        UNUSED(data);
-    }
-}
--- a/Kernel/Core/Crash/Screens/Details.cpp
+++ b/Kernel/Core/Crash/Screens/Details.cpp
@@ -1,247 +0,0 @@
-#include "../../crashhandler.hpp"
-#include "../chfcts.hpp"
-
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../../kernel.h"
-
-namespace CrashHandler
-{
-    SafeFunction void DisplayDetailsScreen(CRData data)
-    {
-        if (data.Process)
-            EHPrint("\e7981FCCurrent Process: %s(%ld)\n",
-                    data.Process->Name,
-                    data.Process->ID);
-        if (data.Thread)
-            EHPrint("\e7981FCCurrent Thread: %s(%ld)\n",
-                    data.Thread->Name,
-                    data.Thread->ID);
-        EHPrint("\e7981FCTechnical Informations on CPU %lld:\n", data.ID);
-        uintptr_t ds;
-#if defined(a64)
-
-        CPUData *cpu = (CPUData *)data.CPUData;
-        if (cpu)
-        {
-            EHPrint("\eE46CEBCPU Data Address: %#lx\n", cpu);
-            EHPrint("Syscalls Stack: %#lx, TempStack: %#lx\n", cpu->SystemCallStack, cpu->TempStack);
-            EHPrint("Core Stack: %#lx, Core ID: %ld, Error Code: %ld\n", cpu->Stack, cpu->ID, cpu->ErrorCode);
-            EHPrint("Is Active: %s\n", cpu->IsActive ? "true" : "false");
-            EHPrint("Current Process: %#lx, Current Thread: %#lx\n", cpu->CurrentProcess, cpu->CurrentThread);
-            EHPrint("Arch Specific Data: %#lx\n", cpu->Data);
-            EHPrint("Checksum: 0x%X\n", cpu->Checksum);
-        }
-
-        asmv("mov %%ds, %0"
-             : "=r"(ds));
-#elif defined(a32)
-        asmv("mov %%ds, %0"
-             : "=r"(ds));
-#elif defined(aa64)
-#endif
-
-#if defined(a64)
-        EHPrint("\e7981FCFS=%#llx  GS=%#llx  SS=%#llx  CS=%#llx  DS=%#llx\n",
-                CPU::x64::rdmsr(CPU::x64::MSR_FS_BASE), CPU::x64::rdmsr(CPU::x64::MSR_GS_BASE),
-                data.Frame->ss, data.Frame->cs, ds);
-        EHPrint("R8=%#llx  R9=%#llx  R10=%#llx  R11=%#llx\n", data.Frame->r8, data.Frame->r9, data.Frame->r10, data.Frame->r11);
-        EHPrint("R12=%#llx  R13=%#llx  R14=%#llx  R15=%#llx\n", data.Frame->r12, data.Frame->r13, data.Frame->r14, data.Frame->r15);
-        EHPrint("RAX=%#llx  RBX=%#llx  RCX=%#llx  RDX=%#llx\n", data.Frame->rax, data.Frame->rbx, data.Frame->rcx, data.Frame->rdx);
-        EHPrint("RSI=%#llx  RDI=%#llx  RBP=%#llx  RSP=%#llx\n", data.Frame->rsi, data.Frame->rdi, data.Frame->rbp, data.Frame->rsp);
-        EHPrint("RIP=%#llx  RFL=%#llx  INT=%#llx  ERR=%#llx  EFER=%#llx\n", data.Frame->rip, data.Frame->rflags.raw, data.Frame->InterruptNumber, data.Frame->ErrorCode, data.efer.raw);
-#elif defined(a32)
-        EHPrint("\e7981FCFS=%#llx  GS=%#llx  SS=%#llx  CS=%#llx  DS=%#llx\n",
-                CPU::x32::rdmsr(CPU::x32::MSR_FS_BASE), CPU::x32::rdmsr(CPU::x32::MSR_GS_BASE),
-                data.Frame->ss, data.Frame->cs, ds);
-        EHPrint("EAX=%#llx  EBX=%#llx  ECX=%#llx  EDX=%#llx\n", data.Frame->eax, data.Frame->ebx, data.Frame->ecx, data.Frame->edx);
-        EHPrint("ESI=%#llx  EDI=%#llx  EBP=%#llx  ESP=%#llx\n", data.Frame->esi, data.Frame->edi, data.Frame->ebp, data.Frame->esp);
-        EHPrint("EIP=%#llx  EFL=%#llx  INT=%#llx  ERR=%#llx  EFER=%#llx\n", data.Frame->eip, data.Frame->eflags.raw, data.Frame->InterruptNumber, data.Frame->ErrorCode, data.efer.raw);
-#elif defined(aa64)
-#endif
-        EHPrint("CR0=%#llx  CR2=%#llx  CR3=%#llx  CR4=%#llx  CR8=%#llx\n", data.cr0.raw, data.cr2.raw, data.cr3.raw, data.cr4.raw, data.cr8.raw);
-        EHPrint("DR0=%#llx  DR1=%#llx  DR2=%#llx  DR3=%#llx  DR6=%#llx  DR7=%#llx\n", data.dr0, data.dr1, data.dr2, data.dr3, data.dr6, data.dr7.raw);
-
-        EHPrint("\eFC797BCR0: PE:%s     MP:%s     EM:%s     TS:%s\n     ET:%s     NE:%s     WP:%s     AM:%s\n     NW:%s     CD:%s     PG:%s\n     R0:%#x R1:%#x R2:%#x\n",
-                data.cr0.PE ? "True " : "False", data.cr0.MP ? "True " : "False", data.cr0.EM ? "True " : "False", data.cr0.TS ? "True " : "False",
-                data.cr0.ET ? "True " : "False", data.cr0.NE ? "True " : "False", data.cr0.WP ? "True " : "False", data.cr0.AM ? "True " : "False",
-                data.cr0.NW ? "True " : "False", data.cr0.CD ? "True " : "False", data.cr0.PG ? "True " : "False",
-                data.cr0.Reserved0, data.cr0.Reserved1, data.cr0.Reserved2);
-
-        EHPrint("\eFCBD79CR2: PFLA: %#llx\n",
-                data.cr2.PFLA);
-
-        EHPrint("\e79FC84CR3: PWT:%s     PCD:%s    PDBR:%#llx\n",
-                data.cr3.PWT ? "True " : "False", data.cr3.PCD ? "True " : "False", data.cr3.PDBR);
-
-        EHPrint("\eBD79FCCR4: VME:%s     PVI:%s     TSD:%s      DE:%s\n     PSE:%s     PAE:%s     MCE:%s     PGE:%s\n     PCE:%s    UMIP:%s  OSFXSR:%s OSXMMEXCPT:%s\n    LA57:%s    VMXE:%s    SMXE:%s   PCIDE:%s\n OSXSAVE:%s    SMEP:%s    SMAP:%s     PKE:%s\n     R0:%#x R1:%#x R2:%#x\n",
-                data.cr4.VME ? "True " : "False", data.cr4.PVI ? "True " : "False", data.cr4.TSD ? "True " : "False", data.cr4.DE ? "True " : "False",
-                data.cr4.PSE ? "True " : "False", data.cr4.PAE ? "True " : "False", data.cr4.MCE ? "True " : "False", data.cr4.PGE ? "True " : "False",
-                data.cr4.PCE ? "True " : "False", data.cr4.UMIP ? "True " : "False", data.cr4.OSFXSR ? "True " : "False", data.cr4.OSXMMEXCPT ? "True " : "False",
-                data.cr4.LA57 ? "True " : "False", data.cr4.VMXE ? "True " : "False", data.cr4.SMXE ? "True " : "False", data.cr4.PCIDE ? "True " : "False",
-                data.cr4.OSXSAVE ? "True " : "False", data.cr4.SMEP ? "True " : "False", data.cr4.SMAP ? "True " : "False", data.cr4.PKE ? "True " : "False",
-#if defined(a64)
-                data.cr4.Reserved0, data.cr4.Reserved1, data.cr4.Reserved2);
-#elif defined(a32)
-                data.cr4.Reserved0, data.cr4.Reserved1, 0);
-#elif defined(aa64)
-#endif
-
-        EHPrint("\e79FCF5CR8: TPL:%d\n", data.cr8.TPL);
-
-#if defined(a64)
-        EHPrint("\eFCFC02RFL: CF:%s     PF:%s     AF:%s     ZF:%s\n     SF:%s     TF:%s     IF:%s     DF:%s\n     OF:%s   IOPL:%s     NT:%s     RF:%s\n     VM:%s     AC:%s    VIF:%s    VIP:%s\n     ID:%s     AlwaysOne:%d\n     R0:%#x R1:%#x R2:%#x R3:%#x\n",
-                data.Frame->rflags.CF ? "True " : "False", data.Frame->rflags.PF ? "True " : "False", data.Frame->rflags.AF ? "True " : "False", data.Frame->rflags.ZF ? "True " : "False",
-                data.Frame->rflags.SF ? "True " : "False", data.Frame->rflags.TF ? "True " : "False", data.Frame->rflags.IF ? "True " : "False", data.Frame->rflags.DF ? "True " : "False",
-                data.Frame->rflags.OF ? "True " : "False", data.Frame->rflags.IOPL ? "True " : "False", data.Frame->rflags.NT ? "True " : "False", data.Frame->rflags.RF ? "True " : "False",
-                data.Frame->rflags.VM ? "True " : "False", data.Frame->rflags.AC ? "True " : "False", data.Frame->rflags.VIF ? "True " : "False", data.Frame->rflags.VIP ? "True " : "False",
-                data.Frame->rflags.ID ? "True " : "False", data.Frame->rflags.AlwaysOne,
-                data.Frame->rflags.Reserved0, data.Frame->rflags.Reserved1, data.Frame->rflags.Reserved2, data.Frame->rflags.Reserved3);
-#elif defined(a32)
-        EHPrint("\eFCFC02EFL: CF:%s     PF:%s     AF:%s     ZF:%s\n     SF:%s     TF:%s     IF:%s     DF:%s\n     OF:%s   IOPL:%s     NT:%s     RF:%s\n     VM:%s     AC:%s    VIF:%s    VIP:%s\n     ID:%s     AlwaysOne:%d\n     R0:%#x R1:%#x R2:%#x\n",
-                data.Frame->eflags.CF ? "True " : "False", data.Frame->eflags.PF ? "True " : "False", data.Frame->eflags.AF ? "True " : "False", data.Frame->eflags.ZF ? "True " : "False",
-                data.Frame->eflags.SF ? "True " : "False", data.Frame->eflags.TF ? "True " : "False", data.Frame->eflags.IF ? "True " : "False", data.Frame->eflags.DF ? "True " : "False",
-                data.Frame->eflags.OF ? "True " : "False", data.Frame->eflags.IOPL ? "True " : "False", data.Frame->eflags.NT ? "True " : "False", data.Frame->eflags.RF ? "True " : "False",
-                data.Frame->eflags.VM ? "True " : "False", data.Frame->eflags.AC ? "True " : "False", data.Frame->eflags.VIF ? "True " : "False", data.Frame->eflags.VIP ? "True " : "False",
-                data.Frame->eflags.ID ? "True " : "False", data.Frame->eflags.AlwaysOne,
-                data.Frame->eflags.Reserved0, data.Frame->eflags.Reserved1, data.Frame->eflags.Reserved2);
-#elif defined(aa64)
-#endif
-
-        EHPrint("\eA0F0F0DR7: LDR0:%s     GDR0:%s     LDR1:%s     GDR1:%s\n     LDR2:%s     GDR2:%s     LDR3:%s     GDR3:%s\n     CDR0:%s     SDR0:%s     CDR1:%s     SDR1:%s\n     CDR2:%s     SDR2:%s     CDR3:%s     SDR3:%s\n     R:%#x\n",
-                data.dr7.LocalDR0 ? "True " : "False", data.dr7.GlobalDR0 ? "True " : "False", data.dr7.LocalDR1 ? "True " : "False", data.dr7.GlobalDR1 ? "True " : "False",
-                data.dr7.LocalDR2 ? "True " : "False", data.dr7.GlobalDR2 ? "True " : "False", data.dr7.LocalDR3 ? "True " : "False", data.dr7.GlobalDR3 ? "True " : "False",
-                data.dr7.ConditionsDR0 ? "True " : "False", data.dr7.SizeDR0 ? "True " : "False", data.dr7.ConditionsDR1 ? "True " : "False", data.dr7.SizeDR1 ? "True " : "False",
-                data.dr7.ConditionsDR2 ? "True " : "False", data.dr7.SizeDR2 ? "True " : "False", data.dr7.ConditionsDR3 ? "True " : "False", data.dr7.SizeDR3 ? "True " : "False",
-                data.dr7.Reserved);
-
-        EHPrint("\e009FF0EFER: SCE:%s      LME:%s      LMA:%s      NXE:%s\n     SVME:%s    LMSLE:%s    FFXSR:%s      TCE:%s\n     R0:%#x R1:%#x R2:%#x\n",
-                data.efer.SCE ? "True " : "False", data.efer.LME ? "True " : "False", data.efer.LMA ? "True " : "False", data.efer.NXE ? "True " : "False",
-                data.efer.SVME ? "True " : "False", data.efer.LMSLE ? "True " : "False", data.efer.FFXSR ? "True " : "False", data.efer.TCE ? "True " : "False",
-                data.efer.Reserved0, data.efer.Reserved1, data.efer.Reserved2);
-
-        switch (data.Frame->InterruptNumber)
-        {
-        case CPU::x86::DivideByZero:
-        {
-            DivideByZeroExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::Debug:
-        {
-            DebugExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::NonMaskableInterrupt:
-        {
-            NonMaskableInterruptExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::Breakpoint:
-        {
-            BreakpointExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::Overflow:
-        {
-            OverflowExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::BoundRange:
-        {
-            BoundRangeExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::InvalidOpcode:
-        {
-            InvalidOpcodeExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::DeviceNotAvailable:
-        {
-            DeviceNotAvailableExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::DoubleFault:
-        {
-            DoubleFaultExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::CoprocessorSegmentOverrun:
-        {
-            CoprocessorSegmentOverrunExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::InvalidTSS:
-        {
-            InvalidTSSExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::SegmentNotPresent:
-        {
-            SegmentNotPresentExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::StackSegmentFault:
-        {
-            StackFaultExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::GeneralProtectionFault:
-        {
-            GeneralProtectionExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::PageFault:
-        {
-            PageFaultExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::x87FloatingPoint:
-        {
-            x87FloatingPointExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::AlignmentCheck:
-        {
-            AlignmentCheckExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::MachineCheck:
-        {
-            MachineCheckExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::SIMDFloatingPoint:
-        {
-            SIMDFloatingPointExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::Virtualization:
-        {
-            VirtualizationExceptionHandler(data.Frame);
-            break;
-        }
-        case CPU::x86::Security:
-        {
-            SecurityExceptionHandler(data.Frame);
-            break;
-        }
-        default:
-        {
-            UnknownExceptionHandler(data.Frame);
-            break;
-        }
-        }
-    }
-}
--- a/Kernel/Core/Crash/Screens/Main.cpp
+++ b/Kernel/Core/Crash/Screens/Main.cpp
@@ -1,345 +0,0 @@
-#include "../../crashhandler.hpp"
-#include "../chfcts.hpp"
-
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../../kernel.h"
-
-static const char *PagefaultDescriptions[8] = {
-    "Supervisory process tried to read a non-present page entry\n",
-    "Supervisory process tried to read a page and caused a protection fault\n",
-    "Supervisory process tried to write to a non-present page entry\n",
-    "Supervisory process tried to write a page and caused a protection fault\n",
-    "User process tried to read a non-present page entry\n",
-    "User process tried to read a page and caused a protection fault\n",
-    "User process tried to write to a non-present page entry\n",
-    "User process tried to write a page and caused a protection fault\n"};
-
-namespace CrashHandler
-{
-    SafeFunction void DisplayMainScreen(CRData data)
-    {
-        CHArchTrapFrame *Frame = data.Frame;
-
-        /*
- _______ ___ ___ _______ _______ _______ _______      ______ ______ _______ _______ _______ _______ _____
-|     __|   |   |     __|_     _|    ___|   |   |    |      |   __ \   _   |     __|   |   |    ___|     \
-|__     |\     /|__     | |   | |    ___|       |    |   ---|      <       |__     |       |    ___|  --  |
-|_______| |___| |_______| |___| |_______|__|_|__|    |______|___|__|___|___|_______|___|___|_______|_____/
-        */
-        EHPrint("\eFF5500 _______ ___ ___ _______ _______ _______ _______      ______ ______ _______ _______ _______ _______ _____  \n");
-        EHPrint("|     __|   |   |     __|_     _|    ___|   |   |    |      |   __ \\   _   |     __|   |   |    ___|     \\ \n");
-        EHPrint("|__     |\\     /|__     | |   | |    ___|       |    |   ---|      <       |__     |       |    ___|  --  |\n");
-        EHPrint("|_______| |___| |_______| |___| |_______|__|_|__|    |______|___|__|___|___|_______|___|___|_______|_____/ \n\eFAFAFA");
-
-        switch (Frame->InterruptNumber)
-        {
-        case CPU::x86::DivideByZero:
-        {
-            EHPrint("Exception: Divide By Zero\n");
-            EHPrint("The processor attempted to divide a number by zero.\n");
-            break;
-        }
-        case CPU::x86::Debug:
-        {
-            EHPrint("Exception: Debug\n");
-            EHPrint("A debug exception has occurred.\n");
-            break;
-        }
-        case CPU::x86::NonMaskableInterrupt:
-        {
-            EHPrint("Exception: Non-Maskable Interrupt\n");
-            EHPrint("A non-maskable interrupt was received.\n");
-            break;
-        }
-        case CPU::x86::Breakpoint:
-        {
-            EHPrint("Exception: Breakpoint\n");
-            EHPrint("The processor encountered a breakpoint.\n");
-            break;
-        }
-        case CPU::x86::Overflow:
-        {
-            EHPrint("Exception: Overflow\n");
-            EHPrint("The processor attempted to add a number to a number that was too large.\n");
-            break;
-        }
-        case CPU::x86::BoundRange:
-        {
-            EHPrint("Exception: Bound Range\n");
-            EHPrint("The processor attempted to access an array element that is out of bounds.\n");
-            break;
-        }
-        case CPU::x86::InvalidOpcode:
-        {
-            EHPrint("Exception: Invalid Opcode\n");
-            EHPrint("The processor attempted to execute an invalid opcode.\n");
-            break;
-        }
-        case CPU::x86::DeviceNotAvailable:
-        {
-            EHPrint("Exception: Device Not Available\n");
-            EHPrint("The processor attempted to use a device that is not available.\n");
-            break;
-        }
-        case CPU::x86::DoubleFault:
-        {
-            EHPrint("Exception: Double Fault\n");
-            EHPrint("The processor encountered a double fault.\n");
-            break;
-        }
-        case CPU::x86::CoprocessorSegmentOverrun:
-        {
-            EHPrint("Exception: Coprocessor Segment Overrun\n");
-            EHPrint("The processor attempted to access a segment that is not available.\n");
-            break;
-        }
-        case CPU::x86::InvalidTSS:
-        {
-            EHPrint("Exception: Invalid TSS\n");
-            EHPrint("The processor attempted to access a task state segment that is not available or valid.\n");
-            CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
-            EHPrint("External? %s\n", SelCode.External ? "Yes" : "No");
-            EHPrint("GDT  IDT  LDT  IDT\n");
-            switch (SelCode.Table)
-            {
-            case 0b00:
-            {
-                EHPrint(" ^                \n");
-                EHPrint(" |                \n");
-                EHPrint(" %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b01:
-            {
-                EHPrint("      ^           \n");
-                EHPrint("      |           \n");
-                EHPrint("      %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b10:
-            {
-                EHPrint("           ^      \n");
-                EHPrint("           |      \n");
-                EHPrint("           %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b11:
-            {
-                EHPrint("                ^ \n");
-                EHPrint("                | \n");
-                EHPrint("                %ld\n", SelCode.Idx);
-                break;
-            }
-            }
-            break;
-        }
-        case CPU::x86::SegmentNotPresent:
-        {
-            EHPrint("Exception: Segment Not Present\n");
-            EHPrint("The processor attempted to access a segment that is not present.\n");
-            CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
-            EHPrint("External? %s\n", SelCode.External ? "Yes" : "No");
-            EHPrint("GDT  IDT  LDT  IDT\n");
-            switch (SelCode.Table)
-            {
-            case 0b00:
-            {
-                EHPrint(" ^                \n");
-                EHPrint(" |                \n");
-                EHPrint(" %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b01:
-            {
-                EHPrint("      ^           \n");
-                EHPrint("      |           \n");
-                EHPrint("      %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b10:
-            {
-                EHPrint("           ^      \n");
-                EHPrint("           |      \n");
-                EHPrint("           %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b11:
-            {
-                EHPrint("                ^ \n");
-                EHPrint("                | \n");
-                EHPrint("                %ld\n", SelCode.Idx);
-                break;
-            }
-            }
-            break;
-        }
-        case CPU::x86::StackSegmentFault:
-        {
-            EHPrint("Exception: Stack Segment Fault\n");
-            CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
-            EHPrint("External? %s\n", SelCode.External ? "Yes" : "No");
-            EHPrint("GDT  IDT  LDT  IDT\n");
-            switch (SelCode.Table)
-            {
-            case 0b00:
-            {
-                EHPrint(" ^                \n");
-                EHPrint(" |                \n");
-                EHPrint(" %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b01:
-            {
-                EHPrint("      ^           \n");
-                EHPrint("      |           \n");
-                EHPrint("      %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b10:
-            {
-                EHPrint("           ^      \n");
-                EHPrint("           |      \n");
-                EHPrint("           %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b11:
-            {
-                EHPrint("                ^ \n");
-                EHPrint("                | \n");
-                EHPrint("                %ld\n", SelCode.Idx);
-                break;
-            }
-            }
-            break;
-        }
-        case CPU::x86::GeneralProtectionFault:
-        {
-            EHPrint("Exception: General Protection Fault\n");
-            EHPrint("Kernel performed an illegal operation.\n");
-            CPU::x64::SelectorErrorCode SelCode = {.raw = Frame->ErrorCode};
-            EHPrint("External? %s\n", SelCode.External ? "Yes" : "No");
-            EHPrint("GDT  IDT  LDT  IDT\n");
-            switch (SelCode.Table)
-            {
-            case 0b00:
-            {
-                EHPrint(" ^                \n");
-                EHPrint(" |                \n");
-                EHPrint(" %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b01:
-            {
-                EHPrint("      ^           \n");
-                EHPrint("      |           \n");
-                EHPrint("      %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b10:
-            {
-                EHPrint("           ^      \n");
-                EHPrint("           |      \n");
-                EHPrint("           %ld\n", SelCode.Idx);
-                break;
-            }
-            case 0b11:
-            {
-                EHPrint("                ^ \n");
-                EHPrint("                | \n");
-                EHPrint("                %ld\n", SelCode.Idx);
-                break;
-            }
-            }
-            break;
-        }
-        case CPU::x86::PageFault:
-        {
-            EHPrint("Exception: Page Fault\n");
-            EHPrint("The processor attempted to access a page that is not present.\n");
-
-            CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode};
-#if defined(a64)
-            EHPrint("At \e8888FF%#lx \eFAFAFAby \e8888FF%#lx\eFAFAFA\n", PageFaultAddress, Frame->rip);
-#elif defined(a32)
-            EHPrint("At \e8888FF%#lx \eFAFAFAby \e8888FF%#lx\eFAFAFA\n", PageFaultAddress, Frame->eip);
-#elif defined(aa64)
-#endif
-            EHPrint("Page: %s\eFAFAFA\n", params.P ? "\e058C19Present" : "\eE85230Not Present");
-            EHPrint("Write Operation: \e8888FF%s\eFAFAFA\n", params.W ? "Read-Only" : "Read-Write");
-            EHPrint("Processor Mode: \e8888FF%s\eFAFAFA\n", params.U ? "User-Mode" : "Kernel-Mode");
-            EHPrint("CPU Reserved Bits: %s\eFAFAFA\n", params.R ? "\eE85230Reserved" : "\e058C19Unreserved");
-            EHPrint("Caused By An Instruction Fetch: %s\eFAFAFA\n", params.I ? "\eE85230Yes" : "\e058C19No");
-            EHPrint("Caused By A Protection-Key Violation: %s\eFAFAFA\n", params.PK ? "\eE85230Yes" : "\e058C19No");
-            EHPrint("Caused By A Shadow Stack Access: %s\eFAFAFA\n", params.SS ? "\eE85230Yes" : "\e058C19No");
-            EHPrint("Caused By An SGX Violation: %s\eFAFAFA\n", params.SGX ? "\eE85230Yes" : "\e058C19No");
-            EHPrint("More Info: \e8888FF");
-            if (Frame->ErrorCode & 0x00000008)
-                EHPrint("One or more page directory entries contain reserved bits which are set to 1.\n");
-            else
-                EHPrint(PagefaultDescriptions[Frame->ErrorCode & 0b111]);
-            EHPrint("\eFAFAFA");
-            break;
-        }
-        case CPU::x86::x87FloatingPoint:
-        {
-            EHPrint("Exception: x87 Floating Point\n");
-            EHPrint("The x87 FPU generated an error.\n");
-            break;
-        }
-        case CPU::x86::AlignmentCheck:
-        {
-            EHPrint("Exception: Alignment Check\n");
-            EHPrint("The CPU detected an unaligned memory access.\n");
-            break;
-        }
-        case CPU::x86::MachineCheck:
-        {
-            EHPrint("Exception: Machine Check\n");
-            EHPrint("The CPU detected a hardware error.\n");
-            break;
-        }
-        case CPU::x86::SIMDFloatingPoint:
-        {
-            EHPrint("Exception: SIMD Floating Point\n");
-            EHPrint("The CPU detected an error in the SIMD unit.\n");
-            break;
-        }
-        case CPU::x86::Virtualization:
-        {
-            EHPrint("Exception: Virtualization\n");
-            EHPrint("The CPU detected a virtualization error.\n");
-            break;
-        }
-        case CPU::x86::Security:
-        {
-            EHPrint("Exception: Security\n");
-            EHPrint("The CPU detected a security violation.\n");
-            break;
-        }
-        default:
-        {
-            EHPrint("Exception: Unknown\n");
-            EHPrint("The CPU generated an unknown exception.\n");
-            break;
-        }
-        }
-
-#if defined(a64)
-        EHPrint("The exception happened at \e8888FF%#lx\eFAFAFA\n", Frame->rip);
-#elif defined(a32)
-        EHPrint("The exception happened at \e8888FF%#lx\eFAFAFA\n", Frame->eip);
-#elif defined(aa64)
-#endif
-    }
-}
--- a/Kernel/Core/Crash/Screens/StackFrame.cpp
+++ b/Kernel/Core/Crash/Screens/StackFrame.cpp
@@ -1,81 +0,0 @@
-#include "../../crashhandler.hpp"
-#include "../chfcts.hpp"
-
-#include <ints.hpp>
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../../kernel.h"
-
-namespace CrashHandler
-{
-    SafeFunction void DisplayStackFrameScreen(CRData data)
-    {
-        EHPrint("\eFAFAFATracing 10 frames...");
-        TraceFrames(data.Frame, 10, KernelSymbolTable, true);
-        if (data.Process)
-        {
-            EHPrint("\n\eFAFAFATracing 10 process frames...");
-            SymbolResolver::Symbols *sh = data.Process->ELFSymbolTable;
-            if (!sh)
-                EHPrint("\n\eFF0000< No symbol table available. >\n");
-            else
-                TraceFrames(data.Frame, 10, sh, false);
-        }
-        EHPrint("\n\eFAFAFATracing interrupt frames...");
-        for (short i = 0; i < 8; i++)
-        {
-            if (EHIntFrames[i])
-            {
-                if (!Memory::Virtual().Check(EHIntFrames[i]))
-                    continue;
-                EHPrint("\n\e2565CC%p", EHIntFrames[i]);
-                EHPrint("\e7925CC-");
-#if defined(a64)
-                if ((uintptr_t)EHIntFrames[i] >= 0xFFFFFFFF80000000 && (uintptr_t)EHIntFrames[i] <= (uintptr_t)&_kernel_end)
-#elif defined(a32)
-                if ((uintptr_t)EHIntFrames[i] >= 0xC0000000 && (uintptr_t)EHIntFrames[i] <= (uintptr_t)&_kernel_end)
-#elif defined(aa64)
-#endif
-                    EHPrint("\e25CCC9%s", KernelSymbolTable->GetSymbolFromAddress((uintptr_t)EHIntFrames[i]));
-                else
-                    EHPrint("\eFF4CA9Outside Kernel");
-            }
-        }
-        if (data.Process && data.Thread)
-        {
-            EHPrint("\n\n\eFAFAFATracing thread instruction pointer history...");
-            SymbolResolver::Symbols *sh = data.Process->ELFSymbolTable;
-            if (!sh)
-                EHPrint("\n\eFFA500Warning: No symbol table available.");
-            int SameItr = 0;
-            uintptr_t LastRIP = 0;
-            for (size_t i = 0; i < sizeof(data.Thread->IPHistory) / sizeof(data.Thread->IPHistory[0]); i++)
-            {
-                if (data.Thread->IPHistory[i] == LastRIP)
-                {
-                    SameItr++;
-                    if (SameItr > 2)
-                        continue;
-                }
-                else
-                    SameItr = 0;
-                LastRIP = data.Thread->IPHistory[i];
-                if (!sh)
-                    EHPrint("\n\eCCCCCC%d: \e2565CC%p", i, data.Thread->IPHistory[i]);
-                else
-                    EHPrint("\n\eCCCCCC%d: \e2565CC%p\e7925CC-\e25CCC9%s", i, data.Thread->IPHistory[i], sh->GetSymbolFromAddress(data.Thread->IPHistory[i]));
-            }
-            EHPrint("\n\e7925CCNote: \e2565CCSame instruction pointers are not shown more than 3 times.\n");
-        }
-    }
-}
--- a/Kernel/Core/Crash/Screens/Tasks.cpp
+++ b/Kernel/Core/Crash/Screens/Tasks.cpp
@@ -1,70 +0,0 @@
-#include "../../crashhandler.hpp"
-#include "../chfcts.hpp"
-
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../../kernel.h"
-
-namespace CrashHandler
-{
-    SafeFunction void DisplayTasksScreen(CRData data)
-    {
-        const char *StatusColor[7] = {
-            "FF0000", // Unknown
-            "AAFF00", // Ready
-            "00AA00", // Running
-            "FFAA00", // Sleeping
-            "FFAA00", // Waiting
-            "FF0088", // Stopped
-            "FF0000", // Terminated
-        };
-
-        const char *StatusString[7] = {
-            "Unknown",    // Unknown
-            "Ready",      // Ready
-            "Running",    // Running
-            "Sleeping",   // Sleeping
-            "Waiting",    // Waiting
-            "Stopped",    // Stopped
-            "Terminated", // Terminated
-        };
-
-        Vector<Tasking::PCB *> Plist = TaskManager->GetProcessList();
-
-        if (TaskManager)
-        {
-            if (data.Thread)
-#if defined(a64)
-                EHPrint("\eFAFAFACrash occurred in thread \eAA0F0F%s\eFAFAFA(%ld) at \e00AAAA%#lx\n", data.Thread->Name, data.Thread->ID, data.Frame->rip);
-#elif defined(a32)
-                EHPrint("\eFAFAFACrash occurred in thread \eAA0F0F%s\eFAFAFA(%ld) at \e00AAAA%#lx\n", data.Thread->Name, data.Thread->ID, data.Frame->eip);
-#elif defined(aa64)
-#endif
-
-            EHPrint("\eFAFAFAProcess list (%ld):\n", Plist.size());
-            foreach (auto Process in Plist)
-            {
-                EHPrint("\e%s-> \eFAFAFA%s\eCCCCCC(%ld) \e00AAAA%s\eFAFAFA PT:\e00AAAA%#lx\n",
-                        StatusColor[Process->Status], Process->Name, Process->ID, StatusString[Process->Status],
-                        Process->PageTable);
-
-                foreach (auto Thread in Process->Threads)
-                    EHPrint("\e%s  -> \eFAFAFA%s\eCCCCCC(%ld) \e00AAAA%s\eFAFAFA Stack:\e00AAAA%#lx\n",
-                            StatusColor[Thread->Status], Thread->Name, Thread->ID, StatusString[Thread->Status],
-                            Thread->Stack);
-            }
-        }
-        else
-            EHPrint("\eFAFAFATaskManager is not initialized!\n");
-    }
-}
--- a/Kernel/Core/Crash/UserHandler.cpp
+++ b/Kernel/Core/Crash/UserHandler.cpp
@@ -1,374 +0,0 @@
-#include "../crashhandler.hpp"
-#include "chfcts.hpp"
-
-#include <display.hpp>
-#include <printf.h>
-#include <debug.h>
-#include <smp.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-#include "../../Architecture/amd64/cpu/gdt.hpp"
-#elif defined(a32)
-#elif defined(aa64)
-#endif
-
-#include "../../kernel.h"
-
-static const char *PageFaultDescriptions[8] = {
-    "Supervisory process tried to read a non-present page entry\n",
-    "Supervisory process tried to read a page and caused a protection fault\n",
-    "Supervisory process tried to write to a non-present page entry\n",
-    "Supervisory process tried to write a page and caused a protection fault\n",
-    "User process tried to read a non-present page entry\n",
-    "User process tried to read a page and caused a protection fault\n",
-    "User process tried to write to a non-present page entry\n",
-    "User process tried to write a page and caused a protection fault\n"};
-
-SafeFunction void UserModeExceptionHandler(CHArchTrapFrame *Frame)
-{
-    CriticalSection cs;
-    debug("Interrupts? %s.", cs.IsInterruptsEnabled() ? "Yes" : "No");
-    fixme("Handling user mode exception");
-    TaskManager->GetCurrentThread()->Status = Tasking::TaskStatus::Stopped;
-    CPUData *CurCPU = GetCurrentCPU();
-
-    {
-#if defined(a64)
-        CPU::x64::CR0 cr0 = CPU::x64::readcr0();
-        CPU::x64::CR2 cr2 = CPU::x64::CR2{.PFLA = CrashHandler::PageFaultAddress};
-        CPU::x64::CR3 cr3 = CPU::x64::readcr3();
-        CPU::x64::CR4 cr4 = CPU::x64::readcr4();
-        CPU::x64::CR8 cr8 = CPU::x64::readcr8();
-        CPU::x64::EFER efer;
-        efer.raw = CPU::x64::rdmsr(CPU::x64::MSR_EFER);
-
-        error("Technical Informations on CPU %lld:", CurCPU->ID);
-        uintptr_t ds;
-        asmv("mov %%ds, %0"
-             : "=r"(ds));
-#elif defined(a32)
-        CPU::x32::CR0 cr0 = CPU::x32::readcr0();
-        CPU::x32::CR2 cr2 = CPU::x32::CR2{.PFLA = CrashHandler::PageFaultAddress};
-        CPU::x32::CR3 cr3 = CPU::x32::readcr3();
-        CPU::x32::CR4 cr4 = CPU::x32::readcr4();
-        CPU::x32::CR8 cr8 = CPU::x32::readcr8();
-        CPU::x32::EFER efer;
-        efer.raw = CPU::x32::rdmsr(CPU::x32::MSR_EFER);
-
-        error("Technical Informations on CPU %lld:", CurCPU->ID);
-        uintptr_t ds;
-        asmv("mov %%ds, %0"
-             : "=r"(ds));
-#elif defined(aa64)
-#endif
-
-#if defined(a64)
-        error("FS=%#llx GS=%#llx SS=%#llx CS=%#llx DS=%#llx",
-              CPU::x64::rdmsr(CPU::x64::MSR_FS_BASE), CPU::x64::rdmsr(CPU::x64::MSR_GS_BASE),
-              Frame->ss, Frame->cs, ds);
-        error("R8=%#llx R9=%#llx R10=%#llx R11=%#llx", Frame->r8, Frame->r9, Frame->r10, Frame->r11);
-        error("R12=%#llx R13=%#llx R14=%#llx R15=%#llx", Frame->r12, Frame->r13, Frame->r14, Frame->r15);
-        error("RAX=%#llx RBX=%#llx RCX=%#llx RDX=%#llx", Frame->rax, Frame->rbx, Frame->rcx, Frame->rdx);
-        error("RSI=%#llx RDI=%#llx RBP=%#llx RSP=%#llx", Frame->rsi, Frame->rdi, Frame->rbp, Frame->rsp);
-        error("RIP=%#llx RFL=%#llx INT=%#llx ERR=%#llx EFER=%#llx", Frame->rip, Frame->rflags.raw, Frame->InterruptNumber, Frame->ErrorCode, efer.raw);
-#elif defined(a32)
-        error("FS=%#llx GS=%#llx SS=%#llx CS=%#llx DS=%#llx",
-              CPU::x32::rdmsr(CPU::x32::MSR_FS_BASE), CPU::x32::rdmsr(CPU::x32::MSR_GS_BASE),
-              Frame->ss, Frame->cs, ds);
-        error("EAX=%#llx EBX=%#llx ECX=%#llx EDX=%#llx", Frame->eax, Frame->ebx, Frame->ecx, Frame->edx);
-        error("ESI=%#llx EDI=%#llx EBP=%#llx ESP=%#llx", Frame->esi, Frame->edi, Frame->ebp, Frame->esp);
-        error("EIP=%#llx EFL=%#llx INT=%#llx ERR=%#llx EFER=%#llx", Frame->eip, Frame->eflags.raw, Frame->InterruptNumber, Frame->ErrorCode, efer.raw);
-#elif defined(aa64)
-#endif
-        error("CR0=%#llx CR2=%#llx CR3=%#llx CR4=%#llx CR8=%#llx", cr0.raw, cr2.raw, cr3.raw, cr4.raw, cr8.raw);
-
-        error("CR0: PE:%s MP:%s EM:%s TS:%s ET:%s NE:%s WP:%s AM:%s NW:%s CD:%s PG:%s R0:%#x R1:%#x R2:%#x",
-              cr0.PE ? "True " : "False", cr0.MP ? "True " : "False", cr0.EM ? "True " : "False", cr0.TS ? "True " : "False",
-              cr0.ET ? "True " : "False", cr0.NE ? "True " : "False", cr0.WP ? "True " : "False", cr0.AM ? "True " : "False",
-              cr0.NW ? "True " : "False", cr0.CD ? "True " : "False", cr0.PG ? "True " : "False",
-              cr0.Reserved0, cr0.Reserved1, cr0.Reserved2);
-
-        error("CR2: PFLA: %#llx",
-              cr2.PFLA);
-
-        error("CR3: PWT:%s PCD:%s PDBR:%#llx",
-              cr3.PWT ? "True " : "False", cr3.PCD ? "True " : "False", cr3.PDBR);
-
-#if defined(a64)
-        error("CR4: VME:%s PVI:%s TSD:%s DE:%s PSE:%s PAE:%s MCE:%s PGE:%s PCE:%s UMIP:%s OSFXSR:%s OSXMMEXCPT:%s    LA57:%s    VMXE:%s    SMXE:%s   PCIDE:%s OSXSAVE:%s    SMEP:%s    SMAP:%s PKE:%s R0:%#x R1:%#x R2:%#x",
-              cr4.VME ? "True " : "False", cr4.PVI ? "True " : "False", cr4.TSD ? "True " : "False", cr4.DE ? "True " : "False",
-              cr4.PSE ? "True " : "False", cr4.PAE ? "True " : "False", cr4.MCE ? "True " : "False", cr4.PGE ? "True " : "False",
-              cr4.PCE ? "True " : "False", cr4.UMIP ? "True " : "False", cr4.OSFXSR ? "True " : "False", cr4.OSXMMEXCPT ? "True " : "False",
-              cr4.LA57 ? "True " : "False", cr4.VMXE ? "True " : "False", cr4.SMXE ? "True " : "False", cr4.PCIDE ? "True " : "False",
-              cr4.OSXSAVE ? "True " : "False", cr4.SMEP ? "True " : "False", cr4.SMAP ? "True " : "False", cr4.PKE ? "True " : "False",
-              cr4.Reserved0, cr4.Reserved1, cr4.Reserved2);
-#elif defined(a32)
-                error("CR4: VME:%s PVI:%s TSD:%s DE:%s PSE:%s PAE:%s MCE:%s PGE:%s PCE:%s UMIP:%s OSFXSR:%s OSXMMEXCPT:%s    LA57:%s    VMXE:%s    SMXE:%s   PCIDE:%s OSXSAVE:%s    SMEP:%s    SMAP:%s PKE:%s R0:%#x R1:%#x",
-              cr4.VME ? "True " : "False", cr4.PVI ? "True " : "False", cr4.TSD ? "True " : "False", cr4.DE ? "True " : "False",
-              cr4.PSE ? "True " : "False", cr4.PAE ? "True " : "False", cr4.MCE ? "True " : "False", cr4.PGE ? "True " : "False",
-              cr4.PCE ? "True " : "False", cr4.UMIP ? "True " : "False", cr4.OSFXSR ? "True " : "False", cr4.OSXMMEXCPT ? "True " : "False",
-              cr4.LA57 ? "True " : "False", cr4.VMXE ? "True " : "False", cr4.SMXE ? "True " : "False", cr4.PCIDE ? "True " : "False",
-              cr4.OSXSAVE ? "True " : "False", cr4.SMEP ? "True " : "False", cr4.SMAP ? "True " : "False", cr4.PKE ? "True " : "False",
-              cr4.Reserved0, cr4.Reserved1);
-#endif
-
-        error("CR8: TPL:%d", cr8.TPL);
-
-#if defined(a64)
-        error("RFL: CF:%s PF:%s AF:%s ZF:%s SF:%s TF:%s IF:%s DF:%s OF:%s IOPL:%s NT:%s RF:%s VM:%s AC:%s VIF:%s VIP:%s ID:%s AlwaysOne:%d R0:%#x R1:%#x R2:%#x R3:%#x",
-              Frame->rflags.CF ? "True " : "False", Frame->rflags.PF ? "True " : "False", Frame->rflags.AF ? "True " : "False", Frame->rflags.ZF ? "True " : "False",
-              Frame->rflags.SF ? "True " : "False", Frame->rflags.TF ? "True " : "False", Frame->rflags.IF ? "True " : "False", Frame->rflags.DF ? "True " : "False",
-              Frame->rflags.OF ? "True " : "False", Frame->rflags.IOPL ? "True " : "False", Frame->rflags.NT ? "True " : "False", Frame->rflags.RF ? "True " : "False",
-              Frame->rflags.VM ? "True " : "False", Frame->rflags.AC ? "True " : "False", Frame->rflags.VIF ? "True " : "False", Frame->rflags.VIP ? "True " : "False",
-              Frame->rflags.ID ? "True " : "False", Frame->rflags.AlwaysOne,
-              Frame->rflags.Reserved0, Frame->rflags.Reserved1, Frame->rflags.Reserved2, Frame->rflags.Reserved3);
-#elif defined(a32)
-        error("EFL: CF:%s PF:%s AF:%s ZF:%s SF:%s TF:%s IF:%s DF:%s OF:%s IOPL:%s NT:%s RF:%s VM:%s AC:%s VIF:%s VIP:%s ID:%s AlwaysOne:%d R0:%#x R1:%#x R2:%#x",
-              Frame->eflags.CF ? "True " : "False", Frame->eflags.PF ? "True " : "False", Frame->eflags.AF ? "True " : "False", Frame->eflags.ZF ? "True " : "False",
-              Frame->eflags.SF ? "True " : "False", Frame->eflags.TF ? "True " : "False", Frame->eflags.IF ? "True " : "False", Frame->eflags.DF ? "True " : "False",
-              Frame->eflags.OF ? "True " : "False", Frame->eflags.IOPL ? "True " : "False", Frame->eflags.NT ? "True " : "False", Frame->eflags.RF ? "True " : "False",
-              Frame->eflags.VM ? "True " : "False", Frame->eflags.AC ? "True " : "False", Frame->eflags.VIF ? "True " : "False", Frame->eflags.VIP ? "True " : "False",
-              Frame->eflags.ID ? "True " : "False", Frame->eflags.AlwaysOne,
-              Frame->eflags.Reserved0, Frame->eflags.Reserved1, Frame->eflags.Reserved2);
-#elif defined(aa64)
-#endif
-
-        error("EFER: SCE:%s LME:%s LMA:%s NXE:%s SVME:%s LMSLE:%s FFXSR:%s TCE:%s R0:%#x R1:%#x R2:%#x",
-              efer.SCE ? "True " : "False", efer.LME ? "True " : "False", efer.LMA ? "True " : "False", efer.NXE ? "True " : "False",
-              efer.SVME ? "True " : "False", efer.LMSLE ? "True " : "False", efer.FFXSR ? "True " : "False", efer.TCE ? "True " : "False",
-              efer.Reserved0, efer.Reserved1, efer.Reserved2);
-    }
-
-    switch (Frame->InterruptNumber)
-    {
-    case CPU::x86::DivideByZero:
-    {
-        break;
-    }
-    case CPU::x86::Debug:
-    {
-        break;
-    }
-    case CPU::x86::NonMaskableInterrupt:
-    {
-        break;
-    }
-    case CPU::x86::Breakpoint:
-    {
-        break;
-    }
-    case CPU::x86::Overflow:
-    {
-        break;
-    }
-    case CPU::x86::BoundRange:
-    {
-        break;
-    }
-    case CPU::x86::InvalidOpcode:
-    {
-        break;
-    }
-    case CPU::x86::DeviceNotAvailable:
-    {
-        break;
-    }
-    case CPU::x86::DoubleFault:
-    {
-        break;
-    }
-    case CPU::x86::CoprocessorSegmentOverrun:
-    {
-        break;
-    }
-    case CPU::x86::InvalidTSS:
-    {
-        break;
-    }
-    case CPU::x86::SegmentNotPresent:
-    {
-        break;
-    }
-    case CPU::x86::StackSegmentFault:
-    {
-        break;
-    }
-    case CPU::x86::GeneralProtectionFault:
-    {
-        break;
-    }
-    case CPU::x86::PageFault:
-    {
-        uintptr_t CheckPageFaultAddress = 0;
-        CPU::x64::PageFaultErrorCode params = {.raw = (uint32_t)Frame->ErrorCode};
-#if defined(a64)
-        CheckPageFaultAddress = CrashHandler::PageFaultAddress;
-        if (CheckPageFaultAddress == 0)
-            CheckPageFaultAddress = Frame->rip;
-
-        error("An exception occurred at %#lx by %#lx", CrashHandler::PageFaultAddress, Frame->rip);
-#elif defined(a32)
-        error("An exception occurred at %#lx by %#lx", CrashHandler::PageFaultAddress, Frame->eip);
-#elif defined(aa64)
-#endif
-        error("Page: %s", params.P ? "Present" : "Not Present");
-        error("Write Operation: %s", params.W ? "Read-Only" : "Read-Write");
-        error("Processor Mode: %s", params.U ? "User-Mode" : "Kernel-Mode");
-        error("CPU Reserved Bits: %s", params.R ? "Reserved" : "Unreserved");
-        error("Caused By An Instruction Fetch: %s", params.I ? "Yes" : "No");
-        error("Caused By A Protection-Key Violation: %s", params.PK ? "Yes" : "No");
-        error("Caused By A Shadow Stack Access: %s", params.SS ? "Yes" : "No");
-        error("Caused By An SGX Violation: %s", params.SGX ? "Yes" : "No");
-        if (Frame->ErrorCode & 0x00000008)
-            error("One or more page directory entries contain reserved bits which are set to 1.");
-        else
-            error(PageFaultDescriptions[Frame->ErrorCode & 0b111]);
-
-#ifdef DEBUG
-        if (CurCPU)
-        {
-            Memory::Virtual vma = Memory::Virtual(CurCPU->CurrentProcess->PageTable);
-            bool PageAvailable = vma.Check((void *)CheckPageFaultAddress);
-            debug("Page available (Check(...)): %s. %s",
-                  PageAvailable ? "Yes" : "No",
-                  (params.P && !PageAvailable) ? "CR2 == Present; Check() != Present??????" : "CR2 confirms Check() result.");
-
-            if (PageAvailable)
-            {
-                bool Present = vma.Check((void *)CheckPageFaultAddress);
-                bool ReadWrite = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::RW);
-                bool User = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::US);
-                bool WriteThrough = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::PWT);
-                bool CacheDisabled = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::PCD);
-                bool Accessed = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::A);
-                bool Dirty = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::D);
-                bool Global = vma.Check((void *)CheckPageFaultAddress, Memory::PTFlag::G);
-                /* ... */
-
-                debug("Page available: %s", Present ? "Yes" : "No");
-                debug("Page read/write: %s", ReadWrite ? "Yes" : "No");
-                debug("Page user/kernel: %s", User ? "User" : "Kernel");
-                debug("Page write-through: %s", WriteThrough ? "Yes" : "No");
-                debug("Page cache disabled: %s", CacheDisabled ? "Yes" : "No");
-                debug("Page accessed: %s", Accessed ? "Yes" : "No");
-                debug("Page dirty: %s", Dirty ? "Yes" : "No");
-                debug("Page global: %s", Global ? "Yes" : "No");
-
-                if (Present)
-                {
-                    uintptr_t CheckPageFaultLinearAddress = (uintptr_t)CheckPageFaultAddress;
-                    CheckPageFaultLinearAddress &= 0xFFFFFFFFFFFFF000;
-                    debug("%#lx -> %#lx", CheckPageFaultAddress, CheckPageFaultLinearAddress);
-
-                    Memory::Virtual::PageMapIndexer Index = Memory::Virtual::PageMapIndexer((uintptr_t)CheckPageFaultLinearAddress);
-                    debug("Index for %#lx is PML:%d PDPTE:%d PDE:%d PTE:%d",
-                          CheckPageFaultLinearAddress,
-                          Index.PMLIndex,
-                          Index.PDPTEIndex,
-                          Index.PDEIndex,
-                          Index.PTEIndex);
-                    Memory::PageMapLevel4 PML4 = CurCPU->CurrentProcess->PageTable->Entries[Index.PMLIndex];
-
-                    Memory::PageDirectoryPointerTableEntryPtr *PDPTE = (Memory::PageDirectoryPointerTableEntryPtr *)((uintptr_t)PML4.GetAddress() << 12);
-                    Memory::PageDirectoryEntryPtr *PDE = (Memory::PageDirectoryEntryPtr *)((uintptr_t)PDPTE->Entries[Index.PDPTEIndex].GetAddress() << 12);
-                    Memory::PageTableEntryPtr *PTE = (Memory::PageTableEntryPtr *)((uintptr_t)PDE->Entries[Index.PDEIndex].GetAddress() << 12);
-
-                    debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s NX:%s Address:%#lx",
-                          Index.PMLIndex, 0, 0, 0,
-                          PML4.Present ? "1" : "0",
-                          PML4.ReadWrite ? "1" : "0",
-                          PML4.UserSupervisor ? "1" : "0",
-                          PML4.WriteThrough ? "1" : "0",
-                          PML4.CacheDisable ? "1" : "0",
-                          PML4.Accessed ? "1" : "0",
-                          PML4.ExecuteDisable ? "1" : "0",
-                          PML4.GetAddress() << 12);
-
-                    debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s NX:%s Address:%#lx",
-                          Index.PMLIndex, Index.PDPTEIndex, 0, 0,
-                          PDPTE->Entries[Index.PDPTEIndex].Present ? "1" : "0",
-                          PDPTE->Entries[Index.PDPTEIndex].ReadWrite ? "1" : "0",
-                          PDPTE->Entries[Index.PDPTEIndex].UserSupervisor ? "1" : "0",
-                          PDPTE->Entries[Index.PDPTEIndex].WriteThrough ? "1" : "0",
-                          PDPTE->Entries[Index.PDPTEIndex].CacheDisable ? "1" : "0",
-                          PDPTE->Entries[Index.PDPTEIndex].Accessed ? "1" : "0",
-                          PDPTE->Entries[Index.PDPTEIndex].ExecuteDisable ? "1" : "0",
-                          PDPTE->Entries[Index.PDPTEIndex].GetAddress() << 12);
-
-                    debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s NX:%s Address:%#lx",
-                          Index.PMLIndex, Index.PDPTEIndex, Index.PDEIndex, 0,
-                          PDE->Entries[Index.PDEIndex].Present ? "1" : "0",
-                          PDE->Entries[Index.PDEIndex].ReadWrite ? "1" : "0",
-                          PDE->Entries[Index.PDEIndex].UserSupervisor ? "1" : "0",
-                          PDE->Entries[Index.PDEIndex].WriteThrough ? "1" : "0",
-                          PDE->Entries[Index.PDEIndex].CacheDisable ? "1" : "0",
-                          PDE->Entries[Index.PDEIndex].Accessed ? "1" : "0",
-                          PDE->Entries[Index.PDEIndex].ExecuteDisable ? "1" : "0",
-                          PDE->Entries[Index.PDEIndex].GetAddress() << 12);
-
-                    debug("# %03d-%03d-%03d-%03d: P:%s RW:%s US:%s PWT:%s PCB:%s A:%s D:%s PAT:%s G:%s PK:%d NX:%s Address:%#lx",
-                          Index.PMLIndex, Index.PDPTEIndex, Index.PDEIndex, Index.PTEIndex,
-                          PTE->Entries[Index.PTEIndex].Present ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].ReadWrite ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].UserSupervisor ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].WriteThrough ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].CacheDisable ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].Accessed ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].Dirty ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].PageAttributeTable ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].Global ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].ProtectionKey,
-                          PTE->Entries[Index.PTEIndex].ExecuteDisable ? "1" : "0",
-                          PTE->Entries[Index.PTEIndex].GetAddress() << 12);
-                }
-            }
-        }
-#endif
-
-        if (CurCPU)
-            if (CurCPU->CurrentThread->Stack->Expand(CrashHandler::PageFaultAddress))
-            {
-                debug("Stack expanded");
-                TaskManager->GetCurrentThread()->Status = Tasking::TaskStatus::Ready;
-                return;
-            }
-        break;
-    }
-    case CPU::x86::x87FloatingPoint:
-    {
-        break;
-    }
-    case CPU::x86::AlignmentCheck:
-    {
-        break;
-    }
-    case CPU::x86::MachineCheck:
-    {
-        break;
-    }
-    case CPU::x86::SIMDFloatingPoint:
-    {
-        break;
-    }
-    case CPU::x86::Virtualization:
-    {
-        break;
-    }
-    case CPU::x86::Security:
-    {
-        break;
-    }
-    default:
-    {
-        break;
-    }
-    }
-
-    TaskManager->GetCurrentThread()->Status = Tasking::TaskStatus::Terminated;
-    __sync;
-    error("End of report.");
-    CPU::Interrupts(CPU::Enable);
-    debug("Interrupts enabled back.");
-    return;
-}
--- a/Kernel/Core/Crash/chfcts.hpp
+++ b/Kernel/Core/Crash/chfcts.hpp
@@ -1,296 +0,0 @@
-#ifndef __FENNIX_KERNEL_CRASH_HANDLERS_FUNCTIONS_H__
-#define __FENNIX_KERNEL_CRASH_HANDLERS_FUNCTIONS_H__
-
-#include <types.h>
-
-#include <ints.hpp>
-#include <task.hpp>
-#include <cpu.hpp>
-
-#if defined(a64)
-typedef struct CPU::x64::TrapFrame CHArchTrapFrame;
-
-struct CRData
-{
-    CHArchTrapFrame *Frame;
-
-    CPU::x64::CR0 cr0;
-    CPU::x64::CR2 cr2;
-    CPU::x64::CR3 cr3;
-    CPU::x64::CR4 cr4;
-    CPU::x64::CR8 cr8;
-    CPU::x64::EFER efer;
-    uintptr_t dr0, dr1, dr2, dr3, dr6;
-    CPU::x64::DR7 dr7;
-
-    long ID;
-    void *CPUData;
-    Tasking::PCB *Process;
-    Tasking::TCB *Thread;
-};
-
-#elif defined(a32)
-typedef struct CPU::x32::TrapFrame CHArchTrapFrame;
-
-struct CRData
-{
-    CHArchTrapFrame *Frame;
-
-    CPU::x32::CR0 cr0;
-    CPU::x32::CR2 cr2;
-    CPU::x32::CR3 cr3;
-    CPU::x32::CR4 cr4;
-    CPU::x32::CR8 cr8;
-    CPU::x32::EFER efer;
-    uintptr_t dr0, dr1, dr2, dr3, dr6;
-    CPU::x32::DR7 dr7;
-
-    long ID;
-    Tasking::PCB *Process;
-    Tasking::TCB *Thread;
-};
-#elif defined(aa64)
-typedef struct CPU::aarch64::TrapFrame CHArchTrapFrame;
-#endif
-
-enum Keys
-{
-    KEY_INVALID = 0x0,
-    KEY_D_ESCAPE = 0x1,
-    KEY_D_1 = 0x2,
-    KEY_D_2 = 0x3,
-    KEY_D_3 = 0x4,
-    KEY_D_4 = 0x5,
-    KEY_D_5 = 0x6,
-    KEY_D_6 = 0x7,
-    KEY_D_7 = 0x8,
-    KEY_D_8 = 0x9,
-    KEY_D_9 = 0xa,
-    KEY_D_0 = 0xb,
-    KEY_D_MINUS = 0xc,
-    KEY_D_EQUALS = 0xd,
-    KEY_D_BACKSPACE = 0xe,
-    KEY_D_TAB = 0xf,
-    KEY_D_Q = 0x10,
-    KEY_D_W = 0x11,
-    KEY_D_E = 0x12,
-    KEY_D_R = 0x13,
-    KEY_D_T = 0x14,
-    KEY_D_Y = 0x15,
-    KEY_D_U = 0x16,
-    KEY_D_I = 0x17,
-    KEY_D_O = 0x18,
-    KEY_D_P = 0x19,
-    KEY_D_LBRACKET = 0x1a,
-    KEY_D_RBRACKET = 0x1b,
-    KEY_D_RETURN = 0x1c,
-    KEY_D_LCTRL = 0x1d,
-    KEY_D_A = 0x1e,
-    KEY_D_S = 0x1f,
-    KEY_D_D = 0x20,
-    KEY_D_F = 0x21,
-    KEY_D_G = 0x22,
-    KEY_D_H = 0x23,
-    KEY_D_J = 0x24,
-    KEY_D_K = 0x25,
-    KEY_D_L = 0x26,
-    KEY_D_SEMICOLON = 0x27,
-    KEY_D_APOSTROPHE = 0x28,
-    KEY_D_GRAVE = 0x29,
-    KEY_D_LSHIFT = 0x2a,
-    KEY_D_BACKSLASH = 0x2b,
-    KEY_D_Z = 0x2c,
-    KEY_D_X = 0x2d,
-    KEY_D_C = 0x2e,
-    KEY_D_V = 0x2f,
-    KEY_D_B = 0x30,
-    KEY_D_N = 0x31,
-    KEY_D_M = 0x32,
-    KEY_D_COMMA = 0x33,
-    KEY_D_PERIOD = 0x34,
-    KEY_D_SLASH = 0x35,
-    KEY_D_RSHIFT = 0x36,
-    KEY_D_PRTSC = 0x37,
-    KEY_D_LALT = 0x38,
-    KEY_D_SPACE = 0x39,
-    KEY_D_CAPSLOCK = 0x3a,
-    KEY_D_NUMLOCK = 0x45,
-    KEY_D_SCROLLLOCK = 0x46,
-
-    KEY_D_KP_MULTIPLY = 0x37,
-    KEY_D_KP_7 = 0x47,
-    KEY_D_KP_8 = 0x48,
-    KEY_D_KP_9 = 0x49,
-    KEY_D_KP_MINUS = 0x4a,
-    KEY_D_KP_4 = 0x4b,
-    KEY_D_KP_5 = 0x4c,
-    KEY_D_KP_6 = 0x4d,
-    KEY_D_KP_PLUS = 0x4e,
-    KEY_D_KP_1 = 0x4f,
-    KEY_D_KP_2 = 0x50,
-    KEY_D_KP_3 = 0x51,
-    KEY_D_KP_0 = 0x52,
-    KEY_D_KP_PERIOD = 0x53,
-
-    KEY_D_F1 = 0x3b,
-    KEY_D_F2 = 0x3c,
-    KEY_D_F3 = 0x3d,
-    KEY_D_F4 = 0x3e,
-    KEY_D_F5 = 0x3f,
-    KEY_D_F6 = 0x40,
-    KEY_D_F7 = 0x41,
-    KEY_D_F8 = 0x42,
-    KEY_D_F9 = 0x43,
-    KEY_D_F10 = 0x44,
-    KEY_D_F11 = 0x57,
-    KEY_D_F12 = 0x58,
-
-    KEY_D_UP = 0x48,
-    KEY_D_LEFT = 0x4b,
-    KEY_D_RIGHT = 0x4d,
-    KEY_D_DOWN = 0x50,
-
-    KEY_U_ESCAPE = 0x81,
-    KEY_U_1 = 0x82,
-    KEY_U_2 = 0x83,
-    KEY_U_3 = 0x84,
-    KEY_U_4 = 0x85,
-    KEY_U_5 = 0x86,
-    KEY_U_6 = 0x87,
-    KEY_U_7 = 0x88,
-    KEY_U_8 = 0x89,
-    KEY_U_9 = 0x8a,
-    KEY_U_0 = 0x8b,
-    KEY_U_MINUS = 0x8c,
-    KEY_U_EQUALS = 0x8d,
-    KEY_U_BACKSPACE = 0x8e,
-    KEY_U_TAB = 0x8f,
-    KEY_U_Q = 0x90,
-    KEY_U_W = 0x91,
-    KEY_U_E = 0x92,
-    KEY_U_R = 0x93,
-    KEY_U_T = 0x94,
-    KEY_U_Y = 0x95,
-    KEY_U_U = 0x96,
-    KEY_U_I = 0x97,
-    KEY_U_O = 0x98,
-    KEY_U_P = 0x99,
-    KEY_U_LBRACKET = 0x9a,
-    KEY_U_RBRACKET = 0x9b,
-    KEY_U_RETURN = 0x9c,
-    KEY_U_LCTRL = 0x9d,
-    KEY_U_A = 0x9e,
-    KEY_U_S = 0x9f,
-    KEY_U_D = 0xa0,
-    KEY_U_F = 0xa1,
-    KEY_U_G = 0xa2,
-    KEY_U_H = 0xa3,
-    KEY_U_J = 0xa4,
-    KEY_U_K = 0xa5,
-    KEY_U_L = 0xa6,
-    KEY_U_SEMICOLON = 0xa7,
-    KEY_U_APOSTROPHE = 0xa8,
-    KEY_U_GRAVE = 0xa9,
-    KEY_U_LSHIFT = 0xaa,
-    KEY_U_BACKSLASH = 0xab,
-    KEY_U_Z = 0xac,
-    KEY_U_X = 0xad,
-    KEY_U_C = 0xae,
-    KEY_U_V = 0xaf,
-    KEY_U_B = 0xb0,
-    KEY_U_N = 0xb1,
-    KEY_U_M = 0xb2,
-    KEY_U_COMMA = 0xb3,
-    KEY_U_PERIOD = 0xb4,
-    KEY_U_SLASH = 0xb5,
-    KEY_U_RSHIFT = 0xb6,
-    KEY_U_KP_MULTIPLY = 0xb7,
-    KEY_U_LALT = 0xb8,
-    KEY_U_SPACE = 0xb9,
-    KEY_U_CAPSLOCK = 0xba,
-    KEY_U_F1 = 0xbb,
-    KEY_U_F2 = 0xbc,
-    KEY_U_F3 = 0xbd,
-    KEY_U_F4 = 0xbe,
-    KEY_U_F5 = 0xbf,
-    KEY_U_F6 = 0xc0,
-    KEY_U_F7 = 0xc1,
-    KEY_U_F8 = 0xc2,
-    KEY_U_F9 = 0xc3,
-    KEY_U_F10 = 0xc4,
-    KEY_U_NUMLOCK = 0xc5,
-    KEY_U_SCROLLLOCK = 0xc6,
-    KEY_U_KP_7 = 0xc7,
-    KEY_U_KP_8 = 0xc8,
-    KEY_U_KP_9 = 0xc9,
-    KEY_U_KP_MINUS = 0xca,
-    KEY_U_KP_4 = 0xcb,
-    KEY_U_KP_5 = 0xcc,
-    KEY_U_KP_6 = 0xcd,
-    KEY_U_KP_PLUS = 0xce,
-    KEY_U_KP_1 = 0xcf,
-    KEY_U_KP_2 = 0xd0,
-    KEY_U_KP_3 = 0xd1,
-    KEY_U_KP_0 = 0xd2,
-    KEY_U_KP_PERIOD = 0xd3,
-    KEY_U_F11 = 0xd7,
-    KEY_U_F12 = 0xd8,
-};
-
-namespace CrashHandler
-{
-    extern int SBIdx;
-
-    class CrashKeyboardDriver : public Interrupts::Handler
-    {
-    private:
-#if defined(a64)
-        void OnInterruptReceived(CPU::x64::TrapFrame *Frame);
-#elif defined(a32)
-        void OnInterruptReceived(CPU::x32::TrapFrame *Frame);
-#elif defined(aa64)
-        void OnInterruptReceived(void *Frame);
-#endif
-    public:
-        CrashKeyboardDriver();
-        ~CrashKeyboardDriver();
-    };
-
-    void TraceFrames(CHArchTrapFrame *Frame, int Count, SymbolResolver::Symbols *SymHandle, bool Kernel);
-
-    void ArrowInput(uint8_t key);
-    void UserInput(char *Input);
-    void HookKeyboard();
-
-    void DisplayMainScreen(CRData data);
-    void DisplayDetailsScreen(CRData data);
-    void DisplayStackFrameScreen(CRData data);
-    void DisplayTasksScreen(CRData data);
-    void DisplayConsoleScreen(CRData data);
-}
-
-void DivideByZeroExceptionHandler(CHArchTrapFrame *Frame);
-void DebugExceptionHandler(CHArchTrapFrame *Frame);
-void NonMaskableInterruptExceptionHandler(CHArchTrapFrame *Frame);
-void BreakpointExceptionHandler(CHArchTrapFrame *Frame);
-void OverflowExceptionHandler(CHArchTrapFrame *Frame);
-void BoundRangeExceptionHandler(CHArchTrapFrame *Frame);
-void InvalidOpcodeExceptionHandler(CHArchTrapFrame *Frame);
-void DeviceNotAvailableExceptionHandler(CHArchTrapFrame *Frame);
-void DoubleFaultExceptionHandler(CHArchTrapFrame *Frame);
-void CoprocessorSegmentOverrunExceptionHandler(CHArchTrapFrame *Frame);
-void InvalidTSSExceptionHandler(CHArchTrapFrame *Frame);
-void SegmentNotPresentExceptionHandler(CHArchTrapFrame *Frame);
-void StackFaultExceptionHandler(CHArchTrapFrame *Frame);
-void GeneralProtectionExceptionHandler(CHArchTrapFrame *Frame);
-void PageFaultExceptionHandler(CHArchTrapFrame *Frame);
-void x87FloatingPointExceptionHandler(CHArchTrapFrame *Frame);
-void AlignmentCheckExceptionHandler(CHArchTrapFrame *Frame);
-void MachineCheckExceptionHandler(CHArchTrapFrame *Frame);
-void SIMDFloatingPointExceptionHandler(CHArchTrapFrame *Frame);
-void VirtualizationExceptionHandler(CHArchTrapFrame *Frame);
-void SecurityExceptionHandler(CHArchTrapFrame *Frame);
-void UnknownExceptionHandler(CHArchTrapFrame *Frame);
-void UserModeExceptionHandler(CHArchTrapFrame *Frame);
-
-#endif // !__FENNIX_KERNEL_CRASH_HANDLERS_FUNCTIONS_H__
--- a/Kernel/Core/Debugger.cpp
+++ b/Kernel/Core/Debugger.cpp
@@ -1,138 +0,0 @@
-#include <debug.h>
-
-#include <uart.hpp>
-#include <printf.h>
-#include <lock.hpp>
-
-NewLock(DebuggerLock);
-
-using namespace UniversalAsynchronousReceiverTransmitter;
-
-static inline NIF void uart_wrapper(char c, void *unused)
-{
-    UART(COM1).Write(c);
-    UNUSED(unused);
-}
-
-static inline NIF void WritePrefix(DebugLevel Level, const char *File, int Line, const char *Function)
-{
-    const char *DbgLvlString;
-    switch (Level)
-    {
-    case DebugLevelError:
-        DbgLvlString = "ERROR";
-        break;
-    case DebugLevelWarning:
-        DbgLvlString = "WARN ";
-        break;
-    case DebugLevelInfo:
-        DbgLvlString = "INFO ";
-        break;
-    case DebugLevelDebug:
-        DbgLvlString = "DEBUG";
-        break;
-    case DebugLevelTrace:
-        DbgLvlString = "TRACE";
-        break;
-    case DebugLevelFixme:
-        DbgLvlString = "FIXME";
-        break;
-    case DebugLevelUbsan:
-    {
-        DbgLvlString = "UBSAN";
-        fctprintf(uart_wrapper, nullptr, "%s|%s: ", DbgLvlString, Function);
-        return;
-    }
-    default:
-        DbgLvlString = "UNKNW";
-        break;
-    }
-    fctprintf(uart_wrapper, nullptr, "%s|%s->%s:%d: ", DbgLvlString, File, Function, Line);
-}
-
-namespace SysDbg
-{
-    NIF void Write(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-    {
-        WritePrefix(Level, File, Line, Function);
-        va_list args;
-        va_start(args, Format);
-        vfctprintf(uart_wrapper, nullptr, Format, args);
-        va_end(args);
-    }
-
-    NIF void WriteLine(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-    {
-        WritePrefix(Level, File, Line, Function);
-        va_list args;
-        va_start(args, Format);
-        vfctprintf(uart_wrapper, nullptr, Format, args);
-        va_end(args);
-        uart_wrapper('\n', nullptr);
-    }
-
-    NIF void LockedWrite(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-    {
-        SmartTimeoutLock(DebuggerLock, 1000);
-        WritePrefix(Level, File, Line, Function);
-        va_list args;
-        va_start(args, Format);
-        vfctprintf(uart_wrapper, nullptr, Format, args);
-        va_end(args);
-    }
-
-    NIF void LockedWriteLine(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-    {
-        SmartTimeoutLock(DebuggerLock, 1000);
-        WritePrefix(Level, File, Line, Function);
-        va_list args;
-        va_start(args, Format);
-        vfctprintf(uart_wrapper, nullptr, Format, args);
-        va_end(args);
-        uart_wrapper('\n', nullptr);
-    }
-}
-
-// C compatibility
-extern "C" NIF void SysDbgWrite(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-{
-    WritePrefix(Level, File, Line, Function);
-    va_list args;
-    va_start(args, Format);
-    vfctprintf(uart_wrapper, nullptr, Format, args);
-    va_end(args);
-}
-
-// C compatibility
-extern "C" NIF void SysDbgWriteLine(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-{
-    WritePrefix(Level, File, Line, Function);
-    va_list args;
-    va_start(args, Format);
-    vfctprintf(uart_wrapper, nullptr, Format, args);
-    va_end(args);
-    uart_wrapper('\n', nullptr);
-}
-
-// C compatibility
-extern "C" NIF void SysDbgLockedWrite(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-{
-    SmartTimeoutLock(DebuggerLock, 1000);
-    WritePrefix(Level, File, Line, Function);
-    va_list args;
-    va_start(args, Format);
-    vfctprintf(uart_wrapper, nullptr, Format, args);
-    va_end(args);
-}
-
-// C compatibility
-extern "C" NIF void SysDbgLockedWriteLine(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
-{
-    SmartTimeoutLock(DebuggerLock, 1000);
-    WritePrefix(Level, File, Line, Function);
-    va_list args;
-    va_start(args, Format);
-    vfctprintf(uart_wrapper, nullptr, Format, args);
-    va_end(args);
-    uart_wrapper('\n', nullptr);
-}
--- a/Kernel/Core/Disk.cpp
+++ b/Kernel/Core/Disk.cpp
@@ -1,158 +0,0 @@
-#include <disk.hpp>
-
-#include <memory.hpp>
-#include <printf.h>
-
-#include "../kernel.h"
-#include "../DAPI.hpp"
-#include "../Fex.hpp"
-
-namespace Disk
-{
-    void Manager::FetchDisks(unsigned long DriverUID)
-    {
-        KernelCallback *callback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback)));
-        memset(callback, 0, sizeof(KernelCallback));
-        callback->Reason = FetchReason;
-        DriverManager->IOCB(DriverUID, (void *)callback);
-        this->AvailablePorts = callback->DiskCallback.Fetch.Ports;
-        this->BytesPerSector = callback->DiskCallback.Fetch.BytesPerSector;
-        debug("AvailablePorts:%ld BytesPerSector:%ld", this->AvailablePorts, this->BytesPerSector);
-
-        if (this->AvailablePorts <= 0)
-        {
-            KernelAllocator.FreePages((void *)callback, TO_PAGES(sizeof(KernelCallback)));
-            return;
-        }
-
-        uint8_t *RWBuffer = (uint8_t *)KernelAllocator.RequestPages(TO_PAGES(this->BytesPerSector));
-
-        for (unsigned char ItrPort = 0; ItrPort < this->AvailablePorts; ItrPort++)
-        {
-            Drive *drive = new Drive;
-            sprintf(drive->Name, "sd%ld-%d", DriverUID, this->AvailablePorts);
-            debug("Drive Name: %s", drive->Name);
-            // TODO: Implement disk type detection. Very useful in the future.
-            drive->MechanicalDisk = true;
-
-            memset(RWBuffer, 0, this->BytesPerSector);
-            memset(callback, 0, sizeof(KernelCallback));
-            callback->Reason = ReceiveReason;
-            callback->DiskCallback.RW = {
-                .Sector = 0,
-                .SectorCount = 2,
-                .Port = ItrPort,
-                .Buffer = RWBuffer,
-                .Write = false,
-            };
-            DriverManager->IOCB(DriverUID, (void *)callback);
-            memcpy(&drive->Table, RWBuffer, sizeof(PartitionTable));
-
-            /*
-            TODO: Add to devfs the disk
-            */
-
-            if (drive->Table.GPT.Signature == GPT_MAGIC)
-            {
-                drive->Style = GPT;
-                uint32_t Entries = 512 / drive->Table.GPT.EntrySize;
-                uint32_t Sectors = drive->Table.GPT.PartCount / Entries;
-                for (uint32_t Block = 0; Block < Sectors; Block++)
-                {
-                    memset(RWBuffer, 0, this->BytesPerSector);
-                    memset(callback, 0, sizeof(KernelCallback));
-                    callback->Reason = ReceiveReason;
-                    callback->DiskCallback.RW = {
-                        .Sector = 2 + Block,
-                        .SectorCount = 1,
-                        .Port = ItrPort,
-                        .Buffer = RWBuffer,
-                        .Write = false,
-                    };
-                    DriverManager->IOCB(DriverUID, (void *)callback);
-
-                    for (uint32_t e = 0; e < Entries; e++)
-                    {
-                        GUIDPartitionTablePartition GPTPartition = reinterpret_cast<GUIDPartitionTablePartition *>(RWBuffer)[e];
-                        if (GPTPartition.TypeLow || GPTPartition.TypeHigh)
-                        {
-                            Partition *partition = new Partition;
-                            memcpy(partition->Label, GPTPartition.Label, sizeof(partition->Label));
-                            partition->StartLBA = GPTPartition.StartLBA;
-                            partition->EndLBA = GPTPartition.EndLBA;
-                            partition->Sectors = partition->EndLBA - partition->StartLBA;
-                            partition->Port = ItrPort;
-                            partition->Flags = Present;
-                            partition->Style = GPT;
-                            if (GPTPartition.Attributes & 1)
-                                partition->Flags |= EFISystemPartition;
-                            partition->Index = drive->Partitions.size();
-                            // why there is NUL (\0) between every char?????
-                            char PartName[72];
-                            memcpy(PartName, GPTPartition.Label, 72);
-                            for (int i = 0; i < 72; i++)
-                                if (PartName[i] == '\0')
-                                    PartName[i] = ' ';
-                            PartName[71] = '\0';
-                            trace("GPT partition \"%s\" found with %lld sectors", PartName, partition->Sectors);
-                            drive->Partitions.push_back(partition);
-
-                            char *PartitionName = new char[64];
-                            sprintf(PartitionName, "sd%ldp%ld", drives.size() - 1, partition->Index);
-
-                            /*
-                            TODO: Add to devfs the disk
-                            */
-
-                            delete[] PartitionName;
-                        }
-                    }
-                }
-                trace("%d GPT partitions found.", drive->Partitions.size());
-            }
-            else if (drive->Table.MBR.Signature[0] == MBR_MAGIC0 && drive->Table.MBR.Signature[1] == MBR_MAGIC1)
-            {
-                drive->Style = MBR;
-                for (size_t p = 0; p < 4; p++)
-                    if (drive->Table.MBR.Partitions[p].LBAFirst != 0)
-                    {
-                        Partition *partition = new Partition;
-                        partition->StartLBA = drive->Table.MBR.Partitions[p].LBAFirst;
-                        partition->EndLBA = drive->Table.MBR.Partitions[p].LBAFirst + drive->Table.MBR.Partitions[p].Sectors;
-                        partition->Sectors = drive->Table.MBR.Partitions[p].Sectors;
-                        partition->Port = ItrPort;
-                        partition->Flags = Present;
-                        partition->Style = MBR;
-                        partition->Index = drive->Partitions.size();
-                        trace("Partition \"%#llx\" found with %lld sectors.", drive->Table.MBR.UniqueID, partition->Sectors);
-                        drive->Partitions.push_back(partition);
-
-                        char *PartitionName = new char[64];
-                        sprintf(PartitionName, "sd%ldp%ld", drives.size() - 1, partition->Index);
-
-                        /*
-                        TODO: Add to devfs the disk
-                        */
-
-                        delete[] PartitionName;
-                    }
-                trace("%d MBR partitions found.", drive->Partitions.size());
-            }
-            else
-                warn("No partition table found on port %d!", ItrPort);
-
-            drives.push_back(drive);
-        }
-
-        KernelAllocator.FreePages((void *)callback, TO_PAGES(sizeof(KernelCallback)));
-    }
-
-    Manager::Manager()
-    {
-    }
-
-    Manager::~Manager()
-    {
-        debug("Destructor called");
-    }
-}
--- a/Kernel/Core/Driver/Driver.cpp
+++ b/Kernel/Core/Driver/Driver.cpp
@@ -1,234 +0,0 @@
-#include <driver.hpp>
-
-#include <ints.hpp>
-#include <memory.hpp>
-#include <task.hpp>
-#include <lock.hpp>
-#include <printf.h>
-#include <cwalk.h>
-#include <md5.h>
-
-#include "../../kernel.h"
-#include "../../DAPI.hpp"
-#include "../../Fex.hpp"
-#include "api.hpp"
-
-NewLock(DriverInitLock);
-NewLock(DriverInterruptLock);
-
-namespace Driver
-{
-    const char *DriverTypesName[] = {
-        "Unknown",
-        "Generic",
-        "Display",
-        "Network",
-        "Storage",
-        "FileSystem",
-        "Input",
-        "Audio"};
-
-    void Driver::UnloadAllDrivers()
-    {
-        size_t DriversNum = Drivers.size();
-        debug("%ld drivers loaded, [DUIDs: %ld]", DriversNum, DriverUIDs);
-        debug("driver size %ld", DriversNum);
-        for (size_t i = 0; i < DriversNum; i++)
-        {
-            DriverFile *drv = Drivers[i];
-            KernelCallback callback;
-            callback.Reason = StopReason;
-            debug("Stopping & unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
-            DriverManager->IOCB(drv->DriverUID, (void *)&callback);
-
-            delete drv->MemTrk, drv->MemTrk = nullptr;
-            for (size_t j = 0; j < sizeof(drv->InterruptHook) / sizeof(drv->InterruptHook[0]); j++)
-            {
-                if (!drv->InterruptHook[j])
-                    continue;
-                delete drv->InterruptHook[j], drv->InterruptHook[j] = nullptr;
-            }
-            delete drv, drv = nullptr;
-            Drivers.remove(i);
-        }
-    }
-
-    bool Driver::UnloadDriver(unsigned long DUID)
-    {
-        debug("Searching for driver %ld", DUID);
-        for (size_t i = 0; i < Drivers.size(); i++)
-        {
-            DriverFile *drv = Drivers[i];
-            if (drv->DriverUID == DUID)
-            {
-                KernelCallback callback;
-                callback.Reason = StopReason;
-                debug("Stopping and unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
-                this->IOCB(drv->DriverUID, (void *)&callback);
-
-                delete drv->MemTrk, drv->MemTrk = nullptr;
-                for (size_t i = 0; i < sizeof(drv->InterruptHook) / sizeof(drv->InterruptHook[0]); i++)
-                {
-                    if (!drv->InterruptHook[i])
-                        continue;
-                    delete drv->InterruptHook[i], drv->InterruptHook[i] = nullptr;
-                }
-                delete drv, drv = nullptr;
-                Drivers.remove(i);
-                return true;
-            }
-        }
-        return false;
-    }
-
-    int Driver::IOCB(unsigned long DUID, void *KCB)
-    {
-        foreach (auto Drv in Drivers)
-        {
-            if (Drv->DriverUID == DUID)
-            {
-                FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)Drv->Address + EXTENDED_SECTION_ADDRESS);
-                int ret = ((int (*)(void *))((uintptr_t)DrvExtHdr->Driver.Callback + (uintptr_t)Drv->Address))(KCB);
-                __sync;
-                return ret;
-            }
-        }
-        return -1;
-    }
-
-    DriverCode Driver::CallDriverEntryPoint(void *fex, void *KAPIAddress)
-    {
-        memcpy(KAPIAddress, &KernelAPITemplate, sizeof(KernelAPI));
-
-        ((KernelAPI *)KAPIAddress)->Info.Offset = (unsigned long)fex;
-        ((KernelAPI *)KAPIAddress)->Info.DriverUID = DriverUIDs++;
-
-        debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, ((KernelAPI *)KAPIAddress)->Info.DriverUID);
-        int ret = ((int (*)(KernelAPI *))((uintptr_t)((Fex *)fex)->EntryPoint + (uintptr_t)fex))(((KernelAPI *)KAPIAddress));
-
-        if (DriverReturnCode::OK != ret)
-            return DriverCode::DRIVER_RETURNED_ERROR;
-        return DriverCode::OK;
-    }
-
-    DriverCode Driver::LoadDriver(uintptr_t DriverAddress, uintptr_t Size)
-    {
-        Fex *DrvHdr = (Fex *)DriverAddress;
-        if (DrvHdr->Magic[0] != 'F' || DrvHdr->Magic[1] != 'E' || DrvHdr->Magic[2] != 'X' || DrvHdr->Magic[3] != '\0')
-        {
-            if (Size > 0x1000)
-            {
-                Fex *ElfDrvHdr = (Fex *)(DriverAddress + 0x1000);
-                if (ElfDrvHdr->Magic[0] != 'F' || ElfDrvHdr->Magic[1] != 'E' || ElfDrvHdr->Magic[2] != 'X' || ElfDrvHdr->Magic[3] != '\0')
-                    return DriverCode::INVALID_FEX_HEADER;
-                else
-                {
-                    debug("Fex Magic: \"%s\"; Type: %d; OS: %d; EntryPoint: %#lx", ElfDrvHdr->Magic, ElfDrvHdr->Type, ElfDrvHdr->OS, ElfDrvHdr->EntryPoint);
-
-                    if (ElfDrvHdr->Type == FexFormatType::FexFormatType_Driver)
-                    {
-                        FexExtended *ElfDrvExtHdr = (FexExtended *)((uintptr_t)ElfDrvHdr + EXTENDED_SECTION_ADDRESS);
-                        debug("Name: \"%s\"; Type: %d; Callback: %#lx", ElfDrvExtHdr->Driver.Name, ElfDrvExtHdr->Driver.Type, ElfDrvExtHdr->Driver.Callback);
-
-                        if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PCI)
-                            return this->DriverLoadBindPCI(ElfDrvExtHdr, DriverAddress, Size, true);
-                        else if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INTERRUPT)
-                            return this->DriverLoadBindInterrupt(ElfDrvExtHdr, DriverAddress, Size, true);
-                        else if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PROCESS)
-                            return this->DriverLoadBindProcess(ElfDrvExtHdr, DriverAddress, Size, true);
-                        else if (ElfDrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INPUT)
-                            return this->DriverLoadBindInput(ElfDrvExtHdr, DriverAddress, Size, true);
-                        else
-                            error("Unknown driver bind type: %d", ElfDrvExtHdr->Driver.Bind.Type);
-                    }
-                    else
-                        return DriverCode::NOT_DRIVER;
-                }
-            }
-            else
-                return DriverCode::INVALID_FEX_HEADER;
-        }
-        debug("Fex Magic: \"%s\"; Type: %d; OS: %d; EntryPoint: %#lx", DrvHdr->Magic, DrvHdr->Type, DrvHdr->OS, DrvHdr->EntryPoint);
-
-        if (DrvHdr->Type == FexFormatType::FexFormatType_Driver)
-        {
-            FexExtended *DrvExtHdr = (FexExtended *)((uintptr_t)DrvHdr + EXTENDED_SECTION_ADDRESS);
-            debug("Name: \"%s\"; Type: %d; Callback: %#lx", DrvExtHdr->Driver.Name, DrvExtHdr->Driver.Type, DrvExtHdr->Driver.Callback);
-
-            if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PCI)
-                return this->DriverLoadBindPCI(DrvExtHdr, DriverAddress, Size);
-            else if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INTERRUPT)
-                return this->DriverLoadBindInterrupt(DrvExtHdr, DriverAddress, Size);
-            else if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_PROCESS)
-                return this->DriverLoadBindProcess(DrvExtHdr, DriverAddress, Size);
-            else if (DrvExtHdr->Driver.Bind.Type == DriverBindType::BIND_INPUT)
-                return this->DriverLoadBindInput(DrvExtHdr, DriverAddress, Size);
-            else
-                error("Unknown driver bind type: %d", DrvExtHdr->Driver.Bind.Type);
-        }
-        else
-            return DriverCode::NOT_DRIVER;
-        return DriverCode::ERROR;
-    }
-
-    Driver::Driver()
-    {
-        SmartCriticalSection(DriverInitLock);
-        shared_ptr<VirtualFileSystem::File> DriverDirectory = vfs->Open(Config.DriverDirectory);
-        if (DriverDirectory->Status == VirtualFileSystem::FileStatus::OK)
-        {
-            foreach (auto driver in DriverDirectory->node->Children)
-                if (driver->Flags == VirtualFileSystem::NodeFlags::FILE)
-                    if (cwk_path_has_extension(driver->Name))
-                    {
-                        const char *extension;
-                        cwk_path_get_extension(driver->Name, &extension, nullptr);
-                        debug("Driver: %s; Extension: %s", driver->Name, extension);
-                        if (strcmp(extension, ".fex") == 0 || strcmp(extension, ".elf") == 0)
-                        {
-                            uintptr_t ret = this->LoadDriver(driver->Address, driver->Length);
-                            char RetString[128];
-                            if (ret == DriverCode::OK)
-                                strncpy(RetString, "\e058C19OK", 10);
-                            else if (ret == DriverCode::NOT_AVAILABLE)
-                                strncpy(RetString, "\eFF7900NOT AVAILABLE", 21);
-                            else
-                                sprintf(RetString, "\eE85230FAILED (%#lx)", ret);
-                            KPrint("%s %s", driver->Name, RetString);
-                        }
-                    }
-        }
-        else
-        {
-            KPrint("\eE85230Failed to open driver directory: %s! (Status: %#lx)", Config.DriverDirectory, DriverDirectory->Status);
-            CPU::Stop();
-        }
-        vfs->Close(DriverDirectory);
-    }
-
-    Driver::~Driver()
-    {
-        debug("Destructor called");
-        this->UnloadAllDrivers();
-    }
-
-#if defined(a64)
-    SafeFunction void DriverInterruptHook::OnInterruptReceived(CPU::x64::TrapFrame *Frame)
-#elif defined(a32)
-    SafeFunction void DriverInterruptHook::OnInterruptReceived(CPU::x32::TrapFrame *Frame)
-#elif defined(aa64)
-    SafeFunction void DriverInterruptHook::OnInterruptReceived(void *Frame)
-#endif
-    {
-        SmartLock(DriverInterruptLock);
-        ((int (*)(void *))(Handle))(Data);
-        UNUSED(Frame);
-    }
-
-    DriverInterruptHook::DriverInterruptHook(int Interrupt, void *Address, void *ParamData) : Interrupts::Handler(Interrupt)
-    {
-        trace("Interrupt %d Hooked", Interrupt - 32); // x86
-        Handle = Address;
-        Data = ParamData;
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
EnderIce2	ce3cf8162a	chore: Update codebase Some checks failed Build OS / Deploy Documentation to GitHub Pages (push) Failing after 53s Details Build OS / Build Cross-Compiler & Toolchain (push) Failing after 17m52s Details Build OS / Analyze with CodeQL (cpp) (push) Has been skipped Details Build OS / Build amd64 (push) Has been skipped Details Build OS / Build i386 (push) Has been skipped Details Build OS / Build aarch64 (push) Has been skipped Details	2024-11-28 04:47:30 +02:00
EnderIce2	640b902045	chore: Update vscode workspace files Some checks failed Build OS / Deploy Documentation to GitHub Pages (push) Has been cancelled Details Build OS / Build Cross-Compiler & Toolchain (push) Has been cancelled Details Build OS / Analyze with CodeQL (cpp) (push) Has been cancelled Details Build OS / Build amd64 (push) Has been cancelled Details Build OS / Build i386 (push) Has been cancelled Details Build OS / Build aarch64 (push) Has been cancelled Details	2024-11-27 01:56:37 +02:00
EnderIce2	0dbdacb8df	chore: General cleanup	2024-11-27 01:19:24 +02:00
EnderIce2	220238eff8	chore: Revert last change Some checks failed Build OS / Deploy Documentation to GitHub Pages (push) Failing after 13s Details Build OS / Build Cross-Compiler & Toolchain (push) Failing after 9s Details Build OS / Build GNU-EFI (push) Failing after 5s Details Build OS / Analyze with CodeQL (cpp) (push) Has been skipped Details Build OS / Build amd64 (push) Has been skipped Details Build OS / Build i386 (push) Has been skipped Details Build OS / Build aarch64 (push) Has been skipped Details	2024-11-26 04:13:34 +02:00
EnderIce2	360afdbc9c	chore: Remove sudo & change "apt-get" to "apt" Some checks failed Build OS / Deploy Documentation to GitHub Pages (push) Failing after 18s Details Build OS / Build Cross-Compiler & Toolchain (push) Failing after 10s Details Build OS / Build GNU-EFI (push) Failing after 11s Details Build OS / Analyze with CodeQL (cpp) (push) Has been skipped Details Build OS / Build amd64 (push) Has been skipped Details Build OS / Build i386 (push) Has been skipped Details Build OS / Build aarch64 (push) Has been skipped Details	2024-11-26 04:03:57 +02:00
EnderIce2	f34a222bf1	chore: TODO: Fix workflows Some checks failed Build OS / Deploy Documentation to GitHub Pages (push) Waiting to run Details Build OS / Build Cross-Compiler & Toolchain (push) Failing after 20s Details Build OS / Build GNU-EFI (push) Failing after 3s Details Build OS / Analyze with CodeQL (cpp) (push) Has been skipped Details Build OS / Build amd64 (push) Has been skipped Details Build OS / Build i386 (push) Has been skipped Details Build OS / Build aarch64 (push) Has been skipped Details Awesome...	2024-11-26 03:46:43 +02:00
EnderIce2	1b1d3e68fd	chore: Fix workflow error	2024-11-26 03:42:12 +02:00
EnderIce2	f11c00a4e3	chore: (Again) Fix workflow error Too bad that there's no way of testing a workflow.	2024-11-26 03:37:31 +02:00
EnderIce2	ae07b07964	chore: Fix workflow error "this file was generated for autoconf 2.69"	2024-11-26 03:32:40 +02:00
EnderIce2	23853cbb15	chore: Add experimental docker build	2024-11-26 03:27:25 +02:00
EnderIce2	00a37325f6	chore: Fix build process	2024-11-26 03:27:08 +02:00
EnderIce2	ce4ebaf6c5	Remove submodule Some checks failed Build OS / Deploy Documentation to GitHub Pages (push) Failing after 1m14s Details Build OS / Build Cross-Compiler & Toolchain (push) Failing after 1m2s Details Build OS / Build GNU-EFI (push) Failing after 7s Details Build OS / Analyze with CodeQL (cpp) (push) Has been skipped Details Build OS / Build amd64 (push) Has been skipped Details Build OS / Build i386 (push) Has been skipped Details Build OS / Build aarch64 (push) Has been skipped Details	2024-11-20 05:49:33 +02:00
EnderIce2	5806c4feaf	Update .gitmodules	2024-11-20 05:47:19 +02:00