run_debug.sh now checks if it running on wsl and disables boot_flags if it is since it was causing issues with qemu

.vscode/settings.json

@@ -6,6 +6,4 @@
         "editor.formatOnSave": true
     },
     "rust-analyzer.check.command": "clippy",
-    "rust-analyzer.procMacro.attributes.enable": true,
-    "rust-analyzer.cargo.buildScripts.enable": true
 }

Cargo.lock

@@ -22,9 +22,9 @@ checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
 
 [[package]]
 name = "cc"
-version = "1.2.16"
+version = "1.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
+checksum = "c736e259eea577f443d5c86c304f9f4ae0295c43f3ba05c21f1d66b5f06001af"
 dependencies = [
  "shlex",
 ]
@@ -35,10 +35,20 @@ version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
 dependencies = [
+ "crossbeam-epoch",
  "crossbeam-queue",
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-queue"
 version = "0.3.12"
@@ -100,9 +110,7 @@ name = "foundry_os"
 version = "0.1.0"
 dependencies = [
  "cc",
- "crossbeam",
+ "libk",
- "futures-util",
- "libm",
  "limine",
  "pc-keyboard",
  "pic8259",
@@ -140,6 +148,20 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
+[[package]]
+name = "libk"
+version = "0.1.0"
+dependencies = [
+ "crossbeam",
+ "futures-util",
+ "libm",
+ "limine",
+ "linked_list_allocator",
+ "pc-keyboard",
+ "spin",
+ "x86_64",
+]
+
 [[package]]
 name = "libm"
 version = "0.1.0"
@@ -159,6 +181,15 @@ dependencies = [
  "bitflags",
 ]
 
+[[package]]
+name = "linked_list_allocator"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afa463f5405ee81cdb9cc2baf37e08ec7e4c8209442b5d72c04cfb2cd6e6286"
+dependencies = [
+ "spinning_top",
+]
+
 [[package]]
 name = "lock_api"
 version = "0.4.12"
@@ -241,6 +272,15 @@ dependencies = [
  "lock_api",
 ]
 
+[[package]]
+name = "spinning_top"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b9eb1a2f4c41445a3a0ff9abc5221c5fcd28e1f13cd7c0397706f9ac938ddb0"
+dependencies = [
+ "lock_api",
+]
+
 [[package]]
 name = "strsim"
 version = "0.11.1"

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["kernel", "libm"]
+members = ["kernel", "libk", "libm"]
 resolver = "2"
 
 [workspace.package]

docs/Planning & To-Dos.md

@@ -6,11 +6,7 @@
 > 	- [ ] figure out how to run QEMU in the test environment
 > 	- [ ] write a script to run tests
 > 	- [ ] a release should only be published if all tests pass
->
+
-> [!todo] HAL (Hardware Abstraction Layer)
-> - [ ] use either traits or cfg attributes to support more than just x86_64
->   - [ ] prefer writing cross platform code (I am aware I made the problem slightly worse by merging libk with the kernel sources)
->
 > [!todo] Allocator
 > - [ ] learn about several allocator designs and decide on the optimal one
 > - [ ] implementation

kernel/Cargo.toml

@@ -6,19 +6,11 @@ authors.workspace = true
 
 [dependencies]
 limine = "0.3.1"
-# libk = { path = "../libk" }
+libk = { path = "../libk" }
 x86_64 = "0.15.2"
 spin = "0.9.8"
 pic8259 = "0.11.0"
 pc-keyboard = "0.8.0"
-libm = { version = "0.1.0", path = "../libm" }
-crossbeam = { version = "0.8.4", default-features = false, features = [
-    # "alloc",
-    "crossbeam-queue",
-] }
-futures-util = { version = "0.3.31", default-features = false, features = [
-    # "alloc",
-] }
 
 [build-dependencies]
 cc = "1.2.14"

kernel/src/arch/x86_64/apic/mod.rs

@@ -1,17 +1,19 @@
-#![expect(unused)]
 use core::arch::x86_64::__cpuid;
 
+use libk::drivers::memory::{FoundryOSFrameAllocator, FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
 use spin::Lazy;
-// use libk::drivers::memory::{FRAME_ALLOCATOR, FoundryOSFrameAllocator,
-// OFFSET_PAGE_TABLE};
 use x86_64::{
     PhysAddr, VirtAddr,
-    structures::paging::{Page, PageTableFlags, PhysFrame, Size4KiB},
+    instructions::port::Port,
+    registers::model_specific::Msr,
+    structures::paging::{
+        FrameAllocator, Mapper, Page, PageTableFlags, PhysFrame, Size4KiB, Translate,
+    },
 };
 
-// use crate::serial_print;
+use crate::serial_print;
 
-use super::{cpu::msr::*, memmap::PHYSICAL_MEMORY_OFFSET};
+use super::{cpu::model_specific_registers::*, memmap::PHYSICAL_MEMORY_OFFSET};
 
 const IA32_APIC_BASE_MSR: u32 = 0x1b;
 const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
@@ -20,11 +22,12 @@ const IA32_APIC_BASE_MSR_DISABLE: u64 = !IA32_APIC_BASE_MSR_ENABLE;
 
 const CPUID_FEAT_EDX_APIC: u64 = 1 << 9; // the cpuid instruction will return this flag if it supports APIC
 
-static APIC_VIRTUAL_ADDRESS: Lazy<VirtAddr> = Lazy::new(|| {
+// const APIC_VIRTUAL_ADDRESS: Lazy<VirtAddr> = Lazy::new(|| {
-    let apic_base = get_apic_base();
+//     let apic_base = get_apic_base();
+//     let virt_addr = unsafe { phys_to_virt(apic_base) };
 
-    unsafe { phys_to_virt(apic_base) }
+//     virt_addr
-});
+// });
 
 fn set_apic_base_enable(apic: PhysAddr) {
     let rax = (apic.as_u64() & 0xfffff0000) | IA32_APIC_BASE_MSR_ENABLE;
@@ -48,10 +51,10 @@ fn write_apic_register(apic_base: &VirtAddr, reg: u8, value: u32) {
     unsafe { *(reg_addr as *mut u32) = value };
 }
 
-const fn read_apic_register(apic_base: &VirtAddr, reg: u8) -> u32 {
+fn read_apic_register(apic_base: &VirtAddr, reg: u8) -> u32 {
     let apic_base = apic_base.as_u64();
 
-    // serial_print!("got apic base");
+    serial_print!("got apic base");
 
     let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
     unsafe { *(reg_addr as *const u32) }
@@ -65,13 +68,12 @@ pub fn check_apic() -> bool {
 #[inline(always)]
 unsafe fn phys_to_virt(phys: PhysAddr) -> VirtAddr {
     let phys = phys.as_u64();
-    phys.checked_add(*PHYSICAL_MEMORY_OFFSET)
+    phys.checked_add(*PHYSICAL_MEMORY_OFFSET).map_or_else(|| panic!(" overflow"), VirtAddr::new)
-        .map_or_else(|| panic!(" overflow"), VirtAddr::new)
 }
 
 pub fn enable_apic() {
-    // let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+    let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
-    // let mut frame_allocator = FRAME_ALLOCATOR.get().unwrap().lock();
+    let mut frame_allocator = FRAME_ALLOCATOR.get().unwrap().lock();
 
     let apic_phys_addr = get_apic_base();
     set_apic_base_enable(apic_phys_addr);
@@ -82,19 +84,19 @@ pub fn enable_apic() {
     let frame: PhysFrame<Size4KiB> = PhysFrame::containing_address(apic_phys_addr);
     let flags: PageTableFlags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
 
-    /*     unsafe {
+    unsafe {
         match mapper.map_to(page, frame, flags, &mut *frame_allocator) {
             Ok(_) => {}
             Err(why) => panic!("failed to map apic: {:?}", why),
         }
     }
-    */
+
     // // FIXME: this causes a page fault
     // // TODO: map to virtual memor
 
-    let reg = read_apic_register(&APIC_VIRTUAL_ADDRESS, 0xF0);
+    let reg = read_apic_register(&apic_virt, 0xF0);
 
-    // serial_print!("ok2");
+    serial_print!("ok2");
 
     write_apic_register(&apic_virt, 0xF0, reg | 0x100);
 }

kernel/src/arch/x86_64/cpu.rs

@@ -0,0 +1,26 @@
+pub mod model_specific_registers {
+    use core::arch::x86_64::__cpuid;
+    use spin::Lazy;
+    use x86_64::registers::model_specific::Msr;
+
+    const CPUID_FLAG_MSR: u32 = 1 << 5;
+    static EDX: Lazy<u32> = Lazy::new(|| unsafe { __cpuid(1).edx });
+
+    pub fn cpu_has_msr() -> bool {
+        *EDX & CPUID_FLAG_MSR != 0
+    }
+
+    pub fn cpu_get_msr(msr: u32, value: &mut u64) {
+        let msr = Msr::new(msr);
+        unsafe {
+            *value = msr.read();
+        }
+    }
+
+    pub fn cpu_set_msr(msr: u32, value: u64) {
+        let mut msr = Msr::new(msr);
+        unsafe {
+            msr.write(value);
+        }
+    }
+}

kernel/src/arch/x86_64/cpu/mod.rs

@@ -1,2 +0,0 @@
-pub mod msr;
-pub mod port;

kernel/src/arch/x86_64/cpu/msr.rs

@@ -1,24 +0,0 @@
-use core::arch::x86_64::__cpuid;
-use spin::Lazy;
-use x86_64::registers::model_specific::Msr;
-
-const CPUID_FLAG_MSR: u32 = 1 << 5;
-static EDX: Lazy<u32> = Lazy::new(|| unsafe { __cpuid(1).edx });
-
-pub fn cpu_has_msr() -> bool {
-    *EDX & CPUID_FLAG_MSR != 0
-}
-
-pub fn cpu_get_msr(msr: u32, value: &mut u64) {
-    let msr = Msr::new(msr);
-    unsafe {
-        *value = msr.read();
-    }
-}
-
-pub fn cpu_set_msr(msr: u32, value: u64) {
-    let mut msr = Msr::new(msr);
-    unsafe {
-        msr.write(value);
-    }
-}

kernel/src/arch/x86_64/dev/mod.rs

@@ -1,2 +0,0 @@
-pub mod pic;
-pub mod serial;

kernel/src/arch/x86_64/gdt.rs

@@ -1,11 +1,11 @@
 use x86_64::{
-    VirtAddr,
     instructions::tables::load_tss,
-    registers::segmentation::{CS, DS, ES, SS, Segment},
+    registers::segmentation::{Segment, CS, DS, ES, SS},
     structures::{
         gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector},
         tss::TaskStateSegment,
     },
+    VirtAddr,
 };
 
 use spin::Lazy;

kernel/src/arch/x86_64/interrupts.rs

@@ -1,12 +1,13 @@
+use libk::drivers::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
+use libk::prelude::*;
 use pic8259::ChainedPics;
-use x86_64::structures::idt::{
+use x86_64::registers::control::Cr2;
-    InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode,
+use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
-};
+use x86_64::structures::paging::mapper::MapperFlushAll;
+use x86_64::structures::paging::{FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB};
 
 use spin::{Lazy, Mutex};
 
-use crate::print_log;
-
 use super::gdt;
 
 static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
@@ -68,18 +69,16 @@ pub fn disable_pic() {
     }
 }
 
-const extern "x86-interrupt" fn breakpoint_handler(
+extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
-    _stack_frame: InterruptStackFrame,
+    serial_println!("Exception: Breakpoint\n{:#?}", stack_frame);
-) {
+    println_log!("Exception: Breakpoint\n{:#?}", stack_frame);
-    // serial_println!("Exception: Breakpoint\n{:#?}", stack_frame);
-    // println_log!("Exception: Breakpoint\n{:#?}", stack_frame);
 }
 
 extern "x86-interrupt" fn general_protection_fault_handler(
     stack_frame: InterruptStackFrame,
     _error_code: u64,
 ) {
-    // serial_println!("Exception: General Protection Fault\n{:#?}", stack_frame);
+    serial_println!("Exception: General Protection Fault\n{:#?}", stack_frame);
     panic!("Exception: General Protection Fault\n{:#?}", stack_frame);
 }
 
@@ -87,20 +86,17 @@ extern "x86-interrupt" fn double_fault_handler(
     stack_frame: InterruptStackFrame,
     _error_code: u64,
 ) -> ! {
-    // serial_println!("Exception: Double Fault\n{:#?}", stack_frame);
+    serial_println!("Exception: Double Fault\n{:#?}", stack_frame);
     panic!("Exception: Double Fault\n{:#?}", stack_frame);
 }
 
-extern "x86-interrupt" fn keyboard_interrupt_handler(
+extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
-    _stack_frame: InterruptStackFrame,
+    use pc_keyboard::{layouts, HandleControl, Keyboard, ScancodeSet1};
-) {
-    use pc_keyboard::{HandleControl, Keyboard, ScancodeSet1, layouts};
     // use pc_keyboard::DecodedKey;
     use spin::Mutex;
-    // use x86_64::instructions::port::Port;
+    use x86_64::instructions::port::Port;
 
-    static KEYBOARD: Lazy<Mutex<Keyboard<layouts::Uk105Key, ScancodeSet1>>> =
+    static KEYBOARD: Lazy<Mutex<Keyboard<layouts::Uk105Key, ScancodeSet1>>> = Lazy::new(|| {
-        Lazy::new(|| {
         Mutex::new(Keyboard::new(
             ScancodeSet1::new(),
             layouts::Uk105Key,
@@ -109,10 +105,10 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(
     });
 
     let _keyboard = KEYBOARD.lock();
-    // let mut port = Port::new(0x60);
+    let mut port = Port::new(0x60);
 
-    // let scancode: u8 = unsafe { port.read() };
+    let scancode: u8 = unsafe { port.read() };
-    // libk::drivers::io::keyboard::add_scancode(scancode);
+    libk::drivers::io::keyboard::add_scancode(scancode);
 
     unsafe {
         PICS.lock()
@@ -120,29 +116,23 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(
     }
 }
 
-extern "x86-interrupt" fn timer_interrupt_handler(
+extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
-    _stack_frame: InterruptStackFrame,
-) {
-    x86_64::instructions::interrupts::without_interrupts(|| {
-        print_log!("{:?}", _stack_frame)
-    });
-
     unsafe {
         PICS.lock()
             .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
     }
 }
 
-const extern "x86-interrupt" fn page_fault_handler(
+extern "x86-interrupt" fn page_fault_handler(
     _stack_frame: InterruptStackFrame,
     _error_code: PageFaultErrorCode,
 ) {
-    // serial_println!("Exception: Page Fault");
+    serial_println!("Exception: Page Fault");
-    // serial_println!("Accessed Address: {:?}", Cr2::read());
+    serial_println!("Accessed Address: {:?}", Cr2::read());
-    // serial_println!("Error Code: {:?}", _error_code);
+    serial_println!("Error Code: {:?}", _error_code);
-    // serial_println!("{:#?}", _stack_frame);
+    serial_println!("{:#?}", _stack_frame);
 
-    /*     if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
+    if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
         let mut f = frame_allocator.lock();
 
         let frame = f.allocate_frame().unwrap();
@@ -161,5 +151,4 @@ const extern "x86-interrupt" fn page_fault_handler(
     } else {
         panic!("failed to get frame allocator");
     }
-    */
 }

kernel/src/arch/x86_64/memmap.rs

@@ -1,4 +1,5 @@
 //! Sets up a memory map using Limine.
+
 use limine::{
     request::{HhdmRequest, KernelAddressRequest, MemoryMapRequest},
     response::MemoryMapResponse,

kernel/src/arch/x86_64/mod.rs

@@ -1,6 +1,9 @@
-pub mod apic;
-pub mod cpu;
-pub mod dev;
 pub mod gdt;
+
 pub mod interrupts;
+
 pub mod memmap;
+
+pub mod apic;
+
+pub mod cpu;

kernel/src/graphics/framebuffer.rs

@@ -1,158 +0,0 @@
-//! Handles setting up the framebuffer passed to us by Limine.
-#![expect(unused)]
-use crate::DEFAULT_FONT;
-
-use super::{colour::Colour, font::Font};
-
-use limine::framebuffer::Framebuffer;
-use limine::request::FramebufferRequest;
-use spin::{Lazy, Mutex};
-
-#[used]
-#[unsafe(link_section = ".requests")]
-/// The Limine framebuffer request.
-static FRAMEBUFFER_REQUEST: FramebufferRequest = FramebufferRequest::new();
-
-/// A mutex used for writing to the framebuffer, in most cases we can abstract
-/// this behind calls to println! etc.
-pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::new(
-    || {
-        Mutex::new(FRAMEBUFFER_REQUEST.get_response().map_or_else(
-            || {
-                unreachable!("Framebuffer request failed, got None.");
-            },
-            |framebuffer_response| {
-                let framebuffer =
-                    framebuffer_response.framebuffers().next()
-                    .expect("Expected to find at least one framebuffer in response, got zero.");
-                Some(FramebufferWriter::new(framebuffer, Colour::Black))
-            },
-        ))
-    },
-);
-
-/// The updated writer stores necessary fields from the [Framebuffer].
-/// This ensures that the contained types are Send, as Framebuffer was
-/// not marked as Send.
-///
-/// It also avoids the requirement for lifetimes.
-///
-/// Note this does not implement Writer as these functions only handle drawing
-/// pixels.
-pub struct FramebufferWriter {
-    pitch: u64,
-    /// Number of bits used per pixel, we expect 32 so this will be asserted
-    /// when we initialise the framebuffer.
-    bpp: u16,
-    /// A raw pointer to the framebuffer.
-    addr: *mut u8,
-    /// The width of the screen in pixels.
-    width: u64,
-    /// The height of the screen in pixels.
-    height: u64,
-    /// The default background colour of the Framebuffer.
-    background_colour: Colour,
-}
-
-/// Marker trait required for sending the writer across threads, which will
-/// probably come in handy later.
-unsafe impl Send for FramebufferWriter {}
-/// Marker trait required for sharing the writer across threads, which will
-/// probably come in handy later.
-///
-/// # Note
-///
-/// We wrap this in a Mutex later so this should handle synchronising accesses.
-unsafe impl Sync for FramebufferWriter {}
-
-impl FramebufferWriter {
-    /// Creates a new [`FramebufferWriter`] with the specified background
-    /// colour.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the bits per pixel for the framebuffer is not 32 bits per
-    /// pixel, because we didn't exactly handle other cases.
-    pub fn new(framebuffer: Framebuffer, background_colour: Colour) -> Self {
-        // We don't handle other cases, this should not trigger on most newer
-        // hardware.
-        assert!(framebuffer.bpp() == 32);
-
-        Self {
-            pitch: framebuffer.pitch(),
-            bpp: framebuffer.bpp(),
-            addr: framebuffer.addr(),
-            width: framebuffer.width(),
-            height: framebuffer.height(),
-            background_colour,
-        }
-    }
-
-    /// Writes a pixel with `colour` to the screen at the given `(x, y)`
-    /// coordinates (in pixels).
-    pub fn write_pixel(&self, x: usize, y: usize, colour: Colour) {
-        let pitch = self.pitch as usize;
-        let bpp = (self.bpp / 8) as usize;
-        let pixel_offset = y * pitch + x * bpp;
-
-        // Safety: We assume the pointer to the framebuffer is valid, which it likely
-        // is because we copy it from the Limine request.
-        unsafe {
-            *(self.addr.add(pixel_offset) as *mut u32) = colour.into();
-        }
-    }
-
-    /// Writes a 2D slice `buffer` to the screen. This should be less than the
-    /// size of the screen in dimensions, but does not neccessarily fill the
-    /// whole screen.
-    pub fn render_frame(&self, buffer: &[&[Colour]]) {
-        // TODO: this should return errors.
-        for (y, &row) in buffer.iter().enumerate() {
-            if y >= self.height() as usize {
-                break;
-            }
-            for (x, pixel) in row.iter().enumerate() {
-                if x >= self.width() as usize {
-                    break;
-                }
-                self.write_pixel(x, y, *pixel);
-            }
-        }
-    }
-
-    /// Returns the width of the framebuffer in pixels.
-    pub const fn width(&self) -> u32 {
-        self.width as u32
-    }
-
-    /// Returns the height of the framebuffer in pixels.
-    pub const fn height(&self) -> u32 {
-        self.height as u32
-    }
-
-    /// Sets the new default background colour.
-    pub const fn set_default_background_colour(&mut self, bg: Colour) {
-        self.background_colour = bg;
-    }
-
-    /// Clears the screen and sets the background to the default colour.
-    pub fn clear(&self) {
-        let width = self.width as usize;
-        let height = self.height as usize;
-
-        for y in 0..height {
-            for x in 0..width {
-                // Write the background in the preferred background colour.
-                self.write_pixel(x, y, self.background_colour);
-            }
-        }
-    }
-}
-
-/// Returns the screen size in pixels or (0, 0) if something went wrong.
-pub fn screensize_px() -> (u32, u32) {
-    FRAMEBUFFER_WRITER
-        .lock()
-        .as_mut()
-        .map_or_else(|| (0, 0), |writer| (writer.width(), writer.height()))
-}

kernel/src/graphics/mod.rs

@@ -1,4 +0,0 @@
-pub mod colour;
-pub mod font;
-pub mod framebuffer;
-pub mod writer;

kernel/src/io/mod.rs

@@ -1 +0,0 @@
-// pub mod keyboard;

kernel/src/lib.rs

@@ -11,64 +11,102 @@
     rustdoc::missing_panics_doc
 )]
 
-use arch::x86_64::dev::serial;
+extern crate alloc;
-use arch::x86_64::{gdt, interrupts};
+
+use arch::x86_64::apic::enable_apic;
 use core::arch::asm;
-use graphics::font::{FONT_SPLEEN_8X16, Font};
+use libk::drivers::memory;
 use limine::BaseRevision;
 
-pub mod arch;
+use libk::drivers::kalloc::allocator::init_heap;
-pub mod graphics;
+use libk::prelude::*;
-pub mod io;
+
+use x86_64::VirtAddr;
+
+mod arch;
 
 /// Sets the base revision to the latest revision supported by the crate.
 /// See specification for further info.
-/// Be sure to mark all limine requests with #[used], otherwise they may be
+/// Be sure to mark all limine requests with #[used], otherwise they may be removed by the compiler.
-/// removed by the compiler.
 #[used]
 // The .requests section allows limine to find the requests faster and more safely.
 #[unsafe(link_section = ".requests")]
 static BASE_REVISION: BaseRevision = BaseRevision::new();
 
-/// The default font used when setting up the framebuffer code.
-pub const DEFAULT_FONT: Font = FONT_SPLEEN_8X16;
-
 #[panic_handler]
 fn rust_panic(_info: &core::panic::PanicInfo) -> ! {
+    println!("Kernel panic: {}", _info);
+    serial_println!("Kernel panic: {}", _info);
     hcf();
 }
 
 pub fn hcf() -> ! {
     loop {
         unsafe {
+            #[cfg(target_arch = "x86_64")]
             asm!("hlt");
+            #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+            asm!("wfi");
+            #[cfg(target_arch = "loongarch64")]
+            asm!("idle 0");
         }
     }
 }
 
 pub fn boot() -> Result<(), &'static str> {
     if !BASE_REVISION.is_supported() {
-        return Err("Base Revision was not supported.");
+        return Err("base revision not supported");
     }
 
-    print_log!("    Setting up Serial Communication... ");
+    use arch::x86_64::{gdt, interrupts, memmap};
 
-    if serial::init().is_err() {
+    let memory_map = memmap::get_memory_map();
+
+    print_log!("    Initialising Serial... ");
+    if libk::drivers::io::serial::init().is_err() {
         println_log!("[Not Detected]")
     } else {
-        println_log!("[Success]")
+        println_log!("[Success]");
     }
 
-    print_log!("    Setting up GDT... ");
+    print_log!("    Setting Up Global Descriptor Table... ");
     gdt::init();
     println_log!("[Success]");
 
-    interrupts::enable_pic();
+    print_log!("    Setting Up Interrupt Descriptor Table... ");
-    // interrupts::disable_pic();
-
-    print_log!("    Initialising interrupts... ");
     interrupts::init_idt();
     println_log!("[Success]");
 
+    print_log!("    Initialising Memory Subsystem... ");
+    let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
+    memory::init_page_table(physical_memory_offset);
+    println_log!("[Success]");
+
+    print_log!("    Setting Up Page Table... ");
+    memory::init_frame_allocator(memory_map);
+    println_log!("[Success]");
+
+    print_log!("    Initialising Heap... ");
+    if init_heap().is_err() {
+        return Err("Failed to initialise heap: error");
+    }
+    println_log!("[Success]");
+
+    print_log!("    Enabling PICs... ");
+    interrupts::enable_pic();
+    println_log!("[Success]");
+
+    // print_log!("    Disabling PICs... ");
+    // interrupts::disable_pic();
+    // println_log!("[Success]");
+
+    // print_log!("    Initialising APIC");
+    // enable_apic();
+    // println_log!("[Success]");
+
+    print_log!("    Enabling Interrupts... ");
+    x86_64::instructions::interrupts::enable();
+    println_log!("[Success]");
+
     Ok(())
 }

kernel/src/main.rs

@@ -1,12 +1,43 @@
 #![no_std]
 #![no_main]
 
-use foundry_os::boot;
+extern crate alloc;
+
+use alloc::vec;
+use libk::{
+    drivers::{
+        async_io::task::{Executor, Task},
+        io::{self, framebuffer::colour::Colour},
+    },
+    prelude::*,
+    util::shell::shell,
+};
 
 #[unsafe(no_mangle)]
 extern "C" fn kmain() -> ! {
-    _ = boot();
+    println_log!(" [ Initialising Kernel Systems ] ");
+    if let Err(err) = foundry_os::boot() {
+        panic!("{}", err);
+    }
+
+    println_log!("[ Kernel Initialised Successfully ] ");
+
+    let dimensions = io::ascii::screensize_chars();
+    let dimensions2 = io::framebuffer::display::screensize_px();
+
+    println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
+    println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
+
+    // println!("TESTING :: Allocation");
+    // let somevec = vec![0; 1_000_000];
+    // println!("{:?}", somevec);
+    // println!("{}", somevec.len());
+    // println!("PASSED!");
+
+
+    let mut executor = Executor::new();
+    executor.spawn(Task::new(shell()));
+    executor.run();
 
-    #[allow(clippy::empty_loop)]
     loop {}
 }

libk/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "libk"
+publish = ["gitea"]
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+description = "A library crate used to write the kernel for Foundry OS."
+
+[dependencies]
+limine = "0.3.1"
+x86_64 = "0.15.2"
+crossbeam = { version = "0.8.4", default-features = false, features = [
+    "alloc",
+    "crossbeam-queue",
+] }
+pc-keyboard = "0.8.0"
+spin = "0.9.8"
+futures-util = { version = "0.3.31", default-features = false, features = [
+    "alloc",
+] }
+linked_list_allocator = { version = "0.10.5", features = ["use_spin"] }
+libm = { path = "../libm" }

libk/README.md

@@ -0,0 +1,24 @@
+# libk is for the code that did not make the kernel*
+
+\*crate, lol.
+
+libk is an attempt to move away from the godforsaken git submodules that plagued our forefathers. Now we have a crate containing a bunch of code that didn't quite make the core kernel crate, which should be:
+
+* simpler to maintain
+* has a catchier name
+* less fighting with Cargo.toml manifests
+
+## TODO:
+
+A lot of things must be improved and worked on, feel free to add extra TODOs below.
+
+- [] Create a kernel logging abstraction similar to Linux. (this should probably just use the serial drivers)
+
+The rationale behind this is that we want some sort of debug log/tracing support so we aren't just printf debugging forever.
+
+## Authors
+
+Again, write your name below if you like:
+
+* @zxq5 (wrote most of the libraries as of 23/02/25)
+* @nullndvoid (made this lushious library crate)

libk/src/drivers/async_io/mod.rs

@@ -0,0 +1 @@
+pub mod task;

libk/src/drivers/async_io/task.rs

@@ -0,0 +1,147 @@
+//! Allows creation of asynchronous IO bound tasks.
+//!
+//! Written by @zxq5 for the most part with code from
+//! [here](https://github.com/phil-opp/blog_os/).
+//!
+use crate::prelude::*;
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::task::Wake;
+use core::{
+    future::Future,
+    pin::Pin,
+    sync::atomic::AtomicU64,
+    task::{Context, Poll, Waker},
+};
+use crossbeam::queue::ArrayQueue;
+use x86_64::instructions::interrupts::{self, enable_and_hlt};
+
+pub struct Task {
+    id: TaskId,
+    future: Pin<Box<dyn Future<Output = ()>>>,
+}
+
+impl Task {
+    pub fn new(future: impl Future<Output = ()> + 'static) -> Self {
+        Self {
+            id: TaskId::new(),
+            future: Box::pin(future),
+        }
+    }
+
+    fn poll(&mut self, context: &mut Context) -> Poll<()> {
+        self.future.as_mut().poll(context)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct TaskId(u64);
+
+impl TaskId {
+    fn new() -> Self {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        Self(NEXT.fetch_add(1, core::sync::atomic::Ordering::Relaxed))
+    }
+}
+
+pub struct Executor {
+    tasks: BTreeMap<TaskId, Task>,
+    task_queue: Arc<ArrayQueue<TaskId>>,
+    waker_cache: BTreeMap<TaskId, Waker>,
+}
+
+impl Executor {
+    pub fn new() -> Self {
+        Self {
+            tasks: BTreeMap::new(),
+            task_queue: Arc::new(ArrayQueue::new(100)),
+            waker_cache: BTreeMap::new(),
+        }
+    }
+
+    pub fn spawn(&mut self, task: Task) {
+        let task_id = task.id;
+        if self.tasks.insert(task.id, task).is_some() {
+            panic!("task with same id already in tasks");
+        }
+        self.task_queue.push(task_id).expect("queue full");
+    }
+
+    fn run_ready_tasks(&mut self) {
+        // destructure `self` to avoid borrow checker errors
+        let Self {
+            tasks,
+            task_queue,
+            waker_cache,
+        } = self;
+
+        while let Some(task_id) = task_queue.pop() {
+            let task = match tasks.get_mut(&task_id) {
+                Some(task) => task,
+                None => continue, // task no longer exists
+            };
+            let waker = waker_cache
+                .entry(task_id)
+                .or_insert_with(|| TaskWaker::new_waker(task_id, task_queue.clone()));
+            let mut context = Context::from_waker(waker);
+            match task.poll(&mut context) {
+                Poll::Ready(()) => {
+                    // task done -> remove it and its cached waker
+                    tasks.remove(&task_id);
+                    waker_cache.remove(&task_id);
+                }
+                Poll::Pending => {}
+            }
+        }
+    }
+
+    pub fn run(&mut self) -> ! {
+        loop {
+            self.run_ready_tasks();
+            self.sleep_if_idle();
+        }
+    }
+
+    fn sleep_if_idle(&self) {
+        interrupts::disable();
+        if self.task_queue.is_empty() {
+            enable_and_hlt();
+        } else {
+            interrupts::enable();
+        }
+    }
+}
+
+impl Default for Executor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+struct TaskWaker {
+    task_id: TaskId,
+    task_queue: Arc<ArrayQueue<TaskId>>,
+}
+
+impl TaskWaker {
+    fn wake_task(&self) {
+        self.task_queue.push(self.task_id).expect("task_queue full");
+    }
+
+    fn new_waker(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
+        Waker::from(Arc::new(Self {
+            task_id,
+            task_queue,
+        }))
+    }
+}
+
+impl Wake for TaskWaker {
+    fn wake(self: Arc<Self>) {
+        self.wake_task();
+    }
+
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.wake_task();
+    }
+}

libk/src/drivers/io/ascii/mod.rs

@@ -1,11 +1,10 @@
-//! Formerly called ascii.rs, this file defines helper functions for drawing
-//! characters to the screen.
-
 use core::fmt;
 use spin::{Lazy, Mutex};
 use x86_64::instructions::interrupts;
 
-use super::{colour::Colour, font::Font, framebuffer::FRAMEBUFFER_WRITER};
+use super::framebuffer::{colour::Colour, display::FRAMEBUFFER_WRITER};
+
+use crate::resources::font::{FONT_SPLEEN_8X16, Font};
 
 static FONT_WIDTH: u32 = 8;
 static FONT_HEIGHT: u32 = 16;
@@ -45,7 +44,7 @@ impl Writer {
                 panic!("Framebuffer writer not initialized.");
             },
             |writer| Self {
-                font: &crate::DEFAULT_FONT,
+                font: &FONT_SPLEEN_8X16,
                 screen_width: writer.width() / 8,
                 screen_height: writer.height() / 16,
                 text_line: 0,
@@ -72,8 +71,7 @@ impl Writer {
             return;
         }
 
-        // Get the character data from the font array. -- each byte is a row of
+        // Get the character data from the font array. -- each byte is a row of pixels
-        // pixels
         let data: &[u8] = self.font.glyph_for(c as u16);
 
         if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
@@ -84,18 +82,10 @@ impl Writer {
 
                     if line & (0x80 >> col) != 0 {
                         // Write the foreground color
-                        writer.write_pixel(
+                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.fg_color);
-                            pixel_x as usize,
-                            pixel_y as usize,
-                            self.fg_color,
-                        );
                     } else {
                         // Write the background color
-                        writer.write_pixel(
+                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.bg_color);
-                            pixel_x as usize,
-                            pixel_y as usize,
-                            self.bg_color,
-                        );
                     }
                 }
             }
@@ -127,8 +117,8 @@ impl Writer {
         }
     }
 
-    /// Handles the backspace character. TODO: Implement VT-100 style terminal
+    /// Handles the backspace character. TODO: Implement VT-100 style terminal control
-    /// control codes alongside a shell. Not simple.
+    /// codes alongside a shell. Not simple.
     pub fn backspace(&mut self) {
         if self.text_col > 0 {
             self.text_col -= 1;
@@ -173,21 +163,18 @@ fn write(args: fmt::Arguments, fg: Colour, bg: Colour) {
     });
 }
 
-#[doc(hidden)]
 pub fn _print(args: fmt::Arguments) {
     x86_64::instructions::interrupts::without_interrupts(|| {
         write(args, Colour::White, Colour::Black);
     })
 }
 
-#[doc(hidden)]
 pub fn _print_err(args: fmt::Arguments) {
     x86_64::instructions::interrupts::without_interrupts(|| {
         write(args, Colour::Red, Colour::Black);
     })
 }
 
-#[doc(hidden)]
 pub fn _print_log(args: fmt::Arguments) {
     x86_64::instructions::interrupts::without_interrupts(|| {
         write(args, Colour::Yellow, Colour::Black);
@@ -222,7 +209,7 @@ macro_rules! println_log {
 
 #[macro_export]
 macro_rules! print_log {
-    ($($arg:tt)*) => ($crate::graphics::writer::_print_log(format_args!($($arg)*)));
+	($($arg:tt)*) => ($crate::_print_log(format_args!($($arg)*)));
 }
 
 #[macro_export]
@@ -233,7 +220,7 @@ macro_rules! println {
 
 #[macro_export]
 macro_rules! print {
-    ($($arg:tt)*) => ($crate::graphics::writer::_print(format_args!($($arg)*)));
+	($($arg:tt)*) => ($crate::_print(format_args!($($arg)*)));
 }
 
 #[macro_export]
@@ -244,5 +231,5 @@ macro_rules! printlnerr {
 
 #[macro_export]
 macro_rules! printerr {
-    ($($arg:tt)*) => ($crate::graphics::writer::_print_err(format_args!($($arg)*)));
+    ($($arg:tt)*) => ($crate::_print_err(format_args!($($arg)*)));
 }

libk/src/drivers/io/framebuffer/colour.rs

@@ -1,11 +1,8 @@
 #[repr(u32)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-// Some predefined colours as well as custom colours in the proper format. This
-// assumes that the framebuffer uses 32bpp, something which we will assert on
-// initialisation.
 pub enum Colour {
-    Argb(u8, u8, u8, u8),
+    ARGB(u8, u8, u8, u8),
-    Rgb(u8, u8, u8),
+    RGB(u8, u8, u8),
     HexARGB(u32),
     Black = 0x000000FF,
     Blue = 0x0000FFFF,
@@ -17,19 +14,14 @@ pub enum Colour {
     White = 0xFFFFFFFF,
 }
 
-#[expect(
+#[allow(clippy::use_self)]
-    clippy::use_self,
-    reason = "Self is uglier and more verbose than `u32`"
-)]
 impl From<Colour> for u32 {
     fn from(val: Colour) -> Self {
         match val {
-            Colour::Argb(a, r, g, b) => {
+            Colour::ARGB(a, r, g, b) => {
                 (a as u32) << 24 | (r as u32) << 16 | (g as u32) << 8 | (b as u32)
             }
-            Colour::Rgb(r, g, b) => {
+            Colour::RGB(r, g, b) => ((r as u32) << 16) | (g as u32) << 8 | (b as u32),
-                ((r as u32) << 16) | (g as u32) << 8 | (b as u32)
-            }
             Colour::HexARGB(hex) => hex,
             Colour::Black => 0xFF000000,
             Colour::Blue => 0xFF0000FF,
@@ -46,10 +38,8 @@ impl From<Colour> for u32 {
 impl core::fmt::Display for Colour {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::Argb(r, g, b, a) => {
+            Self::ARGB(r, g, b, a) => write!(f, "RGBA(#{:x}{:x}{:x}{:x})", r, g, b, a),
-                write!(f, "RGBA(#{:x}{:x}{:x}{:x})", r, g, b, a)
+            Self::RGB(r, g, b) => write!(f, "RGB(#{:x}{:x}{:x})", r, g, b),
-            }
-            Self::Rgb(r, g, b) => write!(f, "RGB(#{:x}{:x}{:x})", r, g, b),
             Self::HexARGB(hex) => write!(f, "Hex(#{:x})", hex),
             Self::Black => write!(f, "Black"),
             Self::Blue => write!(f, "Blue"),

libk/src/drivers/io/framebuffer/display.rs

@@ -0,0 +1,104 @@
+use limine::request::FramebufferRequest;
+
+#[used]
+#[unsafe(link_section = ".requests")]
+static FRAMEBUFFER_REQUEST: FramebufferRequest = FramebufferRequest::new();
+
+use super::colour::Colour;
+use core::panic;
+
+use limine::framebuffer::Framebuffer;
+use spin::{Lazy, Mutex};
+
+pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::new(|| {
+    Mutex::new(FRAMEBUFFER_REQUEST.get_response().map_or_else(
+        || {
+            panic!("Framebuffer request failed");
+        },
+        |framebuffer_response| {
+            let framebuffer = framebuffer_response.framebuffers().next().unwrap();
+            Some(FramebufferWriter::new(framebuffer))
+        },
+    ))
+});
+
+/// The updated writer stores necessary fields from the [Framebuffer].
+/// This ensures that the contained types are Send, as Framebuffer was
+/// not marked as Send.
+///
+/// It also avoids the requirement for lifetimes.
+///
+/// Note this does not implement Writer as these functions only handle drawing pixels.
+pub struct FramebufferWriter {
+    pitch: u64,
+    bpp: u16,
+    addr: *mut u8,
+    width: u64,
+    height: u64,
+}
+
+unsafe impl Send for FramebufferWriter {}
+unsafe impl Sync for FramebufferWriter {}
+
+impl FramebufferWriter {
+    pub fn new(framebuffer: Framebuffer) -> Self {
+        Self {
+            pitch: framebuffer.pitch(),
+            bpp: framebuffer.bpp(),
+            addr: framebuffer.addr(),
+            width: framebuffer.width(),
+            height: framebuffer.height(),
+        }
+    }
+
+    pub fn write_pixel(&self, x: usize, y: usize, color: Colour) {
+        let pitch = self.pitch as usize;
+        let bpp = (self.bpp / 8) as usize;
+        let pixel_offset = y * pitch + x * bpp;
+
+        unsafe {
+            *(self.addr.add(pixel_offset) as *mut u32) = color.into();
+        }
+    }
+
+    pub fn render_frame(&self, buffer: &[&[Colour]]) {
+        // TODO: this should return errors
+        for (y, &row) in buffer.iter().enumerate() {
+            if y >= self.height() as usize {
+                break;
+            }
+            for (x, pixel) in row.iter().enumerate() {
+                if x >= self.width() as usize {
+                    break;
+                }
+                self.write_pixel(x, y, *pixel);
+            }
+        }
+    }
+
+    pub const fn width(&self) -> u32 {
+        self.width as u32
+    }
+
+    pub const fn height(&self) -> u32 {
+        self.height as u32
+    }
+
+    pub fn clear(&self) {
+        let width = self.width as usize;
+        let height = self.height as usize;
+
+        for y in 0..height {
+            for x in 0..width {
+                self.write_pixel(x, y, Colour::Black);
+            }
+        }
+    }
+}
+
+pub fn screensize_px() -> (u32, u32) {
+    FRAMEBUFFER_WRITER
+        .lock()
+        .as_mut()
+        .map_or_else(|| (0, 0), |writer| (writer.width(), writer.height()))
+}

libk/src/drivers/io/framebuffer/mod.rs

@@ -0,0 +1,2 @@
+pub mod colour;
+pub mod display;

libk/src/drivers/io/keyboard.rs

@@ -11,31 +11,31 @@ use pc_keyboard::{
 };
 use spin::{Lazy, Mutex, Once};
 
+use crate::prelude::*;
+
 static KBD_QUEUE: Once<ArrayQueue<u8>> = Once::new();
 static WAKER: AtomicWaker = AtomicWaker::new();
 
-pub static KEYBOARD: Lazy<Mutex<Keyboard<Uk105Key, ScancodeSet1>>> =
+pub static KEYBOARD: Lazy<Mutex<Keyboard<Uk105Key, ScancodeSet1>>> = Lazy::new(|| {
-    Lazy::new(|| {
     Mutex::new(Keyboard::new(
         ScancodeSet1::new(),
         // TODO: Expose an API to change the default KB layout.
         layouts::Uk105Key,
         HandleControl::Ignore,
     ))
-    });
+});
 pub static SCANCODE_STREAM: Lazy<Mutex<ScancodeStream>> =
     Lazy::new(|| Mutex::new(ScancodeStream::new()));
 
 pub fn add_scancode(scancode: u8) {
     if let Some(queue) = KBD_QUEUE.get() {
         if queue.push(scancode).is_err() {
-            // println!("WARNING: scancode queue full; dropping keyboard
+            println!("WARNING: scancode queue full; dropping keyboard input");
-            // input");
         } else {
             WAKER.wake();
         }
     } else {
-        // println!("WARNING: scancode queue not initialized");
+        println!("WARNING: scancode queue not initialized");
     }
 }
 
@@ -63,10 +63,7 @@ impl Default for ScancodeStream {
 impl Stream for ScancodeStream {
     type Item = u8;
 
-    fn poll_next(
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         let queue = KBD_QUEUE.get().unwrap();
 
         if let Some(scancode) = queue.pop() {

libk/src/drivers/io/mod.rs

@@ -0,0 +1,17 @@
+pub mod ascii;
+pub mod framebuffer;
+pub mod keyboard;
+pub mod port;
+pub mod serial;
+
+// Re-exported macro definitions.
+
+pub use crate::print;
+pub use crate::print_log;
+pub use crate::printerr;
+pub use crate::println;
+pub use crate::println_log;
+pub use crate::printlnerr;
+
+pub use crate::serial_print;
+pub use crate::serial_println;

libk/src/drivers/io/port.rs

@@ -1,13 +1,9 @@
 //! Functions for IO using ports.
+
 use core::arch::asm;
 
-/// Take a byte in from a port.
+#[inline]
-///
+pub fn inb(port: u16) -> u8 {
-/// # Safety
-///
-/// This might have side effects so it is marked unsafe just in case.
-#[inline(always)]
-pub unsafe fn inb(port: u16) -> u8 {
     let value: u8;
     unsafe {
         asm!(
@@ -20,13 +16,8 @@ pub unsafe fn inb(port: u16) -> u8 {
     value
 }
 
-/// Take a byte in from a port.
+#[inline]
-///
+pub fn outb(port: u16, value: u8) {
-/// # Safety
-///
-/// This might have side effects so it is marked unsafe just in case.
-#[inline(always)]
-pub unsafe fn outb(port: u16, value: u8) {
     unsafe {
         asm!(
             "out dx, al",

libk/src/drivers/io/serial.rs

@@ -1,14 +1,12 @@
-use crate::arch::x86_64::cpu::port::{inb, outb};
 use core::{
     fmt,
     sync::atomic::{AtomicUsize, Ordering},
 };
 use spin::{Lazy, Mutex};
-use x86_64::instructions::interrupts;
 
 #[macro_export]
 macro_rules! serial_print {
-    ($($arg:tt)*) => ($crate::arch::x86_64::dev::serial::_serial_write(format_args!($($arg)*)));
+    ($($arg:tt)*) => ($crate::_serial_write(format_args!($($arg)*)));
 }
 
 #[macro_export]
@@ -17,6 +15,10 @@ macro_rules! serial_println {
     ($($arg:tt)*) => (serial_print!("{}\n", format_args!($($arg)*)));
 }
 
+use super::port::{inb, outb};
+
+use x86_64::instructions::interrupts;
+
 pub fn _serial_write(args: fmt::Arguments) {
     use core::fmt::Write;
 
@@ -75,7 +77,7 @@ impl fmt::Write for Writer {
 
 impl Writer {
     unsafe fn write_success(&self) -> bool {
-        unsafe { inb(PORT + 5) & 0x20 != 0 }
+        inb(PORT + 5) & 0x20 != 0
     }
 
     pub fn write_byte(&self, data: u8) {
@@ -101,21 +103,21 @@ pub fn init() -> Result<(), &'static str> {
 }
 
 pub fn test() -> Result<(), &'static str> {
-    unsafe { outb(PORT + 1, 0x00) }; // Disable all interrupts
+    outb(PORT + 1, 0x00); // Disable all interrupts
-    unsafe { outb(PORT + 3, 0x80) }; // Enable DLAB (set baud rate divisor)
+    outb(PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
-    unsafe { outb(PORT, 0x03) }; // Set divisor to 3 (lo byte) 38400 baud
+    outb(PORT, 0x03); // Set divisor to 3 (lo byte) 38400 baud
-    unsafe { outb(PORT + 1, 0x00) }; //                  (hi byte)
+    outb(PORT + 1, 0x00); //                  (hi byte)
-    unsafe { outb(PORT + 3, 0x03) }; // 8 bits, no parity, one stop bit
+    outb(PORT + 3, 0x03); // 8 bits, no parity, one stop bit
-    unsafe { outb(PORT + 2, 0xC7) }; // Enable FIFO, clear them, with 14-bytethreshold
+    outb(PORT + 2, 0xC7); // Enable FIFO, clear them, with 14-bytethreshold
-    unsafe { outb(PORT + 4, 0x0B) }; // IRQs enabled, RTS/DSR set
+    outb(PORT + 4, 0x0B); // IRQs enabled, RTS/DSR set
-    unsafe { outb(PORT + 4, 0x1E) }; // Set in loopback mode, test the serial chip
+    outb(PORT + 4, 0x1E); // Set in loopback mode, test the serial chip
-    unsafe { outb(PORT, 0xAE) }; // Test serial chip (send byte 0xAE and check if serial returns same byte)
+    outb(PORT, 0xAE); // Test serial chip (send byte 0xAE and check if serial returns same byte)
 
-    if unsafe { inb(PORT) } != 0xAE {
+    if inb(PORT) != 0xAE {
-        return Err("Serial test failed");
+        return Err("serial test failed");
     }
 
-    unsafe { outb(PORT + 4, 0x0F) };
+    outb(PORT + 4, 0x0F);
 
     Ok(())
 }
@@ -141,7 +143,7 @@ impl Reader {
     }
 
     unsafe fn read_ready(&self) -> bool {
-        unsafe { inb(PORT + 5) & 1 != 0 }
+        inb(PORT + 5) & 1 != 0
     }
 
     pub fn read(&self) -> u8 {

libk/src/drivers/kalloc/allocator.rs

@@ -0,0 +1,42 @@
+use linked_list_allocator::LockedHeap;
+use spin::{Mutex, MutexGuard};
+use x86_64::structures::paging::{
+    mapper::MapToError,
+    Size4KiB,
+};
+use crate::drivers::kalloc::foundry_kalloc::FoundryAllocator;
+
+/// We are currently using a linked list heap allocator which uses our underlying page allocator.
+#[global_allocator]
+/// This is now Rust's global allocator, so we can use stuff requiring heap allocations.
+static ALLOCATOR: Locked<FoundryAllocator> = Locked::new(FoundryAllocator::new());
+
+pub const HEAP_START: usize = 0x4444_4444_0000;
+pub const HEAP_SIZE: usize = 1024 * 1024 * 1024;
+
+/// Sets up the heap using the backing page frame allocator.
+pub fn init_heap() -> Result<(), MapToError<Size4KiB>> {
+    // code to allocate frames is now done in the page fault interrupt handler!
+
+    unsafe {
+        ALLOCATOR.lock().init(HEAP_START, HEAP_SIZE);
+    }
+
+    Ok(())
+}
+
+pub struct Locked<T> {
+    inner: Mutex<T>,
+}
+
+impl<T> Locked<T> {
+    pub const fn new(inner: T) -> Self {
+        Locked {
+            inner: Mutex::new(inner)
+        }
+    }
+
+    pub fn lock(&self) -> MutexGuard<T> {
+        self.inner.lock()
+    }
+}

libk/src/drivers/kalloc/foundry_kalloc.rs

@@ -0,0 +1,231 @@
+use alloc::collections::LinkedList;
+use core::alloc::{GlobalAlloc, Layout};
+use core::{mem, ptr};
+use core::ptr::NonNull;
+use crate::drivers::kalloc::allocator::Locked;
+const BLOCK_SIZES: &[usize] = &[8, 16, 32, 64, 128, 256, 512, 1024, 2048];
+
+struct ListNode {
+    next: Option<&'static mut ListNode>,
+}
+
+pub struct FoundryAllocator {
+    list_heads: [Option<&'static mut ListNode>; BLOCK_SIZES.len()],
+    fallback: Locked<FoundryFallbackAllocator>,
+}
+
+impl Default for FoundryAllocator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl FoundryAllocator {
+    pub const fn new() -> Self {
+        const EMPTY: Option<&'static mut ListNode> = None;
+        Self {
+            list_heads: [EMPTY; BLOCK_SIZES.len()],
+            fallback: Locked::new(FoundryFallbackAllocator::new()),
+        }
+    }
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) { unsafe {
+        self.fallback.lock().init(heap_start, heap_size);
+    }}
+
+    unsafe fn fallback_alloc(&mut self, layout: Layout) -> *mut u8 { unsafe {
+        self.fallback.alloc(layout)
+    }}
+
+    fn block_size(&self, layout: &Layout) -> Option<usize> {
+        let required_block_size = layout.size().max(layout.align());
+        BLOCK_SIZES.iter().position(|&s| s >= required_block_size)
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<FoundryAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut allocator = self.lock();
+
+        match allocator.block_size(&layout) {
+            Some(index) => {
+                match allocator.list_heads[index].take() {
+                    Some(node) => {
+                        allocator.list_heads[index] = node.next.take();
+                        node as *mut ListNode as *mut u8
+                    }
+                    None => {
+                        // no block exists in list => allocate new block
+                        let block_size = BLOCK_SIZES[index];
+                        // only works if all block sizes are a power of 2
+                        let block_align = block_size;
+                        let layout = Layout::from_size_align(block_size, block_align)
+                            .unwrap();
+                        unsafe { allocator.fallback_alloc(layout) }
+                    }
+                }
+            }
+            None => unsafe { allocator.fallback_alloc(layout) },
+        }
+    }
+
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let mut allocator = self.lock();
+        match allocator.block_size(&layout) {
+            Some(idx) => {
+                let new_node = ListNode {
+                    next: allocator.list_heads[idx].take(),
+                };
+
+                let new_ptr = ptr as *mut ListNode;
+                unsafe { new_ptr.write(new_node) };
+                allocator.list_heads[idx] = Some( unsafe { &mut *new_ptr });
+            }
+            None => {;
+                unsafe { allocator.fallback.dealloc(ptr, layout) };
+            }
+        }
+    }
+}
+
+struct FallbackListNode {
+    size: usize,
+    next: Option<&'static mut FallbackListNode>,
+}
+
+impl FallbackListNode {
+    const fn new(size: usize) -> Self {
+        Self {
+            size,
+            next: None,
+        }
+    }
+
+    fn start_addr(&self) -> usize {
+        self as *const Self as usize
+    }
+
+    fn end_addr(&self) -> usize {
+        self.start_addr() + self.size
+    }
+}
+
+pub struct FoundryFallbackAllocator {
+    head: FallbackListNode,
+}
+
+impl FoundryFallbackAllocator {
+    pub const fn new() -> Self {
+        Self {
+            head: FallbackListNode::new(0),
+        }
+    }
+
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        unsafe { self.add_region(heap_start, heap_size) };
+    }
+
+    unsafe fn add_region(&mut self, addr: usize, size: usize) { unsafe {
+        let mut node = FallbackListNode::new(size);
+        node.next = self.head.next.take();
+        let node_ptr = addr as *mut FallbackListNode;
+        node_ptr.write(node);
+        self.head.next = Some(&mut *node_ptr);
+    }}
+
+    fn find_region(&mut self, size: usize, align: usize) -> Option<(&'static mut FallbackListNode, usize)> {
+        let mut current = &mut self.head;
+        // look for a large enough memory region in linked list
+        while let Some(ref mut region) = current.next {
+            if let Ok(alloc_start) = Self::alloc_from_region(&region, size, align) {
+                // region suitable for allocation -> remove node from list
+                let next = region.next.take();
+                let ret = Some((current.next.take().unwrap(), alloc_start));
+                current.next = next;
+                return ret;
+            } else {
+                // region not suitable -> continue with next region
+                current = current.next.as_mut().unwrap();
+            }
+        }
+        None
+    }
+    const fn align_up(addr: usize, align: usize) -> usize {
+        (addr + align - 1) & !(align - 1)
+    }
+
+    fn size_align(layout: Layout) -> (usize, usize) {
+        let layout = layout
+            .align_to(align_of::<ListNode>())
+            .expect("adjusting alignment failed")
+            .pad_to_align();
+        let size = layout.size().max(size_of::<ListNode>());
+        (size, layout.align())
+    }
+
+    fn alloc_from_region(region: &FallbackListNode, size: usize, align: usize) -> Result<usize, ()>
+    {
+        let alloc_start = Self::align_up(region.start_addr(), align);
+        let alloc_end = alloc_start.checked_add(size).ok_or(())?;
+
+        if alloc_end > region.end_addr() {
+            return Err(());
+        }
+
+        let excess_size = region.end_addr() - alloc_end;
+        if excess_size > 0 && excess_size < size_of::<ListNode>() {
+            return Err(());
+        }
+
+        Ok(alloc_start)
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<FoundryFallbackAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut allocator = self.lock();
+        // perform layout adjustments
+        let (size, align) = FoundryFallbackAllocator::size_align(layout);
+
+        if let Some((region, alloc_start)) = allocator.find_region(size, align) {
+            let alloc_end = alloc_start.checked_add(size).expect("overflow");
+            let excess_size = region.end_addr() - alloc_end;
+            if excess_size > 0 {
+                unsafe { allocator.add_region(alloc_end, excess_size) };
+            }
+            alloc_start as *mut u8
+        } else {
+            ptr::null_mut()
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let mut allocator = self.lock();
+
+        // perform layout adjustments
+        let (size, _) = FoundryFallbackAllocator::size_align(layout);
+
+        unsafe {
+            allocator.add_region(ptr as usize, size)
+        }
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

libk/src/drivers/kalloc/mod.rs

@@ -0,0 +1,2 @@
+pub mod allocator;
+mod foundry_kalloc;

libk/src/drivers/memory.rs

@@ -0,0 +1,149 @@
+// use lib_alloc::allocator::FoundryAllocator;
+use limine::{memory_map::EntryType, response::MemoryMapResponse};
+use spin::{Mutex, Once};
+use x86_64::{
+    registers::control::Cr3, structures::paging::{
+        FrameAllocator, OffsetPageTable, PageTable, PhysFrame, Size4KiB
+        ,
+    },
+    PhysAddr,
+    VirtAddr,
+};
+
+pub static FRAME_ALLOCATOR: Once<Mutex<FoundryOSFrameAllocator>> = Once::new();
+pub static OFFSET_PAGE_TABLE: Once<Mutex<OffsetPageTable>> = Once::new();
+/// Returns a mutable reference to the current level 4 page table.
+///
+/// # Safety
+///
+/// The caller must ensure that the level 4 page table is not modified
+/// simultaneously. The caller must also ensure that the physical memory offset
+/// is correct, to ensure that the correct virtual address is constructed.
+unsafe fn active_l4_table(physical_memory_offset: VirtAddr) -> &'static mut PageTable {
+    let (level_4_frame, _) = Cr3::read();
+
+    let phys_addr = level_4_frame.start_address();
+    let virt = phys_addr.as_u64() + physical_memory_offset.as_u64();
+    unsafe { &mut *(virt as *mut PageTable) }
+}
+
+/// Initializes the `OffsetPageTable` for the current CPU architecture.
+///
+/// # Safety
+///
+/// This function must be called only once and should be called before any
+/// memory operations are performed that rely on virtual memory management.
+/// The provided `physical_memory_offset` must be accurate to ensure correct
+/// translation of physical addresses.
+///
+/// # Parameters
+///
+/// - `physical_memory_offset`: The offset to convert physical addresses to
+///   virtual addresses in the higher-half direct map.
+///
+/// # Returns
+///
+/// Returns an `OffsetPageTable` that allows for manipulation of the page
+/// tables for the current CPU architecture.
+pub fn init_page_table(physical_memory_offset: VirtAddr) {
+    unsafe {
+        let l4_table = active_l4_table(physical_memory_offset);
+        let offset_table = OffsetPageTable::new(l4_table, physical_memory_offset);
+        OFFSET_PAGE_TABLE.call_once(|| Mutex::new(offset_table));
+    }
+}
+
+pub struct FoundryOSFrameAllocator {
+    memory_map: &'static MemoryMapResponse,
+    next: usize,
+}
+
+pub fn init_frame_allocator(memory_map: &'static MemoryMapResponse) {
+    unsafe {
+        FRAME_ALLOCATOR.call_once(|| Mutex::new(FoundryOSFrameAllocator::init(memory_map)));
+    }
+}
+
+impl FoundryOSFrameAllocator {
+    /// Creates a new `FoundryOSFrameAllocator` from a memory map.
+    ///
+    /// This function takes a reference to a `MemoryMapResponse` and initializes a
+    /// `FoundryOSFrameAllocator` with it. The `next` field is set to 0, indicating that
+    /// the first frame to be allocated is the first frame in the memory map.
+    pub const unsafe fn init(memory_map: &'static MemoryMapResponse) -> Self {
+        Self {
+            memory_map,
+            next: 0,
+        }
+    }
+
+    pub fn count_usable_frames(&self) -> u32 {
+        self.usable_frames().count() as u32
+    }
+
+    /// An iterator over all usable frames in the memory map.
+    ///
+    /// Yields one `PhysFrame` for each available 4KiB frame in the memory map.
+    ///
+    /// This function is used to allocate frames for the pagemap.
+    fn usable_frames(&self) -> impl Iterator<Item = PhysFrame> + use<> {
+        let regions = self.memory_map.entries().iter();
+        let usable_regions = regions.filter(|region| region.entry_type == EntryType::USABLE);
+
+        let addr_ranges = usable_regions.map(|region| region.base..region.base + region.length);
+
+        let frame_addresses = addr_ranges.flat_map(|r| r.step_by(4096));
+
+        frame_addresses.map(|addr| PhysFrame::from_start_address(PhysAddr::new(addr)).unwrap())
+    }
+}
+
+unsafe impl FrameAllocator<Size4KiB> for FoundryOSFrameAllocator {
+    /// Allocates a frame from the list of usable frames.
+    ///
+    /// This function returns the next available `PhysFrame` from the memory map,
+    /// if one exists. Once a frame is allocated, the internal counter is incremented
+    /// to point to the next frame for future allocations.
+    ///
+    /// # Returns
+    ///
+    /// - `Some(PhysFrame)`: If a usable frame is available.
+    /// - `None`: If there are no more usable frames to allocate.
+    fn allocate_frame(&mut self) -> Option<PhysFrame> {
+        let frame = self.usable_frames().nth(self.next);
+        self.next += 1;
+        frame
+    }
+}
+
+// pub unsafe fn translate_addr(addr: VirtAddr, physical_memory_offset: VirtAddr) -> Option<PhysAddr> {
+//     translate_addr_inner(addr, physical_memory_offset)
+// }
+
+// fn translate_addr_inner(addr: VirtAddr, physical_memory_offset: VirtAddr) -> Option<PhysAddr> {
+//     let (l4_table_frame, _) = Cr3::read();
+
+//     let table_indexes = [
+//         addr.p4_index(),
+//         addr.p3_index(),
+//         addr.p2_index(),
+//         addr.p1_index(),
+//     ];
+//     let mut frame = l4_table_frame;
+
+//     for &i in &table_indexes {
+//         let virt = physical_memory_offset + frame.start_address().as_u64();
+//         let table_ptr: *const PageTable = virt.as_ptr();
+//         let table = unsafe { &*table_ptr };
+
+//         let entry = &table[i];
+
+//         frame = match entry.frame() {
+//             Ok(frame) => frame,
+//             Err(FrameError::FrameNotPresent) => return None,
+//             Err(FrameError::HugeFrame) => panic!("huge frames are not supported!"),
+//         };
+//     }
+
+//     Some(frame.start_address() + u64::from(addr.page_offset()))
+// }

libk/src/drivers/mod.rs

@@ -0,0 +1,6 @@
+pub mod io;
+pub mod kalloc;
+
+pub mod async_io;
+pub mod memory;
+pub mod pic;

libk/src/drivers/pic.rs

@@ -1,4 +1,3 @@
-#![allow(clippy::missing_safety_doc)]
 use x86_64::instructions::port::Port;
 
 const CMD_INIT: u8 = 0x11;
@@ -41,9 +40,8 @@ pub struct ChainedPics {
 }
 
 impl ChainedPics {
-    /// Creates a new [`ChainedPics`].
+    pub const unsafe fn new(offset1: u8, offset2: u8) -> Self {
-    pub const fn new(offset1: u8, offset2: u8) -> Self {
+        ChainedPics {
-        Self {
             pics: [
                 Pic {
                     offset: offset1,
@@ -59,8 +57,13 @@ impl ChainedPics {
         }
     }
 
-    pub const fn new_contiguous(primary_offset: u8) -> Self {
+    /// .
-        Self::new(primary_offset, primary_offset + 8)
+    ///
+    /// # Safety
+    ///
+    /// .
+    pub const unsafe fn new_contiguous(primary_offset: u8) -> Self {
+        unsafe { Self::new(primary_offset, primary_offset + 8) }
     }
 
     /// Returns the initialize of this [`ChainedPics`].

libk/src/lib.rs

@@ -0,0 +1,38 @@
+#![no_std]
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc,
+    tail_expr_drop_order
+)]
+
+extern crate alloc;
+
+pub mod drivers;
+pub mod resources;
+pub mod threads;
+pub mod util;
+
+#[allow(unused)] // We aren't using much of this right now.
+pub mod std;
+
+/// Re-exports most of the IO macros as well as standard allocation stuff
+#[allow(unused)]
+pub mod prelude {
+    pub use crate::std::io::*;
+    pub use alloc::{
+        boxed::Box,
+        string::{String, ToString},
+        vec::Vec,
+    };
+}
+
+pub use crate::drivers::io::{
+    ascii::{_print, _print_log},
+    serial::_serial_write,
+};

libk/src/resources/font/ibm_vga_8x16.rs

@@ -0,0 +1,578 @@
+pub static FONT: [u8; 288 * 16] = [
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 0
+    0x00, 0x00, 0x3f, 0x33, 0x3f, 0x30, 0x30, 0x30, 0x30, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00,
+    0x00, // 1
+    0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0x81, 0xbd, 0x99, 0x81, 0x81, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 2
+    0x00, 0x00, 0x7e, 0xff, 0xdb, 0xff, 0xff, 0xc3, 0xe7, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 3
+    0x00, 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00,
+    0x00, // 4
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 5
+    0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0xe7, 0xe7, 0xe7, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 6
+    0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 7
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 8
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, // 9
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 10
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff,
+    0xff, // 11
+    0x00, 0x00, 0x1e, 0x0e, 0x1a, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,
+    0x00, // 12
+    0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 13
+    0x00, 0x00, 0x7f, 0x63, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x67, 0xe7, 0xe6, 0xc0, 0x00, 0x00,
+    0x00, // 14
+    0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 15
+    0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfe, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00,
+    0x00, // 16
+    0x00, 0x02, 0x06, 0x0e, 0x1e, 0x3e, 0xfe, 0x3e, 0x1e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00,
+    0x00, // 17
+    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 18
+    0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00,
+    0x00, // 19
+    0x00, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00,
+    0x00, // 20
+    0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00,
+    0x00, // 21
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 22
+    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 23
+    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 24
+    0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 25
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 26
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 27
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 28
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x6c, 0xfe, 0x6c, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 29
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 30
+    0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 31
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 32
+    0x00, 0x00, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 33
+    0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 34
+    0x00, 0x00, 0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x00, 0x00, 0x00,
+    0x00, // 35
+    0x18, 0x18, 0x7c, 0xc6, 0xc2, 0xc0, 0x7c, 0x06, 0x06, 0x86, 0xc6, 0x7c, 0x18, 0x18, 0x00,
+    0x00, // 36
+    0x00, 0x00, 0x00, 0x00, 0xc2, 0xc6, 0x0c, 0x18, 0x30, 0x60, 0xc6, 0x86, 0x00, 0x00, 0x00,
+    0x00, // 37
+    0x00, 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x76, 0xdc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 38
+    0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 39
+    0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00,
+    0x00, // 40
+    0x00, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30, 0x00, 0x00, 0x00,
+    0x00, // 41
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 42
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 43
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00,
+    0x00, // 44
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 45
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 46
+    0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00, 0x00, 0x00,
+    0x00, // 47
+    0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xd6, 0xd6, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00,
+    0x00, // 48
+    0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 49
+    0x00, 0x00, 0x7c, 0xc6, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc6, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 50
+    0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 51
+    0x00, 0x00, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, 0xfe, 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x00, 0x00,
+    0x00, // 52
+    0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 53
+    0x00, 0x00, 0x38, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 54
+    0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00,
+    0x00, // 55
+    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 56
+    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c, 0x78, 0x00, 0x00, 0x00,
+    0x00, // 57
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 58
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00,
+    0x00, // 59
+    0x00, 0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x00, 0x00, 0x00,
+    0x00, // 60
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 61
+    0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00,
+    0x00, // 62
+    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x0c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 63
+    0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xde, 0xde, 0xde, 0xdc, 0xc0, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 64
+    0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 65
+    0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x66, 0x66, 0xfc, 0x00, 0x00, 0x00,
+    0x00, // 66
+    0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0, 0xc0, 0xc2, 0x66, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 67
+    0x00, 0x00, 0xf8, 0x6c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6c, 0xf8, 0x00, 0x00, 0x00,
+    0x00, // 68
+    0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 69
+    0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
+    0x00, // 70
+    0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xde, 0xc6, 0xc6, 0x66, 0x3a, 0x00, 0x00, 0x00,
+    0x00, // 71
+    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 72
+    0x00, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 73
+    0x00, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,
+    0x00, // 74
+    0x00, 0x00, 0xe6, 0x66, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00,
+    0x00, // 75
+    0x00, 0x00, 0xf0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 76
+    0x00, 0x00, 0xc6, 0xee, 0xfe, 0xfe, 0xd6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 77
+    0x00, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 78
+    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 79
+    0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
+    0x00, // 80
+    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 0x0c, 0x0e, 0x00,
+    0x00, // 81
+    0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x6c, 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00,
+    0x00, // 82
+    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x60, 0x38, 0x0c, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 83
+    0x00, 0x00, 0x7e, 0x7e, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 84
+    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 85
+    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00,
+    0x00, // 86
+    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xfe, 0xee, 0x6c, 0x00, 0x00, 0x00,
+    0x00, // 87
+    0x00, 0x00, 0xc6, 0xc6, 0x6c, 0x7c, 0x38, 0x38, 0x7c, 0x6c, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 88
+    0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 89
+    0x00, 0x00, 0xfe, 0xc6, 0x86, 0x0c, 0x18, 0x30, 0x60, 0xc2, 0xc6, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 90
+    0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 91
+    0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00,
+    0x00, // 92
+    0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 93
+    0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 94
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+    0x00, // 95
+    0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 96
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 97
+    0x00, 0x00, 0xe0, 0x60, 0x60, 0x78, 0x6c, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 98
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 99
+    0x00, 0x00, 0x1c, 0x0c, 0x0c, 0x3c, 0x6c, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 100
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 101
+    0x00, 0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
+    0x00, // 102
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xcc, 0x78,
+    0x00, // 103
+    0x00, 0x00, 0xe0, 0x60, 0x60, 0x6c, 0x76, 0x66, 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00,
+    0x00, // 104
+    0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 105
+    0x00, 0x00, 0x06, 0x06, 0x00, 0x0e, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3c,
+    0x00, // 106
+    0x00, 0x00, 0xe0, 0x60, 0x60, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0x00, 0x00,
+    0x00, // 107
+    0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 108
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0xfe, 0xd6, 0xd6, 0xd6, 0xd6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 109
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00,
+    0x00, // 110
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 111
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0,
+    0x00, // 112
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0x0c, 0x1e,
+    0x00, // 113
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x76, 0x66, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
+    0x00, // 114
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0x60, 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 115
+    0x00, 0x00, 0x10, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00,
+    0x00, // 116
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 117
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 118
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00, 0x00, 0x00,
+    0x00, // 119
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x6c, 0x38, 0x38, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 120
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0xf8,
+    0x00, // 121
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xcc, 0x18, 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 122
+    0x00, 0x00, 0x0e, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0e, 0x00, 0x00, 0x00,
+    0x00, // 123
+    0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 124
+    0x00, 0x00, 0x70, 0x18, 0x18, 0x18, 0x0e, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00,
+    0x00, // 125
+    0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 126
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 127
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 128
+    0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 129
+    0x00, 0x18, 0x18, 0x3c, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3c, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 130
+    0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xe6, 0xfc, 0x00, 0x00, 0x00,
+    0x00, // 131
+    0x00, 0x00, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 132
+    0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00,
+    0x00, // 133
+    0x00, 0x3c, 0x6c, 0x6c, 0x3e, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 134
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 135
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 136
+    0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 137
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00,
+    0x00, // 138
+    0x00, 0x70, 0xd8, 0x30, 0x60, 0xc8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 139
+    0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xc0, 0x00, 0x00,
+    0x00, // 140
+    0x00, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00,
+    0x00, // 141
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 142
+    0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 143
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36, 0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 144
+    0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, 0x66, 0xce, 0x9e, 0x3e, 0x06, 0x06, 0x00,
+    0x00, // 145
+    0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, 0x60, 0xdc, 0x86, 0x0c, 0x18, 0x3e, 0x00,
+    0x00, // 146
+    0x00, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x60, 0xc0, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 147
+    0x00, 0xc6, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 148
+    0x38, 0x6c, 0x38, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 149
+    0x00, 0x00, 0x3e, 0x6c, 0xcc, 0xcc, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00,
+    0x00, // 150
+    0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0, 0xc2, 0x66, 0x3c, 0x0c, 0x06, 0x7c, 0x00,
+    0x00, // 151
+    0x18, 0x30, 0x60, 0x00, 0xfe, 0x66, 0x60, 0x7c, 0x60, 0x60, 0x66, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 152
+    0x76, 0xdc, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 153
+    0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 154
+    0x00, 0xc6, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 155
+    0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0x00, 0x00, 0x00,
+    0x00, // 156
+    0x00, 0x60, 0x30, 0x18, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 157
+    0x00, 0x18, 0x30, 0x60, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 158
+    0x00, 0x10, 0x38, 0x6c, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 159
+    0x00, 0x00, 0xcc, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 160
+    0x00, 0x38, 0x6c, 0x38, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 161
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0x76, 0x36, 0x7e, 0xd8, 0xd8, 0x6e, 0x00, 0x00, 0x00,
+    0x00, // 162
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x60, 0x60, 0x66, 0x3c, 0x0c, 0x06, 0x3c, 0x00, 0x00,
+    0x00, // 163
+    0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 164
+    0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 165
+    0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 166
+    0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 167
+    0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 168
+    0x00, 0x0c, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 169
+    0x00, 0x18, 0x3c, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 170
+    0x00, 0x00, 0x66, 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 171
+    0x00, 0x00, 0x76, 0xdc, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00,
+    0x00, // 172
+    0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 173
+    0x00, 0x18, 0x30, 0x60, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 174
+    0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 175
+    0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
+    0x00, // 176
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 177
+    0x00, 0x60, 0x30, 0x18, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 178
+    0x00, 0x18, 0x30, 0x60, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 179
+    0x00, 0x30, 0x78, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 180
+    0x00, 0x00, 0xcc, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 181
+    0x00, 0x00, 0xc6, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0x78,
+    0x00, // 182
+    0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0x70, 0x00,
+    0x00, // 183
+    0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00,
+    0x00, // 184
+    0x00, 0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00,
+    0x00, // 185
+    0x00, 0x00, 0x00, 0xfe, 0xc6, 0x60, 0x30, 0x18, 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 186
+    0x00, 0x00, 0x00, 0x7e, 0x18, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 187
+    0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c, 0x6c, 0xee, 0x00, 0x00, 0x00,
+    0x00, // 188
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0xd8, 0xd8, 0xd8, 0xdc, 0x76, 0x00, 0x00, 0x00,
+    0x00, // 189
+    0x00, 0x00, 0x1e, 0x30, 0x18, 0x0c, 0x3e, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 190
+    0x00, 0x00, 0x1c, 0x30, 0x60, 0x60, 0x7c, 0x60, 0x60, 0x60, 0x30, 0x1c, 0x00, 0x00, 0x00,
+    0x00, // 191
+    0x00, 0x00, 0x00, 0x00, 0xfe, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00,
+    0x00, // 192
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00,
+    0x00, // 193
+    0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 194
+    0x00, 0x00, 0x00, 0x03, 0x06, 0x7e, 0xdb, 0xdb, 0xf3, 0x7e, 0x60, 0xc0, 0x00, 0x00, 0x00,
+    0x00, // 195
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 196
+    0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00,
+    0x00, // 197
+    0x00, 0xd8, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 198
+    0x00, 0xf8, 0xcc, 0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0xcc, 0xcc, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 199
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 200
+    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 201
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 202
+    0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 203
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x6c, 0xfe, 0x6c, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 204
+    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 205
+    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 206
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 207
+    0x00, 0x0f, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x6c, 0x3c, 0x1c, 0x00, 0x00, 0x00,
+    0x00, // 208
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xdb, 0xdb, 0xdb, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 209
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 210
+    0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
+    0x00, // 211
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 212
+    0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 213
+    0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 214
+    0x00, 0x00, 0x00, 0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 215
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 216
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 217
+    0x00, 0x00, 0x0e, 0x1b, 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 218
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00,
+    0x00, // 219
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 220
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 221
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 222
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 223
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 224
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 225
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 226
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 227
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 228
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 229
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 230
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 231
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 232
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 233
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 234
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 235
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 236
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 237
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 238
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 239
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 240
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 241
+    0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 242
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 243
+    0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 244
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 245
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 246
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 247
+    0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 248
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 249
+    0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 250
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 251
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 252
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 253
+    0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 254
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 255
+    0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 256
+    0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, // 257
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 258
+    0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+    0x36, // 259
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 260
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, // 261
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, // 262
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+    0xf0, // 263
+    0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+    0x0f, // 264
+    0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11,
+    0x44, // 265
+    0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55,
+    0xaa, // 266
+    0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd,
+    0x77, // 267
+    0x00, 0x00, 0x00, 0x00, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 268
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00,
+    0x00, // 269
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 270
+    0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfe, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00,
+    0x00, // 271
+    0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 272
+    0x00, 0x02, 0x06, 0x0e, 0x1e, 0x3e, 0xfe, 0x3e, 0x1e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00,
+    0x00, // 273
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 274
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, // 275
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff,
+    0xff, // 276
+    0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0x81, 0xbd, 0x99, 0x81, 0x81, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 277
+    0x00, 0x00, 0x7e, 0xff, 0xdb, 0xff, 0xff, 0xc3, 0xe7, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00,
+    0x00, // 278
+    0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 279
+    0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, // 280
+    0x00, 0x00, 0x1e, 0x0e, 0x1a, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,
+    0x00, // 281
+    0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 282
+    0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0xe7, 0xe7, 0xe7, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
+    0x00, // 283
+    0x00, 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00,
+    0x00, // 284
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, // 285
+    0x00, 0x00, 0x3f, 0x33, 0x3f, 0x30, 0x30, 0x30, 0x30, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00,
+    0x00, // 286
+    0x00, 0x00, 0x7f, 0x63, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x67, 0xe7, 0xe6, 0xc0, 0x00, 0x00,
+    0x00, // 287
+];

libk/src/resources/font/mod.rs

@@ -1,11 +1,13 @@
-#![allow(unused)]
 use libm::include_font;
 
-pub const FONT_SPLEEN_8X16: Font =
+pub mod ibm_vga_8x16;
-    Font::new(include_font!("../../resources/font/spleen-8x16.psf"));
 
-pub const FONT_CP850_8X16: Font =
+pub static FONT_SPLEEN_8X16: Font =
-    Font::new(include_font!("../../resources/font/cp850-8x16.psf"));
+    Font::new(include_font!("./libk/resources/font/spleen-8x16.psf"));
+
+pub static FONT_CP850_8X16: Font = Font::new(include_font!("./libk/resources/font/cp850-8x16.psf"));
+
+// pub struct Font(pub [[u8; 16]; 512]);
 
 pub struct Font {
     width: usize,
@@ -15,8 +17,8 @@ pub struct Font {
 }
 
 impl Font {
-    pub const fn new(data: [[u8; 16]; 512]) -> Self {
+    pub const fn new(data: [[u8; 16]; 512]) -> Font {
-        Self {
+        Font {
             width: 8,
             height: 16,
             length: data.len() as u16,
@@ -40,7 +42,7 @@ impl Font {
         self.height
     }
 
-    pub const fn default() -> &'static Self {
+    pub const fn default() -> &'static Font {
-        &FONT_SPLEEN_8X16
+        &FONT_CP850_8X16
     }
 }

libk/src/resources/mod.rs

@@ -0,0 +1 @@
+pub mod font;

libk/src/std/application.rs

@@ -0,0 +1,21 @@
+use crate::prelude::*;
+
+pub mod frame;
+pub mod render;
+pub mod window;
+
+pub trait Application {
+    type Output;
+
+    fn run(
+        &mut self,
+        args: Vec<String>,
+    ) -> impl core::future::Future<Output = Result<Self::Output, Error>> + Send;
+}
+
+#[derive(Debug)]
+pub enum Error {
+    UnknownCommand(String),
+    ApplicationFailed(String),
+    KernelError(String),
+}

libk/src/std/application/frame.rs

@@ -0,0 +1,40 @@
+use crate::{drivers::io::framebuffer::colour::Colour, std::maths::geometry::Vec2};
+
+use super::{
+    render::{ColouredChar, RenderError},
+    window::{self, Window},
+};
+use alloc::{vec, vec::Vec};
+
+pub struct Frame<'f> {
+    data: Vec<Vec<Colour>>,
+    window: &'f Window,
+}
+
+impl<'a> Frame<'a> {
+    pub fn new(window: &'a Window) -> Self {
+        Self {
+            data: vec![vec![Colour::Black; window.dimensions().x()]; window.dimensions().y()],
+            window,
+        }
+    }
+
+    pub fn render(&self) -> Result<(), RenderError> {
+        let data: Vec<&[Colour]> = self.data.iter().map(|v| v.as_slice()).collect::<Vec<_>>();
+        self.window
+            .render(data.as_slice())
+            .map_err(|_| RenderError::Generic)
+    }
+
+    pub fn write_pixel(&mut self, x: usize, y: usize, color: Colour) -> Result<(), RenderError> {
+        if x >= self.window.dimensions().x() || y >= self.window.dimensions().y() {
+            return Err(RenderError::Generic);
+        }
+        self.data[y][x] = color;
+        Ok(())
+    }
+
+    pub const fn dimensions(&self) -> Vec2<usize> {
+        self.window.dimensions()
+    }
+}

libk/src/std/application/render.rs

@@ -0,0 +1,23 @@
+use core::fmt::Display;
+
+use crate::drivers::io::framebuffer::colour::Colour;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RenderError {
+    Generic,
+}
+
+impl Display for RenderError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Generic => write!(f, "Generic render error"),
+        }
+    }
+}
+
+impl core::error::Error for RenderError {}
+
+pub struct ColouredChar {
+    ch: u8,
+    colour: Colour,
+}

libk/src/std/application/window.rs

@@ -0,0 +1,96 @@
+use limine::framebuffer;
+
+use crate::{
+    drivers::io::framebuffer::{colour::Colour, display::FRAMEBUFFER_WRITER},
+    prelude::*,
+    std::maths::geometry::Vec2,
+};
+
+use super::render::RenderError;
+
+pub struct Window {
+    dimensions: Vec2<usize>,
+    position: Vec2<usize>,
+    bordered: bool,
+    opened: bool,
+    title: String,
+}
+
+impl Window {
+    pub const fn new() -> Self {
+        Self {
+            dimensions: Vec2::new(0, 0),
+            position: Vec2::new(0, 0),
+            bordered: true,
+            opened: false,
+            title: String::new(),
+        }
+    }
+
+    pub fn render(&self, _data: &[&[Colour]]) -> Result<(), RenderError> {
+        // TODO: error handling!! the kernel should return an error in some cases
+        if let Some(fb) = FRAMEBUFFER_WRITER.lock().as_mut() {
+            fb.render_frame(_data);
+        }
+        Ok(())
+    }
+
+    pub const fn is_bordered(&self) -> bool {
+        self.bordered
+    }
+
+    pub const fn is_open(&self) -> bool {
+        self.opened
+    }
+
+    pub const fn open(&mut self) {
+        self.opened = true;
+    }
+
+    pub const fn close(&mut self) {
+        self.opened = false;
+    }
+
+    // some basic getters and setters for utility.
+    pub fn title(&'static self) -> &'static str {
+        self.title.as_str()
+    }
+
+    pub const fn dimensions(&self) -> Vec2<usize> {
+        self.dimensions
+    }
+
+    pub const fn position(&self) -> Vec2<usize> {
+        self.position
+    }
+
+    pub fn set_title(&mut self, title: String) {
+        self.title = title;
+    }
+
+    pub fn move_window(&mut self, offset: Vec2<usize>) {
+        self.position += offset;
+    }
+
+    pub const fn set_position(&mut self, position: Vec2<usize>) {
+        self.position = position;
+    }
+
+    pub const fn set_dimensions(&mut self, dimensions: Vec2<usize>) {
+        self.dimensions = dimensions;
+    }
+}
+
+impl Default for Window {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        if self.opened {
+            self.close();
+        }
+    }
+}

libk/src/std/ascii.rs

@@ -0,0 +1,57 @@
+use crate::{drivers::io::framebuffer::colour::Colour, resources::font::Font};
+
+use super::{
+    application::{frame::Frame, render::RenderError},
+    maths::geometry::Vec2,
+};
+
+pub struct Writer<'a> {
+    font: &'a Font,
+}
+
+impl<'a> Writer<'a> {
+    pub const fn new(font: &'a Font) -> Self {
+        Self { font }
+    }
+
+    pub const fn set_font(&mut self, font: &'a Font) {
+        self.font = font;
+    }
+
+    pub const fn font_size(&self) -> Vec2<usize> {
+        Vec2::new(self.font.width(), self.font.height())
+    }
+
+    pub fn render_glyph(
+        &self,
+        frame: &mut Frame,
+        pos: Vec2<usize>,
+        c: u8,
+        scale: usize,
+    ) -> Result<(), RenderError> {
+        // get a reference to the character glyph from the font.
+        let data: &[u8] = self.font.glyph_for(c as u16);
+
+        if pos.x() + self.font.width() * scale > frame.dimensions().x()
+            || pos.y() + self.font.height() * scale > frame.dimensions().y()
+        {
+            return Err(RenderError::Generic);
+        }
+
+        for (row, line) in data.iter().enumerate().take(self.font.height()) {
+            for col in 0..self.font.width() {
+                let pixel_x: usize = pos.x() + col * scale;
+                let pixel_y: usize = pos.y() + row * scale;
+
+                if line & (0x80 >> col) != 0 {
+                    for i in 0..scale {
+                        for j in 0..scale {
+                            frame.write_pixel(pixel_x + i, pixel_y + j, Colour::White)?;
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}

libk/src/std/io.rs

@@ -0,0 +1,84 @@
+pub use crate::drivers::io::{
+    ascii::{_print, _print_err, _print_log},
+    print, print_log, printerr, println, println_log, printlnerr,
+    serial::_serial_write,
+    serial_print, serial_println,
+};
+
+pub mod stdin {
+    use alloc::string::String;
+
+    use crate::drivers::io::{
+        ascii::WRITER,
+        keyboard::{KeyStroke, get_keystroke_async, get_keystroke_optional},
+    };
+
+    /// Reads a line of input from standard input asynchronously, returning a `String` containing
+    /// the input line. Does not include the newline character at the end of the line.
+    ///
+    /// If the user presses the abort key (usually Ctrl+C), the returned string will be empty.
+    ///
+    /// This function is currently unimplemented.
+    pub async fn read_line() -> String {
+        let mut writer = WRITER.lock();
+
+        let mut buff = String::new();
+        loop {
+            match get_keystroke_async().await {
+                KeyStroke::Char(c) => match c {
+                    '\n' => {
+                        writer.write_glyph(c as u8);
+                        return buff;
+                    }
+                    '\r' => {
+                        writer.write_glyph(c as u8);
+                        return buff;
+                    }
+                    '\x08' => {
+                        if !buff.is_empty() {
+                            buff.pop();
+                            writer.backspace();
+                        }
+                    }
+
+                    c => {
+                        writer.write_glyph(c as u8);
+                        buff.push(c)
+                    }
+                },
+                KeyStroke::Enter => {
+                    writer.write_glyph(b'\n');
+                    return buff;
+                }
+                KeyStroke::Backspace => {
+                    if !buff.is_empty() {
+                        buff.pop();
+                        writer.backspace();
+                    }
+                }
+                _ => continue,
+            }
+        }
+    }
+
+    /// Reads a character from standard input and blocks the current task until a character is
+    /// available.
+    ///
+    /// # Note
+    ///
+    /// This function is not yet implemented.
+    pub async fn async_keystroke() -> KeyStroke {
+        get_keystroke_async().await
+    }
+
+    /// Attempt to read a character from standard input without blocking the current task.
+    ///
+    /// If no character is available, returns `None`.
+    ///
+    /// # Note
+    ///
+    /// This function is not yet implemented.
+    pub fn keystroke() -> Option<KeyStroke> {
+        get_keystroke_optional()
+    }
+}

libk/src/std/maths/geometry.rs

@@ -0,0 +1,79 @@
+use core::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
+
+pub trait Coordinate:
+    Copy + Clone + PartialEq + AddAssign + MulAssign + SubAssign + DivAssign
+{
+}
+
+impl Coordinate for usize {}
+impl Coordinate for isize {}
+impl Coordinate for u8 {}
+impl Coordinate for i8 {}
+impl Coordinate for u16 {}
+impl Coordinate for i16 {}
+impl Coordinate for u32 {}
+impl Coordinate for i32 {}
+impl Coordinate for u64 {}
+impl Coordinate for i64 {}
+impl Coordinate for u128 {}
+impl Coordinate for i128 {}
+impl Coordinate for f32 {}
+impl Coordinate for f64 {}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
+pub struct Vec2<T: Coordinate> {
+    x: T,
+    y: T,
+}
+
+impl<T: Coordinate> Vec2<T> {
+    pub const fn new(x: T, y: T) -> Self {
+        Self { x, y }
+    }
+
+    pub fn into<S: Coordinate + From<T>>(&self) -> Vec2<S> {
+        Vec2::new(self.x.into(), self.y.into())
+    }
+
+    pub const fn x(&self) -> T {
+        self.x
+    }
+
+    pub const fn y(&self) -> T {
+        self.y
+    }
+}
+
+impl<T: Coordinate> AddAssign for Vec2<T> {
+    fn add_assign(&mut self, rhs: Self) {
+        self.x += rhs.x;
+        self.y += rhs.y;
+    }
+}
+
+impl<T: Coordinate> SubAssign for Vec2<T> {
+    fn sub_assign(&mut self, rhs: Self) {
+        self.x -= rhs.x;
+        self.y -= rhs.y;
+    }
+}
+
+impl<T: Coordinate> MulAssign<T> for Vec2<T> {
+    fn mul_assign(&mut self, rhs: T) {
+        self.x *= rhs;
+        self.y *= rhs;
+    }
+}
+
+impl<T: Coordinate> DivAssign<T> for Vec2<T> {
+    fn div_assign(&mut self, rhs: T) {
+        self.x /= rhs;
+        self.y /= rhs;
+    }
+}
+
+impl<T: Coordinate> From<Vec2<T>> for (T, T) {
+    fn from(value: Vec2<T>) -> Self {
+        (value.x, value.y)
+    }
+}

libk/src/std/maths/mod.rs

@@ -0,0 +1 @@
+pub mod geometry;

libk/src/std/mod.rs

@@ -0,0 +1,4 @@
+pub mod application;
+pub mod ascii;
+pub mod io;
+pub mod maths;

libk/src/threads.rs

@@ -0,0 +1,113 @@
+use core::arch::asm;
+
+#[repr(C)]
+pub struct Thread {
+    id: usize,
+    /// This shall be default before the program is interrupted, otherwise it will store
+    /// CPU registers etc to be restored on context switch.
+    ctx: ThreadContext,
+}
+
+/// CPU state to be saved on context switches.
+#[repr(C)]
+#[derive(Default)]
+pub struct ThreadContext {
+    /// Accumulator register.
+    rax: u64,
+    /// Base register.
+    rbx: u64,
+    /// Counter register.
+    rcx: u64,
+    /// Data register.
+    rdx: u64,
+    /// Source index register.
+    rsi: u64,
+    /// Destination index register.
+    rdi: u64,
+    /// Base pointer register.
+    rbp: u64,
+    /// Stack pointer register.
+    rsp: u64,
+    /// An extended register.
+    r8: u64,
+    /// An extended register.
+    r9: u64,
+    /// An extended register.
+    r10: u64,
+    /// An extended register.
+    r11: u64,
+    /// An extended register.
+    r12: u64,
+    /// An extended register.
+    r13: u64,
+    /// An extended register.
+    r14: u64,
+    /// An extended register.
+    r15: u64,
+    /// The instruction pointer.
+    rip: u64,
+    /// RFLAGS register.
+    rflags: u64,
+}
+
+impl ThreadContext {
+    /// Saves the current registers of the CPU before a context switch
+    /// to be restored later.
+    ///
+    /// # Notes
+    ///
+    /// This function should ONLY be called in interrupt handlers such
+    /// as that of the timer. This will then save registers as required
+    ///
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because of the usage of inline ASM.
+    #[inline(always)]
+    pub unsafe fn save_registers() -> Self {
+        let mut context = Self::default();
+        unsafe {
+            asm!(
+                "mov {0}, rax",
+                "mov {1}, rbx",
+                "mov {2}, rcx",
+                "mov {3}, rdx",
+                "mov {4}, rsi",
+                "mov {5}, rdi",
+                "mov {6}, rbp",
+                "mov {7}, rsp",
+                "mov {8}, r8",
+                "mov {9}, r9",
+                "mov {10}, r10",
+                "mov {11}, r11",
+                "mov {12}, r12",
+                "mov {13}, r13",
+                "mov {14}, r14",
+                "mov {15}, r15",
+                "lea {16}, [rip]",
+                "pushf",
+                "pop {17}",
+                out(reg) context.rax,
+                out(reg) context.rbx,
+                out(reg) context.rcx,
+                out(reg) context.rdx,
+                out(reg) context.rsi,
+                out(reg) context.rdi,
+                out(reg) context.rbp,
+                out(reg) context.rsp,
+                out(reg) context.r8,
+                out(reg) context.r9,
+                out(reg) context.r10,
+                out(reg) context.r11,
+                out(reg) context.r12,
+                out(reg) context.r13,
+                out(reg) context.r14,
+                out(reg) context.r15,
+                out(reg) context.rip,
+                out(reg) context.rflags,
+            );
+        }
+
+        context
+    }
+}

libk/src/util/editor.rs

@@ -0,0 +1,235 @@
+use crate::drivers::io::keyboard::{KeyStroke, get_keystroke_async};
+use crate::prelude::*;
+use crate::resources::font::{FONT_CP850_8X16, FONT_SPLEEN_8X16, Font};
+use crate::std::application::frame::Frame;
+use crate::std::application::render::RenderError;
+use crate::std::application::window::Window;
+use crate::std::application::{Application, Error};
+use crate::std::ascii::Writer;
+use crate::std::maths::geometry::Vec2;
+use alloc::string::ToString;
+
+pub struct Editor {
+    cursor_line: usize,
+    cursor_col: usize,
+
+    mode: Mode,
+    buffer: String,
+    window: Window,
+}
+
+impl Default for Editor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> Editor {
+    const PADDING: usize = 8;
+
+    pub const fn new() -> Self {
+        Self {
+            cursor_line: 0,
+            cursor_col: 0,
+
+            mode: Mode::Nor,
+            buffer: String::new(),
+            window: Window::new(),
+        }
+    }
+
+    fn render(&'a self) -> Result<Frame<'a>, RenderError> {
+        let mut frame = Frame::new(&self.window);
+        let writer = Writer::new(Font::default());
+
+        let (width, height) = writer.font_size().into();
+
+        let mut col = 0;
+        let mut line = 0;
+        let mut scale = 1;
+
+        for ch in self.buffer.chars() {
+            if ch == '\n' {
+                line += scale;
+                col = 0;
+                scale = 1;
+                continue;
+            }
+
+            if width * (col + 1) > frame.dimensions().x() - 2 * Self::PADDING {
+                line += scale;
+                col = 0;
+            }
+
+            writer.render_glyph(
+                &mut frame,
+                Vec2::new(col * width + Self::PADDING, line * height + Self::PADDING),
+                ch as u8,
+                scale,
+            )?;
+            col += scale;
+        }
+
+        writer.render_glyph(
+            &mut frame,
+            Vec2::new(
+                self.cursor_col * width + Self::PADDING,
+                self.cursor_line * height + Self::PADDING,
+            ),
+            b'_',
+            scale,
+        );
+
+        Ok(frame)
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn get_lines(&self) -> Vec<&str> {
+        self.buffer.split('\n').collect::<Vec<&str>>()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn move_cursor(&mut self, x: i32, y: i32) {
+        self.cursor_line = self
+            .cursor_line
+            .checked_add_signed(y as isize)
+            .unwrap_or(self.cursor_line);
+        self.cursor_col = self
+            .cursor_col
+            .checked_add_signed(x as isize)
+            .unwrap_or(self.cursor_col);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn delete_char(&mut self) {
+        let i = self.get_char_idx();
+        self.buffer.remove(i);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn insert_char(&mut self, c: char) {
+        let i = self.get_char_idx();
+        self.buffer.insert(i, c);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn splitline(&mut self) {
+        let i = self.get_char_idx();
+        self.buffer.insert(i, '\n');
+    }
+
+    fn get_char_idx(&self) -> usize {
+        let frame = Frame::new(&self.window);
+        let writer = Writer::new(Font::default());
+        let (width, _height) = writer.font_size().into();
+
+        let mut col = 0;
+        let mut line = 0;
+        let mut scale = 1;
+
+        for (i, ch) in self.buffer.chars().enumerate() {
+            if ch == '\n' {
+                line += scale;
+                col = 0;
+                scale = 1;
+                continue;
+            }
+
+            if width * (col + 1) > frame.dimensions().x() - 2 * Self::PADDING {
+                line += scale;
+                col = 0;
+            }
+
+            if col == self.cursor_col && line == self.cursor_line {
+                return i;
+            }
+
+            col += scale;
+        }
+
+        0
+    }
+}
+
+impl Application for Editor {
+    type Output = ();
+    async fn run(&mut self, _args: Vec<alloc::string::String>) -> Result<Self::Output, Error> {
+        self.window.set_dimensions(Vec2::new(1280, 800));
+        self.window.set_position(Vec2::new(0, 0));
+        self.window.open();
+
+        self.buffer = "Hello world, this is a test init. idk test \n ewntuiewi gjk gfdfg gndf ngdfgnmdfg ndfgmndfg gdfndfnkg njkdgjkndfjnkg ngnjfgnfgnfg fgn fn gfj gnfg jnfgjfngjk fgnjfgnjk jnkdgjnkdfg gfnd njkgdfgjn d fjnkgjkndfgjkndfgjn gndfjnk njkgdfng jnkfgdjknd jnfkgnjk".to_string();
+
+        loop {
+            if let Err(_err) = self.render().and_then(|frame| frame.render()) {
+                // TODO: Handle error
+                return Err(Error::ApplicationFailed("Rendering failed".to_string()));
+            }
+
+            let keystroke = get_keystroke_async().await;
+
+            match self.mode {
+                Mode::Nor => match keystroke {
+                    KeyStroke::Char('i') => self.mode = Mode::Ins,
+                    KeyStroke::Char('`') => return Ok(()),
+                    _ => {}
+                },
+                Mode::Ins => {
+                    match keystroke {
+                        KeyStroke::Char(c) => {
+                            match c {
+                                // escape
+                                '\x1B' => self.mode = Mode::Nor,
+                                // delete
+                                '\x7F' => self.delete_char(),
+                                // backspace
+                                '\x08' => {
+                                    self.move_cursor(-1, 0);
+                                    self.delete_char();
+                                }
+                                // enter
+                                '\n' => self.splitline(),
+                                _ => {
+                                    self.insert_char(c);
+                                    self.move_cursor(1, 0);
+                                }
+                            }
+                        }
+                        KeyStroke::Left => {
+                            serial_println!("Left\n");
+                            self.move_cursor(-1, 0);
+                        }
+                        KeyStroke::Right => {
+                            serial_println!("Right\n");
+                            self.move_cursor(1, 0);
+                        }
+                        KeyStroke::Up => {
+                            serial_println!("Up\n");
+                            self.move_cursor(0, -1);
+                        }
+                        KeyStroke::Down => {
+                            serial_println!("Down\n");
+                            self.move_cursor(0, 1);
+                        }
+                        KeyStroke::None => {}
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub enum Mode {
+    Nor,
+    Ins,
+}
+
+impl core::fmt::Display for Mode {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Nor => write!(f, "Normal"),
+            Self::Ins => write!(f, "Insert"),
+        }
+    }
+}

libk/src/util/mod.rs

@@ -0,0 +1,2 @@
+pub mod editor;
+pub mod shell;

libk/src/util/shell.rs

@@ -0,0 +1,49 @@
+// use x86_64::registers::rflags::read;
+
+use alloc::vec::Vec;
+
+use crate::{
+    drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println,
+    std::application::Application, util::editor::Editor,
+};
+
+static FETCH: &str = "
+        $$$$$$$$\\                                  $$\\                     
+        $$  _____|                                 $$ |                    
+        $$ |    $$$$$$\\  $$\\   $$\\ $$$$$$$\\   $$$$$$$ | $$$$$$\\  $$\\   $$\\ 
+        $$$$$\\ $$  __$$\\ $$ |  $$ |$$  __$$\\ $$  __$$ |$$  __$$\\ $$ |  $$ |
+        $$  __|$$ /  $$ |$$ |  $$ |$$ |  $$ |$$ /  $$ |$$ |  \\__|$$ |  $$ |
+        $$ |   $$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |      $$ |  $$ |
+        $$ |   \\$$$$$$  |\\$$$$$$  |$$ |  $$ |\\$$$$$$$ |$$ |      \\$$$$$$$ |
+        \\__|    \\______/  \\______/ \\__|  \\__| \\_______|\\__|       \\____$$ |
+             $$$$$$\\   $$$$$$\\        $$\\    $$\\   $$\\           $$\\   $$ |
+            $$  __$$\\ $$  __$$\\       $$ |   $$ |$$$$ |          \\$$$$$$  |
+            $$ /  $$ |$$ /  \\__|      $$ |   $$ |\\_$$ |           \\______/ 
+            $$ |  $$ |\\$$$$$$\\        \\$$\\  $$  |  $$ |                  
+            $$ |  $$ | \\____$$\\        \\$$\\$$  /   $$ |                  
+            $$ |  $$ |$$\\   $$ |        \\$$$  /    $$ |                  
+             $$$$$$  |\\$$$$$$  |         \\$  /   $$$$$$\\                 
+             \\______/  \\______/           \\_/    \\______|                              
+";
+
+pub async fn shell() {
+    println!("{}", FETCH);
+
+    loop {
+        print!(" Shell> ");
+        let line = read_line().await;
+        match line.as_str() {
+            "fetch" => {
+                println!("{}", FETCH);
+            }
+            "editor" => {
+                let mut editor = Editor::new();
+                editor.run(Vec::new()).await.unwrap();
+            }
+            "clear" => clear_screen(),
+            _ => {
+                println!("Unknown command: {}", line);
+            }
+        }
+    }
+}

libm/src/lib.rs

@@ -1,4 +1,3 @@
-#![feature(proc_macro_span)]
 #![warn(
     clippy::correctness,
     clippy::nursery,
@@ -13,32 +12,18 @@
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom};
 
-use proc_macro::{Span, TokenStream};
+use proc_macro::TokenStream;
 use quote::quote;
-use std::path::PathBuf;
 use syn::{LitStr, parse_macro_input};
+
 extern crate proc_macro;
 
 #[proc_macro]
-/// Expects the file path to be relative to the current file so this works
-/// similarly to the standard Rust include! macros.
 pub fn include_font(item: TokenStream) -> TokenStream {
-    let span = Span::call_site();
-    let source_file = span.source_file();
-
-    if !source_file.is_real() {
-        panic!(
-            "We can't handle finding files if the source file does not exist. TODO: Can we?"
-        )
-    }
-
     let filename = parse_macro_input!(item as LitStr);
-    let source_filepath: PathBuf = source_file.path();
+    let file_path = filename.value();
-    let file_path = format!(
+
-        "{}/{}",
+    println!("Loading font: [{}]", file_path);
-        source_filepath.parent().unwrap_or_else(|| panic!("Expected to find the calling source file in a folder like src! Got: {}", source_filepath.display())).display(),
-        filename.value()
-    );
 
     let font_bytes = match load_file(file_path) {
         Ok(bytes) => bytes,

rustfmt.toml

@@ -1,5 +0,0 @@
-max_width = 85
-format_code_in_doc_comments = true
-comment_width = 80
-wrap_comments = true
-inline_attribute_width = 80

scripts/run_debug.sh

@@ -94,6 +94,15 @@ check_test_res() {
 
 trap 'check_test_res "tests completed"' ERR
  
+
+# NOTE(ali): For some reason the values in `boot_flags` were causing issues
+# 	     on WSL, so they've been eradicated.
+systemInfo=$(uname -r)
+if [[ $systemInfo == *"WSL"* ]]; then
+    echo "Running on WSL2"
+    boot_flags=""
+fi
+
 cd "$project_root"
 qemu-system-x86_64 -M q35 \
     -cdrom "$build_dir/image.iso" \