some cleanup

11 files changed, 578 insertions, 581 deletions

diff --git a/Assembler/Program.cs b/Assembler/Program.cs
index 2101868..0493057 100644
--- a/Assembler/Program.cs
+++ b/Assembler/Program.cs
@@ -24,7 +24,7 @@ public class Program
 
             File.WriteAllBytes(assemblerOptions.OutputFile, bin);
 
-            Console.WriteLine($"Assembled {assemblerOptions.InputFile} to {assemblerOptions.OutputFile} ({bin.Length} bytes)");
+            Console.WriteLine($"Assembled {assemblerOptions.InputFile} -> {assemblerOptions.OutputFile}. ({bin.Length} bytes)");
         }
         catch (AssemblerException ex)
         {
diff --git a/Compiler/CompilerOptions.cs b/Compiler/CompilerOptions.cs
index c1f5c3a..87ec384 100644
--- a/Compiler/CompilerOptions.cs
+++ b/Compiler/CompilerOptions.cs
@@ -12,4 +12,7 @@ public class CompilerOptions
 
     [Option('c', "comment-compilation", Required = false, HelpText = "Comments to preserve in the compiled result")]
     public CommentCompilationMode CommentCompilationMode { get; set; } = CommentCompilationMode.UserDefined;
+    
+    [Option('v', "verbose", Required = false, HelpText = "Enable verbose output during compilation.")]
+    public bool Verbose { get; set; } = false;
 }
\ No newline at end of file
diff --git a/Compiler/PreprocessingCharStream.cs b/Compiler/PreprocessingCharStream.cs
new file mode 100644
index 0000000..428cbff
--- /dev/null
+++ b/Compiler/PreprocessingCharStream.cs
@@ -0,0 +1,25 @@
+namespace Q1.Compiler;
+
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+
+public class PreprocessingCharStream : ICharStream
+{
+    private readonly AntlrInputStream inner;
+
+    public PreprocessingCharStream(string filePath)
+    {
+        string preprocessed = Preprocessor.Process(filePath);
+        this.inner = new AntlrInputStream(preprocessed);
+    }
+
+    public int Index => this.inner.Index;
+    public int Size => this.inner.Size;
+    public string SourceName => this.inner.SourceName;
+    public void Consume() => this.inner.Consume();
+    public int LA(int i) => this.inner.LA(i);
+    public int Mark() => this.inner.Mark();
+    public void Release(int marker) => this.inner.Release(marker);
+    public void Seek(int index) => this.inner.Seek(index);
+    public string GetText(Interval interval) => this.inner.GetText(interval);
+}
\ No newline at end of file
diff --git a/Compiler/Preprocessor.cs b/Compiler/Preprocessor.cs
index fba28c1..f11ae3a 100644
--- a/Compiler/Preprocessor.cs
+++ b/Compiler/Preprocessor.cs
@@ -26,7 +26,6 @@ public static class Preprocessor
 
             if (line.StartsWith("#include"))
             {
-                // simple format: #include "file"
                 Match match = Regex.Match(line, "#include\\s+\"([^\"]+)\"");
                 if (match.Success)
                 {
@@ -37,7 +36,6 @@ public static class Preprocessor
             }
             else if (line.StartsWith("#define"))
             {
-                // simple format: #define NAME VALUE
                 Match match = Regex.Match(line, "#define\\s+(\\w+)\\s+(.*)");
                 if (match.Success)
                     Defines[match.Groups[1].Value] = match.Groups[2].Value;
diff --git a/Compiler/Program.cs b/Compiler/Program.cs
index 09f7127..cde49a5 100644
--- a/Compiler/Program.cs
+++ b/Compiler/Program.cs
@@ -2,7 +2,6 @@
 
 using System.Text;
 using Antlr4.Runtime;
-using Antlr4.Runtime.Misc;
 using CommandLine;
 using visitors;
 using Parser = CommandLine.Parser;
@@ -41,33 +40,22 @@ public class Program
             IEnumerable<string> result = compiler.Compile(parser.program());
 
             File.WriteAllLines(options.OutputFile, result);
+            if (options.Verbose)
+            {
+                Console.WriteLine();
+                foreach (string line in result)
+                    Console.WriteLine(line);
+                Console.WriteLine();
+            }
 
-            Console.WriteLine("Compilation successful.");
+            Console.WriteLine($"Compilation successful. ({result.Count(x=>x != string.Empty)} instructions)");
         }
         catch (CompilerException ex)
         {
-            Console.WriteLine($"{ex.Message}");
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            Console.ResetColor();
+            Environment.Exit(1);
         }
     }
-}
-
-public class PreprocessingCharStream : ICharStream
-{
-    private readonly AntlrInputStream inner;
-
-    public PreprocessingCharStream(string filePath)
-    {
-        string preprocessed = Preprocessor.Process(filePath);
-        inner = new AntlrInputStream(preprocessed);
-    }
-
-    public int Index => inner.Index;
-    public int Size => inner.Size;
-    public string SourceName => inner.SourceName;
-    public void Consume() => inner.Consume();
-    public int LA(int i) => inner.LA(i);
-    public int Mark() => inner.Mark();
-    public void Release(int marker) => inner.Release(marker);
-    public void Seek(int index) => inner.Seek(index);
-    public string GetText(Interval interval) => inner.GetText(interval);
 }
\ No newline at end of file
diff --git a/Emulator/DisplayEngine.cs b/Emulator/DisplayEngine.cs
index 1e50809..7aa8e2e 100644
--- a/Emulator/DisplayEngine.cs
+++ b/Emulator/DisplayEngine.cs
@@ -77,7 +77,6 @@ public class DisplayEngine : Game
         foreach (Keys newKey in keys.Except(this._oldKeys ?? []))
         {
             this._hid.SetKeyboard((u8) newKey, true);
-            Console.WriteLine((u8) newKey);
         }
         
         foreach (Keys oldKey in this._oldKeys?.Except(keys) ?? [])
diff --git a/Orchestrator/Program.cs b/Orchestrator/Program.cs
index 213f5ee..c5d7538 100644
--- a/Orchestrator/Program.cs
+++ b/Orchestrator/Program.cs
@@ -28,7 +28,8 @@ class Program
                 {
                     CommentCompilationMode = options.CommentCompilationMode,
                     InputFile = options.InputFile,
-                    OutputFile = compiledFile
+                    OutputFile = compiledFile,
+                    Verbose = options.Verbose
                 });
 
         if (!options.NoAssemble)
@@ -67,4 +68,7 @@ class Options
 
     [Option("no-emulate", HelpText = "Skip emulation")]
     public bool NoEmulate { get; set; } = false;
+    
+    [Option('v', "verbose", HelpText = "Enable verbose output")]
+    public bool Verbose { get; set; } = false;
 }
\ No newline at end of file
diff --git a/ROMs/paint.asm b/ROMs/paint.asm
index 9a853a4..c5bfe14 100644
--- a/ROMs/paint.asm
+++ b/ROMs/paint.asm
@@ -1,264 +1,264 @@
     jmp _main
-_hid_getKeyState_int_scanCode:; int hid_getKeyState(int scanCode)
-    pop V0                    ; preserve function return address
-    pop [$71FF]               ; param int scanCode
-    push V0                   ; restore function return address
-    mov $6033, [$7201]        ; int sk_table = $6033
-    push [$71FF]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    div V0, V1                ; compute division
-    mov AX, [$7203]           ; int index = AX
-    push [$71FF]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mod V0, V1                ; compute modulus
-    mov AX, [$7205]           ; int bit = AX
-    push [$7201]              ; store index obj
-    push [$7203]              ; left operand
-    mov 1, V1                 ; right operand
-    pop V0                    ; get left operand back
-    sub V0, V1                ; compute subtraction
-    mov AX, V1                ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    mov [V0], [$7207]         ; int val = [V0]
-    push [$7207]              ; left operand
-    push 1                    ; left operand
-    mov [$7205], V1           ; right operand
-    pop V0                    ; get left operand back
-    shl V0, V1                ; compute left shift
-    mov DX, V1                ; right operand
-    pop V0                    ; get left operand back
-    and V0, V1                ; compute and
-    push DX                   ; left operand
-    mov 0, V1                 ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute inequality check
+_hid_getKeyState_int_scanCode:
+    pop V0
+    pop [$71FF]
+    push V0
+    mov $6033, [$7201]
+    push [$71FF]
+    mov 8, V1
+    pop V0
+    div V0, V1
+    mov AX, [$7203]
+    push [$71FF]
+    mov 8, V1
+    pop V0
+    mod V0, V1
+    mov AX, [$7205]
+    push [$7201]
+    push [$7203]
+    mov 1, V1
+    pop V0
+    sub V0, V1
+    mov AX, V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    mov [V0], [$7207]
+    push [$7207]
+    push 1
+    mov [$7205], V1
+    pop V0
+    shl V0, V1
+    mov DX, V1
+    pop V0
+    and V0, V1
+    push DX
+    mov 0, V1
+    pop V0
+    cmp V0, V1
     not
-    mov LX, V0                ; return value
+    mov LX, V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_getPressedKey:           ; int hid_getPressedKey()
-    mov 0, [$7209]            ; int sk = 0
+_hid_getPressedKey:
+    mov 0, [$7209]
 _body_1:
-    push [$7209]              ; left operand
-    mov 256, V1               ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    push [$7209]
+    mov 256, V1
+    pop V0
+    lt V0, V1
     not LX
     bz
-    jmp _end_2                ; if for condition fails, jump to end
-    push [$7209]              ; arg int scanCode
-    call _hid_getKeyState_int_scanCode; int hid_getKeyState(int scanCode)
-    cmp V0, 0                 ; logical and
+    jmp _end_2
+    push [$7209]
+    call _hid_getKeyState_int_scanCode
+    cmp V0, 0
     not
     bz
     jmp _clause_3
-    mov 0, V0                 ; first operand failed, store 0 and skip second
+    mov 0, V0
     jmp _end_4
 _clause_3:
-    push [$7209]              ; left operand
-    mov 160, V1               ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute inequality check
+    push [$7209]
+    mov 160, V1
+    pop V0
+    cmp V0, V1
     not
-    cmp LX, 0                 ; compare result from second operand to 0
+    cmp LX, 0
     not
-    mov LX, V0                ; store second operand result
+    mov LX, V0
 _end_4:
     not V0
-    bz                        ; check if condition
-    jmp _end_5                ; if succeeds, continue, else jump to end
-    mov [$7209], V0           ; return value
+    bz
+    jmp _end_5
+    mov [$7209], V0
     ret
 _end_5:
-    push [$7209]              ; i++
+    push [$7209]
     inc [$7209]
     pop V0
     jmp _body_1
 _end_2:
-    mov 0, V0                 ; return value
+    mov 0, V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_waitForPressedKey:       ; int hid_waitForPressedKey()
+_hid_waitForPressedKey:
 _body_6:
     not 1
     bz
-    jmp _end_7                ; if while condition fails, jump to end
-    call _hid_getPressedKey   ; int hid_getPressedKey()
-    mov V0, [$720B]           ; int sk = V0
-    push [$720B]              ; left operand
-    mov 0, V1                 ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute inequality check
+    jmp _end_7
+    call _hid_getPressedKey
+    mov V0, [$720B]
+    push [$720B]
+    mov 0, V1
+    pop V0
+    cmp V0, V1
     not
     not LX
-    bz                        ; check if condition
-    jmp _end_8                ; if succeeds, continue, else jump to end
-    mov [$720B], V0           ; return value
+    bz
+    jmp _end_8
+    mov [$720B], V0
     ret
 _end_8:
     jmp _body_6
 _end_7:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_getMouseIndex:           ; int hid_getMouseIndex()
-    mov $602F, V0             ; move pointer into register for dereference
-    mov [V0], V0              ; return value
+_hid_getMouseIndex:
+    mov $602F, V0
+    mov [V0], V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_getMouseState:           ; int hid_getMouseState()
-    push $602F                ; left operand
-    mov 2, V1                 ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, V0                ; move pointer into register for dereference
-    mov [V0], V0              ; return value
+_hid_getMouseState:
+    push $602F
+    mov 2, V1
+    pop V0
+    add V0, V1
+    mov AX, V0
+    mov [V0], V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_screen_setPixel_int_x__int_y__int_c:; int screen_setPixel(int x, int y, int c)
-    pop V0                    ; preserve function return address
-    pop [$720D]               ; param int x
-    pop [$720F]               ; param int y
-    pop [$7211]               ; param int c
-    push V0                   ; restore function return address
-    mov $402F, [$7213]        ; int screenStart = $402F
-    push [$720F]              ; left operand
-    mov 128, V1               ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    push AX                   ; left operand
-    mov [$720D], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, [$7215]           ; int i = AX
-    push [$7213]              ; store index obj
-    mov [$7215], V1           ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    movb [$7211], [V0]        ; [V0] = [$7211]
-    mov 0, V0                 ; fallback return 0
+_screen_setPixel_int_x__int_y__int_c:
+    pop V0
+    pop [$720D]
+    pop [$720F]
+    pop [$7211]
+    push V0
+    mov $402F, [$7213]
+    push [$720F]
+    mov 128, V1
+    pop V0
+    mul V0, V1
+    push AX
+    mov [$720D], V1
+    pop V0
+    add V0, V1
+    mov AX, [$7215]
+    push [$7213]
+    mov [$7215], V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    movb [$7211], [V0]
+    mov 0, V0
     ret
 
-_screen_setPixel_int_i__int_c:; int screen_setPixel(int i, int c)
-    pop V0                    ; preserve function return address
-    pop [$7217]               ; param int i
-    pop [$7219]               ; param int c
-    push V0                   ; restore function return address
-    mov $402F, [$721B]        ; int screenStart = $402F
-    push [$721B]              ; store index obj
-    mov [$7217], V1           ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    movb [$7219], [V0]        ; [V0] = [$7219]
-    mov 0, V0                 ; fallback return 0
+_screen_setPixel_int_i__int_c:
+    pop V0
+    pop [$7217]
+    pop [$7219]
+    push V0
+    mov $402F, [$721B]
+    push [$721B]
+    mov [$7217], V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    movb [$7219], [V0]
+    mov 0, V0
     ret
 
-_screen_clear_int_c:          ; int screen_clear(int c)
-    pop V0                    ; preserve function return address
-    pop [$721D]               ; param int c
-    push V0                   ; restore function return address
-    mov $402F, [$721F]        ; int screenStart = $402F
-    mov 0, [$7221]            ; int i = 0
+_screen_clear_int_c:
+    pop V0
+    pop [$721D]
+    push V0
+    mov $402F, [$721F]
+    mov 0, [$7221]
 _body_9:
-    push [$7221]              ; left operand
-    push 128                  ; left operand
-    mov 64, V1                ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    mov AX, V1                ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    push [$7221]
+    push 128
+    mov 64, V1
+    pop V0
+    mul V0, V1
+    mov AX, V1
+    pop V0
+    lt V0, V1
     not LX
     bz
-    jmp _end_10               ; if for condition fails, jump to end
-    push [$721F]              ; store index obj
-    mov [$7221], V1           ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    movb [$721D], [V0]        ; [V0] = [$721D]
-    push [$7221]              ; i++
+    jmp _end_10
+    push [$721F]
+    mov [$7221], V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    movb [$721D], [V0]
+    push [$7221]
     inc [$7221]
     pop V0
     jmp _body_9
 _end_10:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_main:                        ; int main()
-    mov 0, [$7223]            ; int color = 0
+_main:
+    mov 0, [$7223]
 _body_11:
     not 1
     bz
-    jmp _end_12               ; if while condition fails, jump to end
-    call _hid_getMouseIndex   ; int hid_getMouseIndex()
-    mov V0, [$7225]           ; int mouseIndex = V0
-    call _hid_getMouseState   ; int hid_getMouseState()
-    mov V0, [$7227]           ; int mouseState = V0
-    push [$7227]              ; left operand
-    mov 1, V1                 ; right operand
-    pop V0                    ; get left operand back
-    and V0, V1                ; compute and
+    jmp _end_12
+    call _hid_getMouseIndex
+    mov V0, [$7225]
+    call _hid_getMouseState
+    mov V0, [$7227]
+    push [$7227]
+    mov 1, V1
+    pop V0
+    and V0, V1
     not DX
-    bz                        ; check if condition
-    jmp _end_13               ; if succeeds, continue, else jump to end
-    push [$7223]              ; left operand
-    mov 3, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mod V0, V1                ; compute modulus
-    push AX                   ; left operand
-    mov 1, V1                 ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; arg int i
-    push [$7225]              ; arg int c
-    call _screen_setPixel_int_i__int_c; int screen_setPixel(int i, int c)
+    bz
+    jmp _end_13
+    push [$7223]
+    mov 3, V1
+    pop V0
+    mod V0, V1
+    push AX
+    mov 1, V1
+    pop V0
+    add V0, V1
+    push AX
+    push [$7225]
+    call _screen_setPixel_int_i__int_c
 _end_13:
-    push 67                   ; arg int scanCode
-    call _hid_getKeyState_int_scanCode; int hid_getKeyState(int scanCode)
+    push 67
+    call _hid_getKeyState_int_scanCode
     not V0
-    bz                        ; check if condition
-    jmp _end_14               ; if succeeds, continue, else jump to end
-    push 8                    ; arg int c
-    call _screen_clear_int_c  ; int screen_clear(int c)
+    bz
+    jmp _end_14
+    push 8
+    call _screen_clear_int_c
 _end_14:
-    push 65                   ; arg int scanCode
-    call _hid_getKeyState_int_scanCode; int hid_getKeyState(int scanCode)
+    push 65
+    call _hid_getKeyState_int_scanCode
     not V0
-    bz                        ; check if condition
-    jmp _end_15               ; if succeeds, continue, else jump to end
-    push [$7223]              ; i++
+    bz
+    jmp _end_15
+    push [$7223]
     inc [$7223]
     pop V0
 _body_16:
-    push 65                   ; arg int scanCode
-    call _hid_getKeyState_int_scanCode; int hid_getKeyState(int scanCode)
+    push 65
+    call _hid_getKeyState_int_scanCode
     not V0
     bz
-    jmp _end_17               ; if while condition fails, jump to end
+    jmp _end_17
     jmp _body_16
 _end_17:
 _end_15:
     jmp _body_11
 _end_12:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
diff --git a/ROMs/typewriter.asm b/ROMs/typewriter.asm
index 8b8338a..a2369c3 100644
--- a/ROMs/typewriter.asm
+++ b/ROMs/typewriter.asm
@@ -1,478 +1,461 @@
     jmp _main
     .include "font.bin"
-_screen_setPixel_int_x__int_y__int_c:; int screen_setPixel(int x, int y, int c)
-    pop V0                    ; preserve function return address
-    pop [$71FF]               ; param int x
-    pop [$7201]               ; param int y
-    pop [$7203]               ; param int c
-    push V0                   ; restore function return address
-    mov $402F, [$7205]        ; int screenStart = $402F
-    push [$7201]              ; left operand
-    mov 128, V1               ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    push AX                   ; left operand
-    mov [$71FF], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, [$7207]           ; int i = AX
-    push [$7205]              ; store index obj
-    mov [$7207], V1           ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    movb [$7203], [V0]        ; [V0] = [$7203]
-    mov 0, V0                 ; fallback return 0
+_screen_setPixel_int_x__int_y__int_c:
+    pop V0
+    pop [$71FF]
+    pop [$7201]
+    pop [$7203]
+    push V0
+    mov $402F, [$7205]
+    push [$7201]
+    mov 128, V1
+    pop V0
+    mul V0, V1
+    push AX
+    mov [$71FF], V1
+    pop V0
+    add V0, V1
+    mov AX, [$7207]
+    push [$7205]
+    mov [$7207], V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    movb [$7203], [V0]
+    mov 0, V0
     ret
 
-_screen_setPixel_int_i__int_c:; int screen_setPixel(int i, int c)
-    pop V0                    ; preserve function return address
-    pop [$7209]               ; param int i
-    pop [$720B]               ; param int c
-    push V0                   ; restore function return address
-    mov $402F, [$720D]        ; int screenStart = $402F
-    push [$720D]              ; store index obj
-    mov [$7209], V1           ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    movb [$720B], [V0]        ; [V0] = [$720B]
-    mov 0, V0                 ; fallback return 0
+_screen_setPixel_int_i__int_c:
+    pop V0
+    pop [$7209]
+    pop [$720B]
+    push V0
+    mov $402F, [$720D]
+    push [$720D]
+    mov [$7209], V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    movb [$720B], [V0]
+    mov 0, V0
     ret
 
-_screen_clear_int_c:          ; int screen_clear(int c)
-    pop V0                    ; preserve function return address
-    pop [$720F]               ; param int c
-    push V0                   ; restore function return address
-    mov $402F, [$7211]        ; int screenStart = $402F
-    mov 0, [$7213]            ; int i = 0
+_screen_clear_int_c:
+    pop V0
+    pop [$720F]
+    push V0
+    mov $402F, [$7211]
+    mov 0, [$7213]
 _body_1:
-    push [$7213]              ; left operand
-    push 128                  ; left operand
-    mov 64, V1                ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    mov AX, V1                ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    push [$7213]
+    push 128
+    mov 64, V1
+    pop V0
+    mul V0, V1
+    mov AX, V1
+    pop V0
+    lt V0, V1
     not LX
     bz
-    jmp _end_2                ; if for condition fails, jump to end
-    push [$7211]              ; store index obj
-    mov [$7213], V1           ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    movb [$720F], [V0]        ; [V0] = [$720F]
-    push [$7213]              ; i++
+    jmp _end_2
+    push [$7211]
+    mov [$7213], V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    movb [$720F], [V0]
+    push [$7213]
     inc [$7213]
     pop V0
     jmp _body_1
 _end_2:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_getKeyState_int_scanCode:; int hid_getKeyState(int scanCode)
-    pop V0                    ; preserve function return address
-    pop [$7215]               ; param int scanCode
-    push V0                   ; restore function return address
-    mov $6033, [$7217]        ; int sk_table = $6033
-    push [$7215]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    div V0, V1                ; compute division
-    mov AX, [$7219]           ; int index = AX
-    push [$7215]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mod V0, V1                ; compute modulus
-    mov AX, [$721B]           ; int bit = AX
-    push [$7217]              ; store index obj
-    push [$7219]              ; left operand
-    mov 1, V1                 ; right operand
-    pop V0                    ; get left operand back
-    sub V0, V1                ; compute subtraction
-    mov AX, V1                ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    mov [V0], [$721D]         ; int val = [V0]
-    push [$721D]              ; left operand
-    push 1                    ; left operand
-    mov [$721B], V1           ; right operand
-    pop V0                    ; get left operand back
-    shl V0, V1                ; compute left shift
-    mov DX, V1                ; right operand
-    pop V0                    ; get left operand back
-    and V0, V1                ; compute and
-    push DX                   ; left operand
-    mov 0, V1                 ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute inequality check
+_hid_getKeyState_int_scanCode:
+    pop V0
+    pop [$7215]
+    push V0
+    mov $6033, [$7217]
+    push [$7215]
+    mov 8, V1
+    pop V0
+    div V0, V1
+    mov AX, [$7219]
+    push [$7215]
+    mov 8, V1
+    pop V0
+    mod V0, V1
+    mov AX, [$721B]
+    push [$7217]
+    push [$7219]
+    mov 1, V1
+    pop V0
+    sub V0, V1
+    mov AX, V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    mov [V0], [$721D]
+    push [$721D]
+    push 1
+    mov [$721B], V1
+    pop V0
+    shl V0, V1
+    mov DX, V1
+    pop V0
+    and V0, V1
+    push DX
+    mov 0, V1
+    pop V0
+    cmp V0, V1
     not
-    mov LX, V0                ; return value
+    mov LX, V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_getPressedKey:           ; int hid_getPressedKey()
-    mov 0, [$721F]            ; int sk = 0
+_hid_getPressedKey:
+    mov 0, [$721F]
 _body_3:
-    push [$721F]              ; left operand
-    mov 256, V1               ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    push [$721F]
+    mov 256, V1
+    pop V0
+    lt V0, V1
     not LX
     bz
-    jmp _end_4                ; if for condition fails, jump to end
-    push [$721F]              ; arg int scanCode
-    call _hid_getKeyState_int_scanCode; int hid_getKeyState(int scanCode)
-    cmp V0, 0                 ; logical and
+    jmp _end_4
+    push [$721F]
+    call _hid_getKeyState_int_scanCode
+    cmp V0, 0
     not
     bz
     jmp _clause_5
-    mov 0, V0                 ; first operand failed, store 0 and skip second
+    mov 0, V0
     jmp _end_6
 _clause_5:
-    push [$721F]              ; left operand
-    mov 160, V1               ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute inequality check
+    push [$721F]
+    mov 160, V1
+    pop V0
+    cmp V0, V1
     not
-    cmp LX, 0                 ; compare result from second operand to 0
+    cmp LX, 0
     not
-    mov LX, V0                ; store second operand result
+    mov LX, V0
 _end_6:
     not V0
-    bz                        ; check if condition
-    jmp _end_7                ; if succeeds, continue, else jump to end
-    mov [$721F], V0           ; return value
+    bz
+    jmp _end_7
+    mov [$721F], V0
     ret
 _end_7:
-    push [$721F]              ; i++
+    push [$721F]
     inc [$721F]
     pop V0
     jmp _body_3
 _end_4:
-    mov 0, V0                 ; return value
+    mov 0, V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_waitForPressedKey:       ; int hid_waitForPressedKey()
+_hid_waitForPressedKey:
 _body_8:
     not 1
     bz
-    jmp _end_9                ; if while condition fails, jump to end
-    call _hid_getPressedKey   ; int hid_getPressedKey()
-    mov V0, [$7221]           ; int sk = V0
-    push [$7221]              ; left operand
-    mov 0, V1                 ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute inequality check
+    jmp _end_9
+    call _hid_getPressedKey
+    mov V0, [$7221]
+    push [$7221]
+    mov 0, V1
+    pop V0
+    cmp V0, V1
     not
     not LX
-    bz                        ; check if condition
-    jmp _end_10               ; if succeeds, continue, else jump to end
-    mov [$7221], V0           ; return value
+    bz
+    jmp _end_10
+    mov [$7221], V0
     ret
 _end_10:
     jmp _body_8
 _end_9:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_getMouseIndex:           ; int hid_getMouseIndex()
-    mov $602F, V0             ; move pointer into register for dereference
-    mov [V0], V0              ; return value
+_hid_getMouseIndex:
+    mov $602F, V0
+    mov [V0], V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_hid_getMouseState:           ; int hid_getMouseState()
-    push $602F                ; left operand
-    mov 2, V1                 ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, V0                ; move pointer into register for dereference
-    mov [V0], V0              ; return value
+_hid_getMouseState:
+    push $602F
+    mov 2, V1
+    pop V0
+    add V0, V1
+    mov AX, V0
+    mov [V0], V0
     ret
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_drawChar_int_ch__int_x__int_y__int_color:; int drawChar(int ch, int x, int y, int color)
-    pop V0                    ; preserve function return address
-    pop [$7223]               ; param int ch
-    pop [$7225]               ; param int x
-    pop [$7227]               ; param int y
-    pop [$7229]               ; param int color
-    push V0                   ; restore function return address
+_drawChar_int_ch__int_x__int_y__int_color:
+    pop V0
+    pop [$7223]
+    pop [$7225]
+    pop [$7227]
+    pop [$7229]
+    push V0
     ; adjust for jmp instruction
-    push $1FFF                ; left operand
-    mov 2, V1                 ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, [$722B]           ; int fontStart = AX
-    push [$7223]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    mov AX, [$722D]           ; int charStart = AX
-    mov 0, [$722F]            ; int yOff = 0
+    push $1FFF
+    mov 2, V1
+    pop V0
+    add V0, V1
+    mov AX, [$722B]
+    push [$7223]
+    mov 8, V1
+    pop V0
+    mul V0, V1
+    mov AX, [$722D]
+    mov 0, [$722F]
 _body_11:
-    push [$722F]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    push [$722F]
+    mov 8, V1
+    pop V0
+    lt V0, V1
     not LX
     bz
-    jmp _end_12               ; if for condition fails, jump to end
-    push [$722B]              ; store index obj
-    push [$722D]              ; left operand
-    mov [$722F], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, V1                ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 1                 ; multiply indexer by 1
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    mov [V0], [$7231]         ; int row = [V0]
-    mov 0, [$7233]            ; int xOff = 0
+    jmp _end_12
+    push [$722B]
+    push [$722D]
+    mov [$722F], V1
+    pop V0
+    add V0, V1
+    mov AX, V1
+    pop V0
+    mul V1, 1
+    add AX, V0
+    mov AX, V0
+    mov [V0], [$7231]
+    mov 0, [$7233]
 _body_13:
-    push [$7233]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    push [$7233]
+    mov 8, V1
+    pop V0
+    lt V0, V1
     not LX
     bz
-    jmp _end_14               ; if for condition fails, jump to end
-    push [$7231]              ; left operand
-    push 7                    ; left operand
-    mov [$7233], V1           ; right operand
-    pop V0                    ; get left operand back
-    sub V0, V1                ; compute subtraction
-    mov AX, V1                ; right operand
-    pop V0                    ; get left operand back
-    shr V0, V1                ; compute right shift
-    push DX                   ; left operand
-    mov 1, V1                 ; right operand
-    pop V0                    ; get left operand back
-    and V0, V1                ; compute and
-    mov DX, [$7235]           ; int bit = DX
-    bz [$7235]                ; check ternary condition
+    jmp _end_14
+    push [$7231]
+    push 7
+    mov [$7233], V1
+    pop V0
+    sub V0, V1
+    mov AX, V1
+    pop V0
+    shr V0, V1
+    push DX
+    mov 1, V1
+    pop V0
+    and V0, V1
+    mov DX, [$7235]
+    bz [$7235]
     jmp _then_15
-    mov [$7229], V0           ; store ternary fail result
+    mov [$7229], V0
     jmp _end_16
 _then_15:
-    mov 8, V0                 ; store ternary success result
+    mov 8, V0
 _end_16:
-    mov V0, [$7237]           ; int pix = V0
-    push [$7237]              ; arg int x
-    push [$7227]              ; left operand
-    mov [$722F], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; arg int y
-    push [$7225]              ; left operand
-    mov [$7233], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; arg int c
-    call _screen_setPixel_int_x__int_y__int_c; int screen_setPixel(int x, int y, int c)
-    push [$7233]              ; i++
+    mov V0, [$7237]
+    push [$7237]
+    push [$7227]
+    mov [$722F], V1
+    pop V0
+    add V0, V1
+    push AX
+    push [$7225]
+    mov [$7233], V1
+    pop V0
+    add V0, V1
+    push AX
+    call _screen_setPixel_int_x__int_y__int_c
+    push [$7233]
     inc [$7233]
     pop V0
     jmp _body_13
 _end_14:
-    push [$722F]              ; i++
+    push [$722F]
     inc [$722F]
     pop V0
     jmp _body_11
 _end_12:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_print_int*_text__int_len__int_x__int_y__int_color:; int print(int* text, int len, int x, int y, int color)
-    pop V0                    ; preserve function return address
-    pop [$7239]               ; param int* text
-    pop [$723B]               ; param int len
-    pop [$723D]               ; param int x
-    pop [$723F]               ; param int y
-    pop [$7241]               ; param int color
-    push V0                   ; restore function return address
-    mov 0, [$7243]            ; int i = 0
+_print_int*_text__int_len__int_x__int_y__int_color:
+    pop V0
+    pop [$7239]
+    pop [$723B]
+    pop [$723D]
+    pop [$723F]
+    pop [$7241]
+    push V0
+    mov 0, [$7243]
 _body_17:
-    push [$7243]              ; left operand
-    mov [$723B], V1           ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    push [$7243]
+    mov [$723B], V1
+    pop V0
+    lt V0, V1
     not LX
     bz
-    jmp _end_18               ; if for condition fails, jump to end
-    push [$7239]              ; store index obj
-    mov [$7243], V1           ; store indexer
-    pop V0                    ; restore index obj
-    mul V1, 2                 ; multiply indexer by 2
-    add AX, V0                ; add indexer and index obj
-    mov AX, V0                ; move to general purpose register
-    mov [V0], [$7245]         ; int ch = [V0]
-    push [$7241]              ; arg int ch
-    push [$723F]              ; arg int x
-    push [$723D]              ; left operand
-    push [$7243]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    mov AX, V1                ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; arg int y
-    push [$7245]              ; arg int color
-    call _drawChar_int_ch__int_x__int_y__int_color; int drawChar(int ch, int x, int y, int color)
-    push [$7243]              ; i++
+    jmp _end_18
+    push [$7239]
+    mov [$7243], V1
+    pop V0
+    mul V1, 2
+    add AX, V0
+    mov AX, V0
+    mov [V0], [$7245]
+    push [$7241]
+    push [$723F]
+    push [$723D]
+    push [$7243]
+    mov 8, V1
+    pop V0
+    mul V0, V1
+    mov AX, V1
+    pop V0
+    add V0, V1
+    push AX
+    push [$7245]
+    call _drawChar_int_ch__int_x__int_y__int_color
+    push [$7243]
     inc [$7243]
     pop V0
     jmp _body_17
 _end_18:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
-_main:                        ; int main()
-    mov 0, [$7247]            ; int x = 0
-    mov 0, [$7249]            ; int y = 0
+_main:
+    mov 0, [$7247]
+    mov 0, [$7249]
 _body_19:
     not 1
     bz
-    jmp _end_20               ; if while condition fails, jump to end
-    push [$7247]              ; left operand
-    mov 128, V1               ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute equality check
+    jmp _end_20
+    push [$7247]
+    mov 128, V1
+    pop V0
+    cmp V0, V1
     bz
     jmp _end_21
     gt V0, V1
 _end_21:
     not LX
-    bz                        ; check if condition
-    jmp _end_22               ; if succeeds, continue, else jump to end
-    mov 0, [$7247]            ; [$7247] = 0
-    push [$7249]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; computation results
-    pop V1                    ; get computation results back
-    mov V1, [$7249]           ; store back into left param
+    bz
+    jmp _end_22
+    mov 0, [$7247]
+    push [$7249]
+    mov 8, V1
+    pop V0
+    add V0, V1
+    push AX
+    pop V1
+    mov V1, [$7249]
 _end_22:
-    push [$7249]              ; left operand
-    mov 64, V1                ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute equality check
+    push [$7249]
+    mov 64, V1
+    pop V0
+    cmp V0, V1
     bz
     jmp _end_23
     gt V0, V1
 _end_23:
     not LX
-    bz                        ; check if condition
-    jmp _end_24               ; if succeeds, continue, else jump to end
-    mov 0, [$7247]            ; [$7247] = 0
-    mov 0, [$7249]            ; [$7249] = 0
-    push 8                    ; arg int c
-    call _screen_clear_int_c  ; int screen_clear(int c)
+    bz
+    jmp _end_24
+    mov 0, [$7247]
+    mov 0, [$7249]
+    push 8
+    call _screen_clear_int_c
 _end_24:
-    call _hid_waitForPressedKey; int hid_waitForPressedKey()
-    mov V0, [$724B]           ; int sk = V0
+    call _hid_waitForPressedKey
+    mov V0, [$724B]
 _body_25:
-    push [$724B]              ; arg int scanCode
-    call _hid_getKeyState_int_scanCode; int hid_getKeyState(int scanCode)
+    push [$724B]
+    call _hid_getKeyState_int_scanCode
     not V0
     bz
-    jmp _end_26               ; if while condition fails, jump to end
+    jmp _end_26
     jmp _body_25
 _end_26:
-    push [$724B]              ; left operand
-    mov 13, V1                ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute equality check
+    push [$724B]
+    mov 13, V1
+    pop V0
+    cmp V0, V1
     not LX
-    bz                        ; check if condition
-    jmp _end_27               ; if succeeds, continue, else jump to end
-    push [$7249]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; computation results
-    pop V1                    ; get computation results back
-    mov V1, [$7249]           ; store back into left param
-    mov 0, [$7247]            ; [$7247] = 0
-    jmp _body_19              ; continue
+    bz
+    jmp _end_27
+    push [$7249]
+    mov 8, V1
+    pop V0
+    add V0, V1
+    push AX
+    pop V1
+    mov V1, [$7249]
+    mov 0, [$7247]
+    jmp _body_19
 _end_27:
-    push [$724B]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute equality check
+    push [$724B]
+    mov 8, V1
+    pop V0
+    cmp V0, V1
     not LX
-    bz                        ; check if condition
-    jmp _end_28               ; if succeeds, continue, else jump to end
-    push [$7247]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    sub V0, V1                ; compute subtraction
-    push AX                   ; computation results
-    pop V1                    ; get computation results back
-    mov V1, [$7247]           ; store back into left param
-    push [$7247]              ; left operand
-    mov 0, V1                 ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
+    bz
+    jmp _end_28
+    push [$7247]
+    mov 8, V1
+    pop V0
+    sub V0, V1
+    push AX
+    pop V1
+    mov V1, [$7247]
+    push [$7247]
+    mov 0, V1
+    pop V0
+    lt V0, V1
     not LX
-    bz                        ; check if condition
-    jmp _end_29               ; if succeeds, continue, else jump to end
-    mov 0, [$7247]            ; [$7247] = 0
+    bz
+    jmp _end_29
+    mov 0, [$7247]
 _end_29:
-    push 1                    ; arg int ch
-    push [$7249]              ; arg int x
-    push [$7247]              ; arg int y
-    push 32                   ; arg int color
-    call _drawChar_int_ch__int_x__int_y__int_color; int drawChar(int ch, int x, int y, int color)
-    jmp _body_19              ; continue
+    push 1
+    push [$7249]
+    push [$7247]
+    push 32
+    call _drawChar_int_ch__int_x__int_y__int_color
+    jmp _body_19
 _end_28:
-    push 160                  ; arg int scanCode
-    call _hid_getKeyState_int_scanCode; int hid_getKeyState(int scanCode)
-    not V0
-    bz                        ; check if condition
-    jmp _end_30               ; if succeeds, continue, else jump to end
-    push [$724B]              ; left operand
-    push 97                   ; left operand
-    mov 65, V1                ; right operand
-    pop V0                    ; get left operand back
-    sub V0, V1                ; compute subtraction
-    mov AX, V1                ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; computation results
-    pop V1                    ; get computation results back
-    mov V1, [$724B]           ; store back into left param
-_end_30:
-    push 1                    ; arg int ch
-    push [$7249]              ; arg int x
-    push [$7247]              ; arg int y
-    push [$724B]              ; arg int color
-    call _drawChar_int_ch__int_x__int_y__int_color; int drawChar(int ch, int x, int y, int color)
-    push [$7247]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; computation results
-    pop V1                    ; get computation results back
-    mov V1, [$7247]           ; store back into left param
+    push 1
+    push [$7249]
+    push [$7247]
+    push [$724B]
+    call _drawChar_int_ch__int_x__int_y__int_color
+    push [$7247]
+    mov 8, V1
+    pop V0
+    add V0, V1
+    push AX
+    pop V1
+    mov V1, [$7247]
     jmp _body_19
 _end_20:
-    mov 0, V0                 ; fallback return 0
+    mov 0, V0
     ret
 
diff --git a/ROMs/typewriter.c b/ROMs/typewriter.c
index 278e048..df8f3b7 100644
--- a/ROMs/typewriter.c
+++ b/ROMs/typewriter.c
@@ -68,9 +68,6 @@ int main()
             drawChar(' ', x, y, 1);
             continue;
         }
-
-        if (hid_getKeyState(SK_SHIFT))
-            sk += ('a' - 'A');
         
         drawChar(sk, x, y, COLOR_RED);
         x += 8;
diff --git a/ROMs/typewriter.q1 b/ROMs/typewriter.q1
index 82d8114..163bb6f 100644
--- a/ROMs/typewriter.q1
+++ b/ROMs/typewriter.q1