implemented standard library

1 files changed, 308 insertions, 234 deletions

diff --git a/ROMs/typewriter.asm b/ROMs/typewriter.asm
index df4e7ca..8a9017b 100644
--- a/ROMs/typewriter.asm
+++ b/ROMs/typewriter.asm
@@ -26,150 +26,72 @@ _setPixel_int_x__int_y__int_c:; int setPixel(int x, int y, int c)
     mov 0, V0                 ; fallback return 0
     ret
 
-_drawChar_int_ch__int_x__int_y__int_color:; int drawChar(int ch, int x, int y, int color)
+_setPixel_int_i__int_c:       ; int setPixel(int i, int c)
     pop V0                    ; preserve function return address
-    pop [$7209]               ; param int ch
-    pop [$720B]               ; param int x
-    pop [$720D]               ; param int y
-    pop [$720F]               ; param int color
+    pop [$7209]               ; param int i
+    pop [$720B]               ; param int c
     push V0                   ; restore function return address
-    ; 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, [$7211]           ; int fontStart = AX
-    push [$7209]              ; left operand
-    mov 8, V1                 ; right operand
-    pop V0                    ; get left operand back
-    mul V0, V1                ; compute multiplication
-    mov AX, [$7213]           ; int charStart = AX
-    mov 0, [$7215]            ; int yOff = 0
-_body_1:
-    push [$7215]              ; 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                ; if for condition fails, jump to end
-    push [$7211]              ; store index obj
-    push [$7213]              ; left operand
-    mov [$7215], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    mov AX, V1                ; store indexer
+    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
-    mov [V0], [$7217]         ; int row = [V0]
-    mov 0, [$7219]            ; int xOff = 0
-_body_3:
-    push [$7219]              ; 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                ; if for condition fails, jump to end
-    push [$7217]              ; left operand
-    push 7                    ; left operand
-    mov [$7219], 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, [$721B]           ; int bit = DX
-    bz [$721B]                ; check ternary condition
-    jmp _then_5
-    mov [$720F], V0           ; store ternary fail result
-    jmp _end_6
-_then_5:
-    mov 8, V0                 ; store ternary success result
-_end_6:
-    mov V0, [$721D]           ; int pix = V0
-    push [$721D]              ; arg int x
-    push [$720D]              ; left operand
-    mov [$7215], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; arg int y
-    push [$720B]              ; left operand
-    mov [$7219], V1           ; right operand
-    pop V0                    ; get left operand back
-    add V0, V1                ; compute addition
-    push AX                   ; arg int c
-    call _setPixel_int_x__int_y__int_c; int setPixel(int x, int y, int c)
-    push [$7219]              ; i++
-    inc [$7219]
-    pop V0
-    jmp _body_3
-_end_4:
-    push [$7215]              ; i++
-    inc [$7215]
-    pop V0
-    jmp _body_1
-_end_2:
+    movb [$720B], [V0]        ; [V0] = [$720B]
     mov 0, V0                 ; fallback return 0
     ret
 
 _clear_int_c:                 ; int clear(int c)
     pop V0                    ; preserve function return address
-    pop [$721F]               ; param int c
+    pop [$720F]               ; param int c
     push V0                   ; restore function return address
-    mov $402F, [$7221]        ; int screenStart = $402F
-    push 64                   ; left operand
-    mov 128, V1               ; right operand
+    mov $402F, [$7211]        ; int screenStart = $402F
+    mov 0, [$7213]            ; int i = 0
+_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, [$7223]           ; int screenSize = AX
-    mov 0, [$7225]            ; int i = 0
-_body_7:
-    push [$7225]              ; left operand
-    mov [$7223], V1           ; right operand
+    mov AX, V1                ; right operand
     pop V0                    ; get left operand back
     lt V0, V1                 ; compute less than check
     not LX
     bz
-    jmp _end_8                ; if for condition fails, jump to end
-    push [$7221]              ; store index obj
-    mov [$7225], V1           ; store indexer
+    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 [$721F], [V0]        ; [V0] = [$721F]
-    push [$7225]              ; i++
-    inc [$7225]
+    movb [$720F], [V0]        ; [V0] = [$720F]
+    push [$7213]              ; i++
+    inc [$7213]
     pop V0
-    jmp _body_7
-_end_8:
+    jmp _body_1
+_end_2:
     mov 0, V0                 ; fallback return 0
     ret
 
 _getKeyState_int_scanCode:    ; int getKeyState(int scanCode)
     pop V0                    ; preserve function return address
-    pop [$7227]               ; param int scanCode
+    pop [$7215]               ; param int scanCode
     push V0                   ; restore function return address
-    mov $6033, [$7229]        ; int hid = $6033
-    push [$7227]              ; left operand
+    mov $6033, [$7217]        ; int hid = $6033
+    push [$7215]              ; left operand
     mov 8, V1                 ; right operand
     pop V0                    ; get left operand back
     div V0, V1                ; compute division
-    mov AX, [$722B]           ; int index = AX
-    push [$7227]              ; left operand
+    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, [$722D]           ; int bit = AX
-    push [$7229]              ; store index obj
-    push [$722B]              ; left operand
+    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
@@ -178,10 +100,10 @@ _getKeyState_int_scanCode:    ; int getKeyState(int scanCode)
     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], [$722F]         ; int val = [V0]
-    push [$722F]              ; left operand
+    mov [V0], [$721D]         ; int val = [V0]
+    push [$721D]              ; left operand
     push 1                    ; left operand
-    mov [$722D], V1           ; right operand
+    mov [$721B], V1           ; right operand
     pop V0                    ; get left operand back
     shl V0, V1                ; compute left shift
     mov DX, V1                ; right operand
@@ -197,34 +119,212 @@ _getKeyState_int_scanCode:    ; int getKeyState(int scanCode)
     mov 0, V0                 ; fallback return 0
     ret
 
-_print_int*_text__int_len__int_x__int_y__int_color:; int print(int* text, int len, int x, int y, int color)
+_getPressedKey:               ; int getPressedKey()
+    mov 0, [$721F]            ; int sk = 0
+_body_3:
+    push [$721F]              ; 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_4                ; if for condition fails, jump to end
+    push [$721F]              ; arg int scanCode
+    call _getKeyState_int_scanCode; int getKeyState(int scanCode)
+    cmp V0, 0                 ; logical and
+    not
+    bz
+    jmp _clause_5
+    mov 0, V0                 ; first operand failed, store 0 and skip second
+    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
+    not
+    cmp LX, 0                 ; compare result from second operand to 0
+    not
+    mov LX, V0                ; store second operand result
+_end_6:
+    not V0
+    bz                        ; check if condition
+    jmp _end_7                ; if succeeds, continue, else jump to end
+    mov [$721F], V0           ; return value
+    ret
+_end_7:
+    push [$721F]              ; i++
+    inc [$721F]
+    pop V0
+    jmp _body_3
+_end_4:
+    mov 0, V0                 ; return value
+    ret
+    mov 0, V0                 ; fallback return 0
+    ret
+
+_readKey:                     ; int readKey()
+_body_8:
+    not 1
+    bz
+    jmp _end_9                ; if while condition fails, jump to end
+    call _getPressedKey       ; int 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
+    not
+    not LX
+    bz                        ; check if condition
+    jmp _end_10               ; if succeeds, continue, else jump to end
+    mov [$7221], V0           ; return value
+    ret
+_end_10:
+    jmp _body_8
+_end_9:
+    mov 0, V0                 ; fallback return 0
+    ret
+
+_getMouseIndex:               ; int getMouseIndex()
+    mov $602F, V0             ; move pointer into register for dereference
+    mov [V0], V0              ; return value
+    ret
+    mov 0, V0                 ; fallback return 0
+    ret
+
+_getMouseState:               ; int 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
+
+_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 [$7231]               ; param int* text
-    pop [$7233]               ; param int len
-    pop [$7235]               ; param int x
-    pop [$7237]               ; param int y
-    pop [$7239]               ; param int color
+    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
-    mov 0, [$723B]            ; int i = 0
-_body_9:
-    push [$723B]              ; left operand
+    ; 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
+_body_11:
+    push [$722F]              ; 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_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
+_body_13:
+    push [$7233]              ; 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
+    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 _then_15
+    mov [$7229], V0           ; store ternary fail result
+    jmp _end_16
+_then_15:
+    mov 8, V0                 ; store ternary success result
+_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 _setPixel_int_x__int_y__int_c; int setPixel(int x, int y, int c)
+    push [$7233]              ; i++
+    inc [$7233]
+    pop V0
+    jmp _body_13
+_end_14:
+    push [$722F]              ; i++
+    inc [$722F]
+    pop V0
+    jmp _body_11
+_end_12:
+    mov 0, V0                 ; fallback return 0
+    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
+_body_17:
+    push [$7243]              ; left operand
+    mov [$723B], 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 [$7231]              ; store index obj
-    mov [$723B], V1           ; store indexer
+    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], [$723D]         ; int ch = [V0]
-    push [$7239]              ; arg int ch
-    push [$7237]              ; arg int x
-    push [$7235]              ; left operand
-    push [$723B]              ; left operand
+    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
@@ -232,156 +332,130 @@ _body_9:
     pop V0                    ; get left operand back
     add V0, V1                ; compute addition
     push AX                   ; arg int y
-    push [$723D]              ; arg int color
+    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 [$723B]              ; i++
-    inc [$723B]
+    push [$7243]              ; i++
+    inc [$7243]
     pop V0
-    jmp _body_9
-_end_10:
+    jmp _body_17
+_end_18:
     mov 0, V0                 ; fallback return 0
     ret
 
 _main:                        ; int main()
-    mov 0, [$723F]            ; int x = 0
-    mov 0, [$7241]            ; int y = 0
-_body_11:
+    mov 0, [$7247]            ; int x = 0
+    mov 0, [$7249]            ; int y = 0
+_body_19:
     not 1
     bz
-    jmp _end_12               ; if while condition fails, jump to end
-    mov 0, [$7243]            ; int sk = 0
-_body_13:
-    push [$7243]              ; left operand
-    mov 256, V1               ; right operand
+    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
-    lt V0, V1                 ; compute less than check
+    cmp V0, V1                ; compute equality check
+    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
+_end_22:
+    push [$7249]              ; left operand
+    mov 64, V1                ; right operand
+    pop V0                    ; get left operand back
+    cmp V0, V1                ; compute equality check
     bz
-    jmp _end_14               ; if for condition fails, jump to end
-    push [$7243]              ; arg int scanCode
-    call _getKeyState_int_scanCode; int getKeyState(int scanCode)
-    not V0
+    jmp _end_23
+    gt V0, V1
+_end_23:
+    not LX
     bz                        ; check if condition
-    jmp _end_15               ; if succeeds, continue, else jump to end
-_body_16:
-    push [$7243]              ; arg int scanCode
+    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 _clear_int_c         ; int clear(int c)
+_end_24:
+    call _readKey             ; int readKey()
+    mov V0, [$724B]           ; int sk = V0
+_body_25:
+    push [$724B]              ; arg int scanCode
     call _getKeyState_int_scanCode; int getKeyState(int scanCode)
     not V0
     bz
-    jmp _end_17               ; if while condition fails, jump to end
-    jmp _body_16
-_end_17:
-    ; Newline pressed
-    push [$7243]              ; left operand
+    jmp _end_26               ; if while condition fails, jump to end
+    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
     not LX
     bz                        ; check if condition
-    jmp _end_18               ; if succeeds, continue, else jump to end
-    push [$7241]              ; left operand
+    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, [$7241]           ; store back into left param
-    mov 0, [$723F]            ; [$723F] = 0
-    jmp _body_13              ; continue
-_end_18:
-    ; Backspace pressed
-    push [$7243]              ; left operand
+    mov V1, [$7249]           ; store back into left param
+    mov 0, [$7247]            ; [$7247] = 0
+    jmp _body_19              ; continue
+_end_27:
+    push [$724B]              ; left operand
     mov 8, V1                 ; right operand
     pop V0                    ; get left operand back
     cmp V0, V1                ; compute equality check
     not LX
     bz                        ; check if condition
-    jmp _end_19               ; if succeeds, continue, else jump to end
-    push [$723F]              ; left operand
+    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, [$723F]           ; store back into left param
-    push [$723F]              ; left operand
+    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
     not LX
     bz                        ; check if condition
-    jmp _end_20               ; if succeeds, continue, else jump to end
-    mov 0, [$723F]            ; [$723F] = 0
-_end_20:
-    mov 32, [$7247]
-    mov $7247, [$7245]        ; int text = $7247
-    push 1                    ; arg int* text
-    push [$7241]              ; arg int len
-    push [$723F]              ; arg int x
-    push 1                    ; arg int y
-    push [$7245]              ; arg int color
-    call _print_int*_text__int_len__int_x__int_y__int_color; int print(int* text, int len, int x, int y, int color)
-    jmp _body_13              ; continue
-_end_19:
-    mov [$7243], [$724B]
-    mov $724B, [$7249]        ; int text = $724B
-    push 1                    ; arg int* text
-    push [$7241]              ; arg int len
-    push [$723F]              ; arg int x
-    push 1                    ; arg int y
-    push [$7249]              ; arg int color
-    call _print_int*_text__int_len__int_x__int_y__int_color; int print(int* text, int len, int x, int y, int color)
-    push [$723F]              ; 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, [$723F]           ; store back into left param
-_end_15:
-    push [$7243]              ; i++
-    inc [$7243]
-    pop V0
-    jmp _body_13
-_end_14:
-    push [$723F]              ; left operand
-    mov 128, V1               ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute equality check
-    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, [$723F]            ; [$723F] = 0
-    push [$7241]              ; left operand
+    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
+    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
+    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, [$7241]           ; store back into left param
-_end_22:
-    push [$7241]              ; left operand
-    mov 64, V1                ; right operand
-    pop V0                    ; get left operand back
-    cmp V0, V1                ; compute equality check
-    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, [$723F]            ; [$723F] = 0
-    mov 0, [$7241]            ; [$7241] = 0
-    push 8                    ; arg int c
-    call _clear_int_c         ; int clear(int c)
-_end_24:
-    jmp _body_11
-_end_12:
+    mov V1, [$7247]           ; store back into left param
+    jmp _body_19
+_end_20:
     mov 0, V0                 ; fallback return 0
     ret