changes

5 files changed, 168 insertions, 634 deletions

diff --git a/ROMs/hello_c.asm b/ROMs/hello_c.asm
index da648b6..16eb6bc 100644
--- a/ROMs/hello_c.asm
+++ b/ROMs/hello_c.asm
@@ -1,160 +1,160 @@
     jmp _main
-    .include "ROMs/font.bin"
-_drawChar_int_ch__int_x__int_y__int_color:
-    pop V0
-    pop [$71FF]
-    pop [$7201]
-    pop [$7203]
-    pop [$7205]
-    push V0
+    .include "font.bin"
+_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 [$71FF]               ; param int ch
+    pop [$7201]               ; param int x
+    pop [$7203]               ; param int y
+    pop [$7205]               ; param int color
+    push V0                   ; restore function return address
     ; adjust for jmp instruction
-    push $1FFF
-    mov 2, V1
-    pop V0
-    add V0, V1
-    mov AX, [$7207]
-    push [$71FF]
-    mov 8, V1
-    pop V0
-    mul V0, V1
-    mov AX, [$7209]
-    mov 0, [$720B]
+    push $1FFF                ; left operand
+    mov 2, V1                 ; right operand
+    pop V0                    ; get left operand back
+    add V0, V1                ; compute addition
+    mov AX, [$7207]           ; int fontStart = AX
+    push [$71FF]              ; left operand
+    mov 8, V1                 ; right operand
+    pop V0                    ; get left operand back
+    mul V0, V1                ; compute multiplication
+    mov AX, [$7209]           ; int charStart = AX
+    mov 0, [$720B]            ; int yOff = 0
 _body_1:
-    push [$720B]
-    mov 8, V1
-    pop V0
-    lt V0, V1
+    push [$720B]              ; left operand
+    mov 8, V1                 ; right operand
+    pop V0                    ; get left operand back
+    lt V0, V1                 ; compute less than check
     not LX
     bz
-    jmp _end_2
-    push [$7207]
-    push [$7209]
-    mov [$720B], V1
-    pop V0
-    add V0, V1
-    mov AX, V1
-    pop V0
-    mul V1, 1
-    add AX, V0
-    mov AX, V0
-    mov [V0], [$720D]
-    mov 0, [$720F]
+    jmp _end_2                ; if for condition fails, jump to end
+    push [$7207]              ; store index obj
+    push [$7209]              ; left operand
+    mov [$720B], 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], [$720D]         ; int row = [V0]
+    mov 0, [$720F]            ; int xOff = 0
 _body_3:
-    push [$720F]
-    mov 8, V1
-    pop V0
-    lt V0, V1
+    push [$720F]              ; left operand
+    mov 8, V1                 ; right operand
+    pop V0                    ; get left operand back
+    lt V0, V1                 ; compute less than check
     not LX
     bz
-    jmp _end_4
-    push [$720D]
-    push 7
-    mov [$720F], 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, [$7211]
-    bz [$7211]
+    jmp _end_4                ; if for condition fails, jump to end
+    push [$720D]              ; left operand
+    push 7                    ; left operand
+    mov [$720F], 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, [$7211]           ; int bit = DX
+    bz [$7211]                ; check ternary condition
     jmp _then_5
-    mov [$7205], V0
+    mov [$7205], V0           ; store ternary fail result
     jmp _end_6
 _then_5:
-    mov 0, V0
+    mov 0, V0                 ; store ternary success result
 _end_6:
-    mov V0, [$7213]
-    push [$7213]
-    push [$7203]
-    mov [$720B], V1
-    pop V0
-    add V0, V1
-    push AX
-    push [$7201]
-    mov [$720F], V1
-    pop V0
-    add V0, V1
-    push AX
-    call _setPixel_int_x__int_y__int_c
-    push [$720F]
+    mov V0, [$7213]           ; int pix = V0
+    push [$7213]              ; arg int c
+    push [$7203]              ; left operand
+    mov [$720B], V1           ; right operand
+    pop V0                    ; get left operand back
+    add V0, V1                ; compute addition
+    push AX                   ; arg int y
+    push [$7201]              ; left operand
+    mov [$720F], V1           ; right operand
+    pop V0                    ; get left operand back
+    add V0, V1                ; compute addition
+    push AX                   ; arg int x
+    call _setPixel_int_x__int_y__int_c; int setPixel(int x, int y, int c)
+    push [$720F]              ; i++
     inc [$720F]
     pop V0
     jmp _body_3
 _end_4:
-    push [$720B]
+    push [$720B]              ; i++
     inc [$720B]
     pop V0
     jmp _body_1
 _end_2:
-    mov 0, V0
+    mov 0, V0                 ; fallback return 0
     ret
 
-_setPixel_int_x__int_y__int_c:
-    pop V0
-    pop [$7215]
-    pop [$7217]
-    pop [$7219]
-    push V0
-    mov $402F, [$721B]
-    push [$7217]
-    mov 128, V1
-    pop V0
-    mul V0, V1
-    push AX
-    mov [$7215], V1
-    pop V0
-    add V0, V1
-    mov AX, [$721D]
-    push [$721B]
-    mov [$721D], V1
-    pop V0
-    mul V1, 1
-    add AX, V0
-    mov AX, V0
-    movb [$7219], [V0]
-    mov 0, V0
+_setPixel_int_x__int_y__int_c:; int setPixel(int x, int y, int c)
+    pop V0                    ; preserve function return address
+    pop [$7215]               ; param int x
+    pop [$7217]               ; param int y
+    pop [$7219]               ; param int c
+    push V0                   ; restore function return address
+    mov $402F, [$721B]        ; int screenStart = $402F
+    push [$7217]              ; left operand
+    mov 128, V1               ; right operand
+    pop V0                    ; get left operand back
+    mul V0, V1                ; compute multiplication
+    push AX                   ; left operand
+    mov [$7215], V1           ; right operand
+    pop V0                    ; get left operand back
+    add V0, V1                ; compute addition
+    mov AX, [$721D]           ; int i = AX
+    push [$721B]              ; store index obj
+    mov [$721D], 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
     ret
 
-_clear_int_c:
-    pop V0
-    pop [$721F]
-    push V0
-    mov $402F, [$7221]
-    push 64
-    mov 128, V1
-    pop V0
-    mul V0, V1
-    mov AX, [$7223]
-    mov 0, [$7225]
+_clear_int_c:                 ; int clear(int c)
+    pop V0                    ; preserve function return address
+    pop [$721F]               ; param int c
+    push V0                   ; restore function return address
+    mov $402F, [$7221]        ; int screenStart = $402F
+    push 64                   ; left operand
+    mov 128, V1               ; right operand
+    pop V0                    ; get left operand back
+    mul V0, V1                ; compute multiplication
+    mov AX, [$7223]           ; int screenSize = AX
+    mov 0, [$7225]            ; int i = 0
 _body_7:
-    push [$7225]
-    mov [$7223], V1
-    pop V0
-    lt V0, V1
+    push [$7225]              ; left operand
+    mov [$7223], V1           ; right operand
+    pop V0                    ; get left operand back
+    lt V0, V1                 ; compute less than check
     not LX
     bz
-    jmp _end_8
-    push [$7221]
-    mov [$7225], V1
-    pop V0
-    mul V1, 1
-    add AX, V0
-    mov AX, V0
-    movb [$721F], [V0]
-    push [$7225]
+    jmp _end_8                ; if for condition fails, jump to end
+    push [$7221]              ; store index obj
+    mov [$7225], 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 [$721F], [V0]        ; [V0] = [$721F]
+    push [$7225]              ; i++
     inc [$7225]
     pop V0
     jmp _body_7
 _end_8:
-    mov 0, V0
+    mov 0, V0                 ; fallback return 0
     ret
 
-_main:
-    mov 1, [$7227]
+_main:                        ; int main()
+    mov 1, [$7227]            ; int color = 1
     mov 72, [$722B]
     mov 69, [$722D]
     mov 76, [$722F]
@@ -167,49 +167,49 @@ _main:
     mov 76, [$723D]
     mov 68, [$723F]
     mov 33, [$7241]
-    mov $722B, [$7229]
-    mov 12, [$7243]
-    push 0
-    call _clear_int_c
+    mov $722B, [$7229]        ; int text = $722B
+    mov 12, [$7243]           ; int len = 12
+    push 0                    ; arg int c
+    call _clear_int_c         ; int clear(int c)
 _body_9:
     not 1
     bz
-    jmp _end_10
-    mov 0, [$7245]
+    jmp _end_10               ; if while condition fails, jump to end
+    mov 0, [$7245]            ; int i = 0
 _body_11:
-    push [$7245]
-    mov [$7243], V1
-    pop V0
-    lt V0, V1
+    push [$7245]              ; left operand
+    mov [$7243], V1           ; right operand
+    pop V0                    ; get left operand back
+    lt V0, V1                 ; compute less than check
     not LX
     bz
-    jmp _end_12
-    push [$7229]
-    mov [$7245], V1
-    pop V0
-    mul V1, 2
-    add AX, V0
-    mov AX, V0
-    mov [V0], [$7247]
-    push [$7227]
-    push 0
-    push [$7245]
-    mov 8, V1
-    pop V0
-    mul V0, V1
-    push AX
-    push [$7247]
-    call _drawChar_int_ch__int_x__int_y__int_color
-    push [$7245]
+    jmp _end_12               ; if for condition fails, jump to end
+    push [$7229]              ; store index obj
+    mov [$7245], 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], [$7247]         ; int ch = [V0]
+    push [$7227]              ; arg int color
+    push 0                    ; arg int y
+    push [$7245]              ; left operand
+    mov 8, V1                 ; right operand
+    pop V0                    ; get left operand back
+    mul V0, V1                ; compute multiplication
+    push AX                   ; arg int x
+    push [$7247]              ; arg int ch
+    call _drawChar_int_ch__int_x__int_y__int_color; int drawChar(int ch, int x, int y, int color)
+    push [$7245]              ; i++
     inc [$7245]
     pop V0
     jmp _body_11
 _end_12:
-    push [$7227]
+    push [$7227]              ; i++
     inc [$7227]
     pop V0
     jmp _body_9
 _end_10:
-    mov 0, V0
+    mov 0, V0                 ; fallback return 0
     ret
 
diff --git a/ROMs/life.asm b/ROMs/life.asm
deleted file mode 100644
index d5250a0..0000000
--- a/ROMs/life.asm
+++ /dev/null
@@ -1,404 +0,0 @@
-    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
-    not
-    mov LX, V0                ; return value
-    ret
-    mov 0, V0                 ; fallback return 0
-    ret
-
-_hid_getPressedKey:           ; int hid_getPressedKey()
-    mov 0, [$7209]            ; int sk = 0
-_body_1:
-    push [$7209]              ; left operand
-    mov 256, V1               ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
-    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
-    not
-    bz
-    jmp _clause_3
-    mov 0, V0                 ; first operand failed, store 0 and skip second
-    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
-    not
-    cmp LX, 0                 ; compare result from second operand to 0
-    not
-    mov LX, V0                ; store second operand result
-_end_4:
-    not V0
-    bz                        ; check if condition
-    jmp _end_5                ; if succeeds, continue, else jump to end
-    mov [$7209], V0           ; return value
-    ret
-_end_5:
-    push [$7209]              ; i++
-    inc [$7209]
-    pop V0
-    jmp _body_1
-_end_2:
-    mov 0, V0                 ; return value
-    ret
-    mov 0, V0                 ; fallback return 0
-    ret
-
-_hid_waitForPressedKey:       ; int 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
-    not
-    not LX
-    bz                        ; check if condition
-    jmp _end_8                ; if succeeds, continue, else jump to end
-    mov [$720B], V0           ; return value
-    ret
-_end_8:
-    jmp _body_6
-_end_7:
-    mov 0, V0                 ; fallback return 0
-    ret
-
-_hid_getMouseIndex:           ; int hid_getMouseIndex()
-    mov $602F, V0             ; move pointer into register for dereference
-    mov [V0], V0              ; return value
-    ret
-    mov 0, V0                 ; fallback return 0
-    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
-    ret
-    mov 0, V0                 ; fallback return 0
-    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
-    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
-    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
-_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
-    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++
-    inc [$7221]
-    pop V0
-    jmp _body_9
-_end_10:
-    mov 0, V0                 ; fallback return 0
-    ret
-
-_getState_char*_grid__int_index:; char getState(char* grid, int index)
-    pop V0                    ; preserve function return address
-    pop [$7223]               ; param char* grid
-    pop [$7225]               ; param int index
-    push V0                   ; restore function return address
-    push [$7225]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    div V0, V1                ; compute division
-    mov AX, [$7227]           ; int byteIndex = AX
-    push [$7225]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mod V0, V1                ; compute modulus
-    mov AX, [$7229]           ; int bitIndex = AX
-    push [$7223]              ; store index obj
-    mov [$7227], 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], [$722B]         ; int byte = [V0]
-    push [$722B]              ; left operand
-    mov [$7229], 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
-    push DX                   ; left operand
-    mov 0, V1                 ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute inequality check
-    not
-    mov LX, V0                ; return value
-    ret
-    mov 0, V0                 ; fallback return 0
-    ret
-
-_setState_char*_grid__int_index__int_state:; int setState(char* grid, int index, int state)
-    pop V0                    ; preserve function return address
-    pop [$722D]               ; param char* grid
-    pop [$722F]               ; param int index
-    pop [$7231]               ; param int state
-    push V0                   ; restore function return address
-    push [$722F]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    div V0, V1                ; compute division
-    mov AX, [$7233]           ; int byteIndex = AX
-    push [$722F]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mod V0, V1                ; compute modulus
-    mov AX, [$7235]           ; int bitIndex = AX
-    push [$722D]              ; store index obj
-    mov [$7233], 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], [$7237]         ; int byte = [V0]
-    bz [$7231]                ; check if condition
-    jmp _then_12
-                              ; if failed
-    push [$7237]              ; left operand
-    push 1                    ; left operand
-    mov [$7235], V1           ; right operand
-    pop V0                    ; get left operand back
-    shl V0, V1                ; compute left shift
-    inv DX
-    mov DX, V1                ; right operand
-    pop V0                    ; get left operand back
-    and V0, V1                ; compute and
-    push DX                   ; computation results
-    pop V1                    ; get computation results back
-    mov V1, [$7237]           ; store back into left param
-    jmp _end_11
-_then_12:                     ; if succeeded
-    push [$7237]              ; left operand
-    push 1                    ; left operand
-    mov [$7235], 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
-    or V0, V1                 ; compute or
-    push DX                   ; computation results
-    pop V1                    ; get computation results back
-    mov V1, [$7237]           ; store back into left param
-_end_11:
-    push [$722D]              ; store index obj
-    mov [$7233], 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 [$7237], [V0]        ; [V0] = [$7237]
-    mov 0, V0                 ; fallback return 0
-    ret
-
-_drawGrid_char*_grid:         ; int drawGrid(char* grid)
-    pop V0                    ; preserve function return address
-    pop [$7239]               ; param char* grid
-    push V0                   ; restore function return address
-    push 8                    ; arg int c
-    call _screen_clear_int_c  ; int screen_clear(int c)
-    mov 0, [$723B]            ; int y = 0
-_body_13:
-    push [$723B]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
-    not LX
-    bz
-    jmp _end_14               ; if for condition fails, jump to end
-    mov 0, [$723D]            ; int x = 0
-_body_15:
-    push [$723D]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
-    not LX
-    bz
-    jmp _end_16               ; if for condition fails, jump to end
-    push [$723B]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    push AX                   ; left operand
-    mov [$723D], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, [$723F]           ; int index = AX
-    push [$723F]              ; arg int index
-    push [$7239]              ; arg char* grid
-    call _getState_char*_grid__int_index; char getState(char* grid, int index)
-    not V0
-    bz                        ; check if condition
-    jmp _end_17               ; if succeeds, continue, else jump to end
-    push 7                    ; arg int c
-    push [$723B]              ; arg int y
-    push [$723D]              ; arg int x
-    call _screen_setPixel_int_x__int_y__int_c; int screen_setPixel(int x, int y, int c)
-_end_17:
-    push [$723D]              ; i++
-    inc [$723D]
-    pop V0
-    jmp _body_15
-_end_16:
-    push [$723B]              ; i++
-    inc [$723B]
-    pop V0
-    jmp _body_13
-_end_14:
-    mov 0, V0                 ; fallback return 0
-    ret
-
-_main:                        ; int main()
-    mov $7243, [$7241]        ; int grid = $7243
-    ; clear memory
-    mov 0, [$724B]            ; int i = 0
-_body_18:
-    push [$724B]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    lt V0, V1                 ; compute less than check
-    not LX
-    bz
-    jmp _end_19               ; if for condition fails, jump to end
-    push [$7241]              ; store index obj
-    mov [$724B], 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 0, [V0]              ; [V0] = 0
-    push [$724B]              ; i++
-    inc [$724B]
-    pop V0
-    jmp _body_18
-_end_19:
-    ; turn on pixel at (0,0)
-    push 1                    ; arg int state
-    push 0                    ; arg int index
-    push [$7241]              ; arg char* grid
-    call _setState_char*_grid__int_index__int_state; int setState(char* grid, int index, int state)
-    push [$7241]              ; arg char* grid
-    call _drawGrid_char*_grid ; int drawGrid(char* grid)
-_body_20:
-    not 1
-    bz
-    jmp _end_21               ; if while condition fails, jump to end
-    jmp _body_20
-_end_21:
-    mov 0, V0                 ; fallback return 0
-    ret
-
diff --git a/ROMs/life.c b/ROMs/life.c
deleted file mode 100644
index f35f9d0..0000000
--- a/ROMs/life.c
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "std.c"
-#include "hid.c"
-#include "screen.c"
-
-#define GRID_SIZE   64
-#define GRID_BYTES  8
-#define GRID_WIDTH  8
-#define GRID_HEIGHT 8
-
-char getState(char* grid, int index)
-{
-    int byteIndex = index / 8;
-    int bitIndex  = index % 8;
-    int byte      = grid[byteIndex];
-
-    return ((byte >> bitIndex) & 1) != 0;
-}
-
-int setState(char* grid, int index, int state)
-{
-    int byteIndex = index / 8;
-    int bitIndex  = index % 8;
-    int byte      = grid[byteIndex];
-    
-    if (state)
-        byte |= (1 << bitIndex);
-    else
-        byte &= ~(1 << bitIndex);
-    
-    grid[byteIndex] = byte;
-}
-
-int drawGrid(char* grid)
-{
-    screen_clear(COLOR_BLACK);
-
-    for (int y = 0; y < GRID_HEIGHT; y++)
-    {
-        for (int x = 0; x < GRID_WIDTH; x++)
-        {
-            int index = (y * GRID_WIDTH) + x;
-            if (getState(grid, index))
-                screen_setPixel(x, y, COLOR_WHITE);
-        }
-    }
-}
-
-int main()
-{
-    char* grid = new char[GRID_BYTES];
-
-    // clear memory
-    for (int i = 0; i < GRID_BYTES; i++)
-        grid[i] = 0;
-
-    // turn on pixel at (0,0)
-    setState(grid, 0, 1);
-
-    drawGrid(grid);
-
-    while (1) { }
-}
\ No newline at end of file
diff --git a/ROMs/life.q1 b/ROMs/life.q1
deleted file mode 100644
index 47e3f95..0000000
--- a/ROMs/life.q1
+++ /dev/null
diff --git a/ROMs/typewriter.asm b/ROMs/typewriter.asm
index a9379d9..e9a5a4a 100644
--- a/ROMs/typewriter.asm
+++ b/ROMs/typewriter.asm
@@ -272,7 +272,7 @@ _then_15:
     mov 8, V0                 ; store ternary success result
 _end_16:
     mov V0, [$7237]           ; int pix = V0
-    push [$7237]              ; arg int x
+    push [$7237]              ; arg int c
     push [$7227]              ; left operand
     mov [$722F], V1           ; right operand
     pop V0                    ; get left operand back
@@ -282,7 +282,7 @@ _end_16:
     mov [$7233], V1           ; right operand
     pop V0                    ; get left operand back
     add V0, V1                ; compute addition
-    push AX                   ; arg int c
+    push AX                   ; arg int x
     call _screen_setPixel_int_x__int_y__int_c; int screen_setPixel(int x, int y, int c)
     push [$7233]              ; i++
     inc [$7233]
@@ -321,8 +321,8 @@ _body_17:
     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 [$7241]              ; arg int color
+    push [$723F]              ; arg int y
     push [$723D]              ; left operand
     push [$7243]              ; left operand
     mov 8, V1                 ; right operand
@@ -331,8 +331,8 @@ _body_17:
     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
+    push AX                   ; arg int x
+    push [$7245]              ; arg int ch
     call _drawChar_int_ch__int_x__int_y__int_color; int drawChar(int ch, int x, int y, int color)
     push [$7243]              ; i++
     inc [$7243]
@@ -435,17 +435,17 @@ _end_27:
     jmp _end_29               ; if succeeds, continue, else jump to end
     mov 0, [$7247]            ; [$7247] = 0
 _end_29:
-    push 1                    ; arg int ch
-    push [$7249]              ; arg int x
-    push [$7247]              ; arg int y
-    push 32                   ; arg int color
+    push 1                    ; arg int color
+    push [$7249]              ; arg int y
+    push [$7247]              ; arg int x
+    push 32                   ; arg int ch
     call _drawChar_int_ch__int_x__int_y__int_color; int drawChar(int ch, int x, int y, int color)
     jmp _body_19              ; continue
 _end_28:
-    push 1                    ; arg int ch
-    push [$7249]              ; arg int x
-    push [$7247]              ; arg int y
-    push [$724B]              ; arg int color
+    push 1                    ; arg int color
+    push [$7249]              ; arg int y
+    push [$7247]              ; arg int x
+    push [$724B]              ; arg int ch
     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