diff --git a/Asuro.iso b/Asuro.iso
index fac55fe9..e6ae8129 100644
Binary files a/Asuro.iso and b/Asuro.iso differ
diff --git a/bin/kernel.bin b/bin/kernel.bin
index 22e05476..5ef1ed72 100755
Binary files a/bin/kernel.bin and b/bin/kernel.bin differ
diff --git a/iso/boot/asuro.bin b/iso/boot/asuro.bin
index 22e05476..5ef1ed72 100755
Binary files a/iso/boot/asuro.bin and b/iso/boot/asuro.bin differ
diff --git a/lib/gdt.ppu b/lib/gdt.ppu
index e9822f97..54cd5770 100644
Binary files a/lib/gdt.ppu and b/lib/gdt.ppu differ
diff --git a/lib/kernel.o b/lib/kernel.o
index 230880e0..c255324b 100644
Binary files a/lib/kernel.o and b/lib/kernel.o differ
diff --git a/lib/kernel.ppu b/lib/kernel.ppu
index 3cdd8fe1..05a2f949 100644
Binary files a/lib/kernel.ppu and b/lib/kernel.ppu differ
diff --git a/lib/libpkernel.a b/lib/libpkernel.a
index 131278a2..a14b9528 100644
Binary files a/lib/libpkernel.a and b/lib/libpkernel.a differ
diff --git a/lib/types.ppu b/lib/types.ppu
index 118a89ac..910b58e4 100644
Binary files a/lib/types.ppu and b/lib/types.ppu differ
diff --git a/src/bios_data_area.pas b/src/bios_data_area.pas
index 5f32060a..a124223f 100644
--- a/src/bios_data_area.pas
+++ b/src/bios_data_area.pas
@@ -4,24 +4,24 @@ interface
 
 type
      TBDA = bitpacked record
-          COM1            : WORD;
-          COM2            : WORD;
-          COM3            : WORD;
-          COM4            : WORD;
-          LPT1            : WORD;
-          LPT2            : WORD;
-          LPT3            : WORD;
-          EBDA            : WORD;
-          Hardware_Flags  : WORD;
-          Keyboard_Flags  : WORD;
-          Keyboard_Buffer : ARRAY[0..31] OF BYTE;
-          Display_Mode    : BYTE;
-          BaseIO          : WORD;
-          Ticks           : WORD;
-          HDD_Count       : BYTE;
-          Keyboard_Start  : WORD;
-          Keyboard_End    : WORD;
-          Keyboard_State  : Byte;
+          COM1            : uint16;
+          COM2            : uint16;
+          COM3            : uint16;
+          COM4            : uint16;
+          LPT1            : uint16;
+          LPT2            : uint16;
+          LPT3            : uint16;
+          EBDA            : uint16;
+          Hardware_Flags  : uint16;
+          Keyboard_Flags  : uint16;
+          Keyboard_Buffer : ARRAY[0..31] OF uint8;
+          Display_Mode    : uint8;
+          BaseIO          : uint16;
+          Ticks           : uint16;
+          HDD_Count       : uint8;
+          Keyboard_Start  : uint16;
+          Keyboard_End    : uint16;
+          Keyboard_State  : uint8;
      end;
      PBDA = ^TBDA;
 
diff --git a/src/console.pas b/src/console.pas
index 1fc388dc..118e3e52 100644
--- a/src/console.pas
+++ b/src/console.pas
@@ -26,33 +26,33 @@ type
 
 procedure init();
 procedure clear();
-procedure setdefaultattribute(attribute : char);
+procedure setdefaultattribute(attribute : sint8);
 
-procedure writechar(character : char);
-procedure writestring(str: PChar);
-procedure writeint(i: Integer);
-procedure writeword(i: DWORD);
-procedure writehex(i: DWORD);
+procedure writechar(character : sint8);
+procedure writestring(str: psint8);
+procedure writeint(i: sint32);
+procedure writeword(i: uint32);
+procedure writehex(i: uint32);
 
-procedure writecharln(character : char);
-procedure writestringln(str: PChar);
-procedure writeintln(i: Integer);
-procedure writewordln(i: DWORD);
-procedure writehexln(i: DWORD);
+procedure writecharln(character : sint8);
+procedure writestringln(str: psint8);
+procedure writeintln(i: sint32);
+procedure writewordln(i: uint32);
+procedure writehexln(i: uint32);
 
-procedure writecharex(character : char; attributes : char);
-procedure writestringex(str: PChar; attributes : char);
-procedure writeintex(i: Integer; attributes : char);
-procedure writewordex(i: DWORD; attributes : char);
-procedure writehexex(i : DWORD; attributes : char);
+procedure writecharex(character : sint8; attributes : sint8);
+procedure writestringex(str: psint8; attributes : sint8);
+procedure writeintex(i: sint32; attributes : sint8);
+procedure writewordex(i: uint32; attributes : sint8);
+procedure writehexex(i : uint32; attributes : sint8);
 
-procedure writecharlnex(character : char; attributes : char);
-procedure writestringlnex(str: PChar; attributes : char);
-procedure writeintlnex(i: Integer; attributes : char);
-procedure writewordlnex(i: DWORD; attributes : char);
-procedure writehexlnex(i: DWORD; attributes : char);
+procedure writecharlnex(character : sint8; attributes : sint8);
+procedure writestringlnex(str: psint8; attributes : sint8);
+procedure writeintlnex(i: sint32; attributes : sint8);
+procedure writewordlnex(i: uint32; attributes : sint8);
+procedure writehexlnex(i: uint32; attributes : sint8);
 
-function combinecolors(Foreground, Background : TColor) : char;
+function combinecolors(Foreground, Background : TColor) : sint8;
 
 procedure _increment_x();
 procedure _increment_y();
@@ -64,12 +64,12 @@ implementation
 
 type
     TConsoleProperties = record
-      Default_Attribute : Char;
+      Default_Attribute : sint8;
     end;
 
     TCharacter = bitpacked record
-      Character  : Char;
-      Attributes : Char;
+      Character  : sint8;
+      Attributes : sint8;
     end;
     PCharacter = ^TCharacter;
 
@@ -80,8 +80,8 @@ type
     P2DVideoMemory = ^T2DVideoMemory;
 
     TCoord = record
-      X : Byte;
-      Y : Byte;
+      X : uint8;
+      Y : uint8;
     end;
 
 var
@@ -98,7 +98,7 @@ end;
 
 procedure clear(); [public, alias: 'console_clear'];
 var
-   x,y: Byte;
+   x,y: uint8;
 
 begin
      for x:=0 to 79 do begin
@@ -111,64 +111,64 @@ begin
      Console_Cursor.Y:= 0;
 end;
 
-procedure setdefaultattribute(attribute: char); [public, alias: 'console_setdefaultattribute'];
+procedure setdefaultattribute(attribute: sint8); [public, alias: 'console_setdefaultattribute'];
 begin
      Console_Properties.Default_Attribute:= attribute;
 end;
 
-procedure writechar(character: char); [public, alias: 'console_writechar'];
+procedure writechar(character: sint8); [public, alias: 'console_writechar'];
 begin
      console.writecharex(character, Console_Properties.Default_Attribute);
 end;
 
-procedure writestring(str: PChar); [public, alias: 'console_writestring'];
+procedure writestring(str: psint8); [public, alias: 'console_writestring'];
 begin
      console.writestringex(str, Console_Properties.Default_Attribute);
 end;
 
-procedure writeint(i: Integer); [public, alias: 'console_writeint'];
+procedure writeint(i: sint32); [public, alias: 'console_writeint'];
 begin
      console.writeintex(i, Console_Properties.Default_Attribute);
 end;
 
-procedure writeword(i: DWORD); [public, alias: 'console_writeword'];
+procedure writeword(i: uint32); [public, alias: 'console_writeword'];
 begin
      console.writewordex(i, Console_Properties.Default_Attribute);
 end;
 
-procedure writecharln(character: char); [public, alias: 'console_writecharln'];
+procedure writecharln(character: sint8); [public, alias: 'console_writecharln'];
 begin
      console.writecharlnex(character, Console_Properties.Default_Attribute);
 end;
 
-procedure writestringln(str: PChar); [public, alias: 'console_writestringln'];
+procedure writestringln(str: psint8); [public, alias: 'console_writestringln'];
 begin
      console.writestringlnex(str, Console_Properties.Default_Attribute);
 end;
 
-procedure writeintln(i: Integer); [public, alias: 'console_writeintln'];
+procedure writeintln(i: sint32); [public, alias: 'console_writeintln'];
 begin
      console.writeintlnex(i, Console_Properties.Default_Attribute);
 end;
 
-procedure writewordln(i: DWORD); [public, alias: 'console_writewordln'];
+procedure writewordln(i: uint32); [public, alias: 'console_writewordln'];
 begin
      console.writewordlnex(i, Console_Properties.Default_Attribute);
 end;
 
-procedure writecharex(character: char; attributes: char); [public, alias: 'console_writecharex'];
+procedure writecharex(character: sint8; attributes: sint8); [public, alias: 'console_writecharex'];
 begin
      Console_Matrix^[Console_Cursor.Y][Console_Cursor.X].Character:= character;
      Console_Matrix^[Console_Cursor.Y][Console_Cursor.X].Attributes:= attributes;
      console._safeincrement_x();
 end;
 
-procedure writehexex(i : dword; attributes: char); [public, alias: 'console_writehexex'];
+procedure writehexex(i : uint32; attributes: sint8); [public, alias: 'console_writehexex'];
 var
-   Hex : Array[0..7] of Byte;
-   Res : DWORD;
-   Rem : DWORD;
-   c   : Integer;
+   Hex : Array[0..7] of uint8;
+   Res : uint32;
+   Rem : uint32;
+   c   : sint32;
    
 begin
      for c:=0 to 7 do begin
@@ -209,25 +209,25 @@ begin
      end;
 end;
 
-procedure writehex(i : dword); [public, alias: 'console_writehex'];
+procedure writehex(i : uint32); [public, alias: 'console_writehex'];
 begin
      console.writehexex(i, Console_Properties.Default_Attribute);
 end;
 
-procedure writehexlnex(i : dword; attributes : char);
+procedure writehexlnex(i : uint32; attributes : sint8);
 begin
      console.writehexex(i, attributes);
      console._safeincrement_y();
 end;
 
-procedure writehexln(i : dword);
+procedure writehexln(i : uint32);
 begin
      writehexlnex(i, Console_Properties.Default_Attribute);
 end;
 
-procedure writestringex(str: PChar; attributes: char); [public, alias: 'console_writestringex'];
+procedure writestringex(str: psint8; attributes: sint8); [public, alias: 'console_writestringex'];
 var
-   i : integer;
+   i : sint32;
 
 begin
      i:= 0;
@@ -237,11 +237,11 @@ begin
      end;
 end;
 
-procedure writeintex(i: Integer; attributes : char); [public, alias: 'console_writeintex'];
+procedure writeintex(i: sint32; attributes : sint8); [public, alias: 'console_writeintex'];
 var
-        buffer: array [0..11] of Char;
-        str: PChar;
-        digit: DWORD;
+        buffer: array [0..11] of sint8;
+        str: psint8;
+        digit: uint32;
         minus: Boolean;
 begin
         str := @buffer[11];
@@ -255,7 +255,7 @@ begin
         end;
         repeat
                 Dec(str);
-                str^ := Char((digit mod 10) + Byte('0'));
+                str^ := sint8((digit mod 10) + uint8('0'));
                 digit := digit div 10;
         until (digit = 0);
         if (minus) then begin
@@ -265,11 +265,11 @@ begin
         console.writestringex(str, attributes);
 end;
  
-procedure writewordex(i: DWORD; attributes : char); [public, alias: 'console_writedwordex'];
+procedure writewordex(i: uint32; attributes : sint8); [public, alias: 'console_writedwordex'];
 var
-        buffer: array [0..11] of Char;
-        str: PChar;
-        digit: DWORD;
+        buffer: array [0..11] of sint8;
+        str: psint8;
+        digit: uint32;
 begin
         for digit := 0 to 10 do buffer[digit] := '0';
         str := @buffer[11];
@@ -277,45 +277,45 @@ begin
         digit := i;
         repeat
                 Dec(str);
-                str^ := Char((digit mod 10) + Byte('0'));
+                str^ := sint8((digit mod 10) + uint8('0'));
                 digit := digit div 10;
         until (digit = 0);
         console.writestringex(@Buffer[0], attributes);
 end;
 
-procedure writecharlnex(character: char; attributes: char); [public, alias: 'console_writecharlnex'];
+procedure writecharlnex(character: sint8; attributes: sint8); [public, alias: 'console_writecharlnex'];
 begin
      console.writecharex(character, attributes);
      console._safeincrement_y();
 end;
 
-procedure writestringlnex(str: PChar; attributes: char); [public, alias: 'console_writestringlnex'];
+procedure writestringlnex(str: sint8; attributes: sint8); [public, alias: 'console_writestringlnex'];
 begin
      console.writestringex(str, attributes);
      console._safeincrement_y();
 end;
 
-procedure writeintlnex(i: Integer; attributes: char); [public, alias: 'console_writeintlnex'];
+procedure writeintlnex(i: sint32; attributes: sint8); [public, alias: 'console_writeintlnex'];
 begin
      console.writeintex(i, attributes);
      console._safeincrement_y();
 end;
 
-procedure writewordlnex(i: DWORD; attributes: char); [public, alias: 'console_writewordlnex'];
+procedure writewordlnex(i: uint32; attributes: sint8); [public, alias: 'console_writewordlnex'];
 begin
      console.writewordex(i, attributes);
      console._safeincrement_y();
 end;
 
-function combinecolors(Foreground, Background: TColor): char; [public, alias: 'console_combinecolors'];
+function combinecolors(Foreground, Background: TColor): sint8; [public, alias: 'console_combinecolors'];
 begin
-     combinecolors:= char(((ord(Background) shl 4) or ord(Foreground)));
+     combinecolors:= sint8(((ord(Background) shl 4) or ord(Foreground)));
 end;
 
 procedure _update_cursor(); [public, alias: '_console_update_cursor'];
 var
-   pos : word;
-   b   : byte;
+   pos : uint16;
+   b   : uint8;
    
 begin
      pos:= (Console_Cursor.Y * 80) + Console_Cursor.X;
@@ -366,7 +366,7 @@ end;
 
 procedure _newline(); [public, alias: '_console_newline'];
 var
-   x, y : byte;
+   x, y : uint8;
 
 begin
      for x:=0 to 79 do begin
diff --git a/src/gdt.pas b/src/gdt.pas
index 74fa1a8a..92e8b8ec 100644
--- a/src/gdt.pas
+++ b/src/gdt.pas
@@ -7,18 +7,18 @@ uses
 
 type
     TGDT_Entry = bitpacked record
-        limit_low   : int16;
-        base_low    : int16;
-        base_middle : int8;
-        access      : int8;
-        granularity : int8;
-        base_high   : int8;
+        limit_low   : uint16;
+        base_low    : uint16;
+        base_middle : uint8;
+        access      : uint8;
+        granularity : uint8;
+        base_high   : uint8;
     end;
     PGDT_Entry = ^TGDT_Entry;
 
     TGDT_Pointer = bitpacked record
-        limit : int16;
-        base  : int32;
+        limit : uint16;
+        base  : uint32;
     end;
 
 var
@@ -29,7 +29,7 @@ procedure init();
     
 implementation
 
-procedure flush_gdt(gdt_pointer : int32); assembler; nostackframe;
+procedure flush_gdt(gdt_pointer : uint32); assembler; nostackframe;
 asm
     MOV EAX, gdt_pointer
     LGDT [EAX]
@@ -40,13 +40,11 @@ asm
     MOV GS, AX
     MOV SS, AX
     db $EA          // Bypass stupid inline ASM restrictions-
-    dw @@flush, $08 // by assembling the farjump instruction ourselves.
-                    // It's just data, honest gov'.
-@@flush:
-    RET
+    dw @@flush, $08 // by assembling the farjump instruction ourselves.                    
+@@flush:            // It's just data, honest gov'.
 end;
 
-procedure set_gate(Gate_Number : int32; Base : int32; Limit : int32; Access : int8; Granularity : int8);
+procedure set_gate(Gate_Number : uint32; Base : uint32; Limit : uint32; Access : uint8; Granularity : uint8);
 begin
     gdt_entries[Gate_Number].base_low    := (Base AND $FFFF);
     gdt_entries[Gate_Number].base_middle := (Base SHR 16) AND $FF;
@@ -59,13 +57,13 @@ end;
 procedure init();
 begin
     gdt_pointer.limit := (sizeof(TGDT_Entry) * 5) - 1;
-    gdt_pointer.base  := int32(@gdt_entries);
+    gdt_pointer.base  := uint32(@gdt_entries);
     set_gate($00, $00, $00,       $00, $00);
     set_gate($01, $00, $FFFFFFFF, $9A, $CF);
     set_gate($02, $00, $FFFFFFFF, $92, $CF);
     set_gate($03, $00, $FFFFFFFF, $FA, $CF);
     set_gate($04, $00, $FFFFFFFF, $F2, $CF);
-    flush_gdt(int32(@gdt_pointer))
+    flush_gdt(uint32(@gdt_pointer))
 end;
 
 end.
\ No newline at end of file
diff --git a/src/idt.pas b/src/idt.pas
new file mode 100644
index 00000000..ee6a9677
--- /dev/null
+++ b/src/idt.pas
@@ -0,0 +1,16 @@
+unit idt;
+
+interface
+
+uses
+    system,
+    types;
+
+type
+    TIDT_Entry = bitpacked record
+        
+    end;
+
+implementation
+
+end.
\ No newline at end of file
diff --git a/src/kernel.pas b/src/kernel.pas
index 78262362..8de23b9b 100644
--- a/src/kernel.pas
+++ b/src/kernel.pas
@@ -14,12 +14,12 @@ procedure kmain(mbinfo: Pmultiboot_info_t; mbmagic: DWORD); stdcall;
  
 implementation
  
-procedure kmain(mbinfo: Pmultiboot_info_t; mbmagic: DWORD); stdcall; [public, alias: 'kmain'];   
+procedure kmain(mbinfo: Pmultiboot_info_t; mbmagic: uint32); stdcall; [public, alias: 'kmain'];   
 var
-   c : byte;
+   c : uint8;
    mbi : Pmultiboot_info_t;
-   mbm : DWORD;
-   dds  : DWORD;
+   mbm : uint32;
+   dds  : uint32;
    
 begin
      mbi:= mbinfo;
@@ -41,8 +41,6 @@ begin
      console.setdefaultattribute(console.combinecolors(Red, Black));
      if dds = $08 then console.setdefaultattribute(console.combinecolors(Green, Black));
      console.writehexln(dds);
-     util.halt_and_catch_fire;
-
      console.setdefaultattribute(console.combinecolors(Green, Black));
      console.writestringln('Asuro Booted Correctly!');
      console.writestringln('');
@@ -57,11 +55,11 @@ begin
      console.writeint(((mbinfo^.mem_upper + 1000) div 1024) +1);
      console.writestringln('MB');
      console.setdefaultattribute(console.combinecolors(lYellow, Black));
-     while true do begin
+     {while true do begin
           c:= keyboard.get_scancode;
           console.writehexln(c);  
      end;
-     util.halt_and_catch_fire;
+     util.halt_and_catch_fire;}
 end;
  
 end.
diff --git a/src/keyboard.pas b/src/keyboard.pas
index f51e7a7b..3ac2b5b5 100644
--- a/src/keyboard.pas
+++ b/src/keyboard.pas
@@ -7,13 +7,13 @@ interface
 uses
      util;
 
-function get_scancode() : byte;
+function get_scancode() : uint8;
 
 implementation
 
-function get_scancode() : byte; [public, alias: 'get_scancode'];
+function get_scancode() : uint8; [public, alias: 'get_scancode'];
 var
-   c : byte;
+   c : uint8;
    
 begin
      c:= 0;
diff --git a/src/multiboot.pas b/src/multiboot.pas
index 049a68d9..33c236af 100644
--- a/src/multiboot.pas
+++ b/src/multiboot.pas
@@ -9,40 +9,40 @@ const
 type
         Pelf_section_header_table_t = ^elf_section_header_table_t;
         elf_section_header_table_t = packed record
-          num: DWORD;
-          size: DWORD;
-          addr: DWORD;
-          shndx: DWORD;
+          num: uint32;
+          size: uint32;
+          addr: uint32;
+          shndx: uint32;
         end;
  
         Pmultiboot_info_t = ^multiboot_info_t;
         multiboot_info_t = packed record
-          flags: DWORD;
-          mem_lower: DWORD;
-          mem_upper: DWORD;
-          boot_device: DWORD;
-          cmdline: DWORD;
-          mods_count: DWORD;
-          mods_addr: DWORD;
+          flags: uint32;
+          mem_lower: uint32;
+          mem_upper: uint32;
+          boot_device: uint32;
+          cmdline: uint32;
+          mods_count: uint32;
+          mods_addr: uint32;
           elf_sec: elf_section_header_table_t;
-          mmap_length: DWORD;
-          mmap_addr: DWORD;
+          mmap_length: uint32;
+          mmap_addr: uint32;
         end;
  
         Pmodule_t = ^module_t;
         module_t = packed record
-          mod_start: DWORD;
-          mod_end: DWORD;
-          name: DWORD;
-          reserved: DWORD;
+          mod_start: uint32;
+          mod_end: uint32;
+          name: uint32;
+          reserved: uint32;
         end;
  
         Pmemory_map_t = ^memory_map_t;
         memory_map_t = packed record
-          size: DWORD;
-		base_addr : QWORD;
-		length : QWORD;          
-		mtype: DWORD;
+          size: uint32;
+		      base_addr : uint64;
+		      length : uint64;          
+		      mtype: uint32;
         end;
  
 implementation
diff --git a/src/types.pas b/src/types.pas
index a78a15f1..fbc712f0 100644
--- a/src/types.pas
+++ b/src/types.pas
@@ -4,21 +4,34 @@ interface
 
 type
     //Standard Types
-    Int8  = BYTE;
-    Int16 = WORD;
-    Int32 = DWORD;
-    Int64 = QWORD;
+    uInt8  = BYTE;
+    uInt16 = WORD;
+    uInt32 = DWORD;
+    uInt64 = QWORD;
+
+    sInt8 = shortint;
+    sInt16 = smallint;
+    sInt32 = integer;
+    sInt64 = longint;
+
+    Float = Single;
 
     //Pointer Types
-    PByte = ^Byte;
-    PInt8 = PByte;
-    PInt16 = ^Int16;
-    PInt32 = ^Int32;
-    PInt64 = ^Int64;
+    PuByte = ^Byte;
+    PuInt8 = PuByte;
+    PuInt16 = ^uInt16;
+    PuInt32 = ^uInt32;
+    PuInt64 = ^uInt64;
 
-    Void = ^Int32;
+    PsInt8 = ^sInt8;
+    PsInt16 = ^sInt16;
+    PsInt32 = ^sInt32;
+    PsInt64 = ^sInt64;
 
+    PFloat = ^Float;
+    PDouble = ^Double;
 
+    Void = ^uInt32;
 
 implementation
 
diff --git a/src/util.pas b/src/util.pas
index 29174461..c41656a6 100644
--- a/src/util.pas
+++ b/src/util.pas
@@ -4,35 +4,35 @@ unit util;
 
 interface
 
-function hi(b : byte) : byte;
-function lo(b : byte) : byte;
-function switchendian(b : byte) : byte;
-procedure outb(port : word; val : byte);
-procedure outw(port : word; val : word);
-procedure outl(port : word; val : longword);
+function hi(b : uint8) : uint8;
+function lo(b : uint8) : uint8;
+function switchendian(b : uint8) : uint8;
+procedure outb(port : uint16; val : uint8);
+procedure outw(port : uint16; val : uint16);
+procedure outl(port : uint16; val : uint32);
 procedure halt_and_catch_fire();
-function inb(port : word) : byte;
-function inw(port : word) : word;
-function inl(port : word) : dword;
+function inb(port : uint16) : uint8;
+function inw(port : uint16) : uint16;
+function inl(port : uint16) : uint32;
 
 implementation
 
-function hi(b : byte) : byte; [public, alias: 'util_hi'];
+function hi(b : uint8) : uint8; [public, alias: 'util_hi'];
 begin
      hi:= (b AND $F0) SHR 4;
 end;
 
-function lo(b : byte) : byte; [public, alias: 'util_lo'];
+function lo(b : uint8) : uint8; [public, alias: 'util_lo'];
 begin
      lo:= b AND $0F;
 end;
 
-function switchendian(b : byte) : byte; [public, alias: 'util_switchendian'];
+function switchendian(b : uint8) : uint8; [public, alias: 'util_switchendian'];
 begin
      switchendian:= (lo(b) SHL 4) OR hi(b);
 end;
 
-procedure outl(port : word; val : longword); [public, alias: 'util_outl'];
+procedure outl(port : uint16; val : uint32); [public, alias: 'util_outl'];
 begin
      asm
           PUSH EAX
@@ -45,7 +45,7 @@ begin
      end;
 end;
 
-procedure outw(port : word; val : word); [public, alias: 'util_outw'];
+procedure outw(port : uint16; val : uint16); [public, alias: 'util_outw'];
 begin
      asm
           PUSH EAX
@@ -58,7 +58,7 @@ begin
      end;
 end;
 
-procedure outb(port : word; val : byte); [public, alias: 'util_outb'];
+procedure outb(port : uint16; val : uint8); [public, alias: 'util_outb'];
 begin
      asm
           PUSH EAX
@@ -79,7 +79,7 @@ begin
      end;
 end;
 
-function inl(port : word) : dword; [public, alias: 'util_inl'];
+function inl(port : uint16) : uint32; [public, alias: 'util_inl'];
 begin
      asm
           PUSH EAX
@@ -92,7 +92,7 @@ begin
      end;
 end;
 
-function inw(port : word) : word; [public, alias: 'util_inw'];
+function inw(port : uint16) : uint16; [public, alias: 'util_inw'];
 begin
      asm
           PUSH EAX
@@ -105,7 +105,7 @@ begin
      end;
 end;
 
-function inb(port : word) : byte; [public, alias: 'util_inb'];
+function inb(port : uint16) : uint8; [public, alias: 'util_inb'];
 begin
      asm
           PUSH EAX