@ (top-level-begin 0 21100005)
        mov    r10, r8
        ldr    r4, =N_21100005
        ldr    r4, [r4]
        mov    r4, r4, lsl $2
        add    r3, r10, r4
@ (call __main)
        bl     __main
@ (exit)
        b      _cleanup
__put4chars:
@ (function-proc-begin 1 2 1)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $4
        add    r3, r10, $8
        add    r0, r10, $4
        str    r1, [r0]
@ (expr #f 0 #f (putchar (shr x 24)))
@ (imm)
@ (push 24)
        mov    r5, $24
        str    r5, [r3], $4
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (shr)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        mov    r4, r7, asr r5
        str    r4, [r3, $-4]
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (putchar (bitwise-and (shr x 16) 255)))
@ (imm)
@ (push 255)
        mov    r5, $255
        str    r5, [r3], $4
@ (imm)
@ (push 16)
        mov    r5, $16
        str    r5, [r3], $4
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (shr)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        mov    r4, r7, asr r5
        str    r4, [r3, $-4]
@ (bitand)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        and    r4, r7, r5
        str    r4, [r3, $-4]
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (putchar (bitwise-and (shr x 8) 255)))
@ (imm)
@ (push 255)
        mov    r5, $255
        str    r5, [r3], $4
@ (imm)
@ (push 8)
        mov    r5, $8
        str    r5, [r3], $4
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (shr)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        mov    r4, r7, asr r5
        str    r4, [r3, $-4]
@ (bitand)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        and    r4, r7, r5
        str    r4, [r3, $-4]
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (putchar (bitwise-and x 255)))
@ (imm)
@ (push 255)
        mov    r5, $255
        str    r5, [r3], $4
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (bitand)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        and    r4, r7, r5
        str    r4, [r3, $-4]
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 1)
        mov    r3, r10
        ldr    r10, [r10, $4]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
__write_int_digit:
@ (function-proc-begin 1 2 1)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $4
        add    r3, r10, $8
        add    r0, r10, $4
        str    r1, [r0]
@ (expr #t 2 > (> n 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (gt)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l0)
        ble    .l0
@ (expr #f 0 #f (__write_int_digit (quotient n 10)))
@ (push 10)
        mov    r5, $10
        str    r5, [r3], $4
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (div)
        ldr    r0, [r3, $-4]!
        ldr    r1, [r3, $-4]
        bl     signed_quotient
        str    r0, [r3, $-4]
@ (call __write_int_digit)
        bl     __write_int_digit
@ (expr #f 0 #f (putchar (+ (remainder n 10) 48)))
@ (imm)
@ (push 48)
        mov    r5, $48
        str    r5, [r3], $4
@ (push 10)
        mov    r5, $10
        str    r5, [r3], $4
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (mod)
        ldr    r0, [r3, $-4]!
        ldr    r1, [r3, $-4]
        bl     signed_remainder
        str    r0, [r3, $-4]
@ (add)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        add    r4, r7, r5
        str    r4, [r3, $-4]
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
.l0:
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 1)
        mov    r3, r10
        ldr    r10, [r10, $4]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
__write_integer:
@ (function-proc-begin 1 2 1)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $4
        add    r3, r10, $8
        add    r0, r10, $4
        str    r1, [r0]
@ (expr #t 2 = (= n 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (eq)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l1)
        bne    .l1
@ (expr #f 0 #f (putchar 48))
@ (push 48)
        mov    r5, $48
        str    r5, [r3], $4
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 1)
        mov    r3, r10
        ldr    r10, [r10, $4]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
.l1:
@ (expr #t 2 < (< n 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (lt)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l2)
        bge    .l2
@ (expr #f 0 #f (putchar 45))
@ (push 45)
        mov    r5, $45
        str    r5, [r3], $4
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #t 4 #f (&& (= (bitwise-and n 65535) 0) (= (shr n 16) (- 32768))))
@ (push 32768)
        ldr    r0, =N_32768
        ldr    r0, [r0]
@ (negate)
        mov    r1, $0
        sub    r0, r1, r0
@ (imm)
@ (push 16)
@ (stack-ref-n 0)
        ldr    r4, [r10]
@ (shr)
@ * use immediate constant 16
        mov    r2, r4, asr $16
@ (eq)
        cmp    r2, r0
        moveq  r0, $1
        movne  r0, $0
@ (imm)
@ (push 0)
@ (push 65535)
        mov    r4, $1
        mov    r4, r4, lsl $16
        sub    r4, r4, $1
@ (stack-ref-n 0)
        ldr    r5, [r10]
@ (bitand)
        and    r4, r5, r4
@ (eq)
@ * use immediate constant 0
        cmp    r4, $0
        moveq  r2, $1
        movne  r2, $0
@ (and)
        and    r0, r2, r0
@ (bfl l4)
        cmp    r0, $0
        beq    .l4
@ (expr #f 0 #f (__put4chars 842085431))
@ (push 842085431)
        ldr    r5, =N_842085431
        ldr    r5, [r5]
        str    r5, [r3], $4
@ (call __put4chars)
        bl     __put4chars
@ (expr #f 0 #f (__put4chars 876098358))
@ (push 876098358)
        ldr    r5, =N_876098358
        ldr    r5, [r5]
        str    r5, [r3], $4
@ (call __put4chars)
        bl     __put4chars
@ (expr #f 0 #f (putchar 52))
@ (push 52)
        mov    r5, $52
        str    r5, [r3], $4
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (putchar 56))
@ (push 56)
        mov    r5, $56
        str    r5, [r3], $4
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 1)
        mov    r3, r10
        ldr    r10, [r10, $4]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
.l4:
@ (expr #f 0 #f (__write_int_digit (- n)))
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (negate)
        sub    r4, r3, $4
        ldr    r5, [r4]
        mov    r0, $0
        sub    r5, r0, r5
        str    r5, [r4]
@ (call __write_int_digit)
        bl     __write_int_digit
@ (br l3)
        b      .l3
.ltorg
.l2:
@ (expr #f 0 #f (__write_int_digit n))
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (call __write_int_digit)
        bl     __write_int_digit
.l3:
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 1)
        mov    r3, r10
        ldr    r10, [r10, $4]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
__mult:
@ (function-proc-begin 2 4 3)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $8
        add    r3, r10, $16
        add    r0, r10, $12
        str    r1, [r0]
@ (expr #t 2 #f (return (* x y)))
@ (stack-ref-n 1)
        ldr    r0, [r10, $4]
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (mul)
        mul    r0, r2, r0
@ (stack-set-n 0)
        str    r0, [r10]
@ (function-end 3)
        add    r3, r10, $4
        ldr    r10, [r10, $12]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
__div:
@ (function-proc-begin 2 4 3)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $8
        add    r3, r10, $16
        add    r0, r10, $12
        str    r1, [r0]
@ (expr #f 0 #f (return (quotient x y)))
@ (stack-ref-n 1)
        ldr    r0, [r10, $4]
        str    r0, [r3], $4
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (div)
        ldr    r0, [r3, $-4]!
        ldr    r1, [r3, $-4]
        bl     signed_quotient
        str    r0, [r3, $-4]
@ (stack-set-n 0)
        ldr    r0, [r3, $-4]!
        str    r0, [r10]
@ (function-end 3)
        add    r3, r10, $4
        ldr    r10, [r10, $12]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
my_putchar:
@ (function-proc-begin 1 2 1)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $4
        add    r3, r10, $8
        add    r0, r10, $4
        str    r1, [r0]
@ (expr #f 0 #f (putchar ch))
@ (stack-ref-n 0)
        ldr    r0, [r10]
        str    r0, [r3], $4
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 1)
        mov    r3, r10
        ldr    r10, [r10, $4]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
my_fgetc:
@ (function-proc-begin 0 2 1)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $0
        add    r3, r10, $8
        add    r0, r10, $4
        str    r1, [r0]
@ (expr #f 0 #f (return (getchar)))
@ (read-char)
        bl     _read_char
        str    r0, [r3], $4
@ (stack-set-n 0)
        ldr    r0, [r3, $-4]!
        str    r0, [r10]
@ (function-end 1)
        add    r3, r10, $4
        ldr    r10, [r10, $4]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
read_char_:
@ (function-proc-begin 0 1 0)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $0
        add    r3, r10, $4
        add    r0, r10, $0
        str    r1, [r0]
@ (expr #t 2 = (= ch (- 1)))
@ (push 1)
        mov    r0, $1
@ (negate)
        mov    r1, $0
        sub    r0, r1, r0
@ (push 21100000)
        ldr    r2, =N_21100000
        ldr    r2, [r2]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (eq)
        cmp    r2, r0
@ (bfl l5)
        bne    .l5
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 0)
        mov    r3, r10
        ldr    r10, [r10]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
.l5:
@ (expr #f 0 #f (set! ch (getchar)))
@ (read-char)
        bl     _read_char
        str    r0, [r3], $4
@ (push 21100000)
        ldr    r5, =N_21100000
        ldr    r5, [r5]
        str    r5, [r3], $4
@ (stack-set)
        ldr    r4, [r3, $-8]!
        ldr    r6, [r3, $4]
        str    r4, [r8, r6, lsl $2]
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 0)
        mov    r3, r10
        ldr    r10, [r10]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
.l6:
skip_blanks:
@ (function-proc-begin 0 1 0)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $0
        add    r3, r10, $4
        add    r0, r10, $0
        str    r1, [r0]
.l7:
@ (expr #t 4 #f ($$ ($$ (= ch 32) (= ch 10)) (= ch 13)))
@ (imm)
@ (push 13)
@ (push 21100000)
        ldr    r2, =N_21100000
        ldr    r2, [r2]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (eq)
@ * use immediate constant 13
        cmp    r2, $13
        moveq  r0, $1
        movne  r0, $0
@ (imm)
@ (push 10)
@ (push 21100000)
        ldr    r4, =N_21100000
        ldr    r4, [r4]
@ (stack-ref)
        ldr    r4, [r8, r4, lsl $2]
@ (eq)
@ * use immediate constant 10
        cmp    r4, $10
        moveq  r2, $1
        movne  r2, $0
@ (imm)
@ (push 32)
@ (push 21100000)
        ldr    r5, =N_21100000
        ldr    r5, [r5]
@ (stack-ref)
        ldr    r5, [r8, r5, lsl $2]
@ (eq)
@ * use immediate constant 32
        cmp    r5, $32
        moveq  r4, $1
        movne  r4, $0
@ (or)
        orr    r2, r4, r2
@ (or)
        orr    r0, r2, r0
@ (bfl l8)
        cmp    r0, $0
        beq    .l8
@ (expr #f 0 #f (set! ch (getchar)))
@ (read-char)
        bl     _read_char
        str    r0, [r3], $4
@ (push 21100000)
        ldr    r5, =N_21100000
        ldr    r5, [r5]
        str    r5, [r3], $4
@ (stack-set)
        ldr    r4, [r3, $-8]!
        ldr    r6, [r3, $4]
        str    r4, [r8, r6, lsl $2]
@ (br l7)
        b      .l7
.ltorg
.l8:
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 0)
        mov    r3, r10
        ldr    r10, [r10]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
my_scan_int:
@ (function-proc-begin 0 4 3)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $0
        add    r3, r10, $16
        add    r0, r10, $12
        str    r1, [r0]
@ (expr #t 1 #f (set! sum 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 0)
        str    r0, [r10]
@ (expr #t 1 #f (set! negative 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 1)
        str    r0, [r10, $4]
@ (expr #f 0 #f (skip_blanks))
@ (call skip_blanks)
        bl     skip_blanks
@ (expr #t 2 = (= ch 45))
@ (imm)
@ (push 45)
@ (push 21100000)
        ldr    r2, =N_21100000
        ldr    r2, [r2]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (eq)
@ * use immediate constant 45
        cmp    r2, $45
@ (bfl l9)
        bne    .l9
@ (expr #t 1 #f (set! negative 1))
@ (push 1)
        mov    r0, $1
@ (stack-set-n 1)
        str    r0, [r10, $4]
@ (expr #f 0 #f (read_char_))
@ (call read_char_)
        bl     read_char_
.l9:
.l10:
@ (expr #t 3 #f (&& (>= ch 48) (<= ch 57)))
@ (imm)
@ (push 57)
@ (push 21100000)
        ldr    r2, =N_21100000
        ldr    r2, [r2]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (le)
@ * use immediate constant 57
        cmp    r2, $57
        movle  r0, $1
        movgt  r0, $0
@ (imm)
@ (push 48)
@ (push 21100000)
        ldr    r4, =N_21100000
        ldr    r4, [r4]
@ (stack-ref)
        ldr    r4, [r8, r4, lsl $2]
@ (ge)
@ * use immediate constant 48
        cmp    r4, $48
        movge  r2, $1
        movlt  r2, $0
@ (and)
        and    r0, r2, r0
@ (bfl l11)
        cmp    r0, $0
        beq    .l11
@ (expr #t 4 #f (set! sum (- (+ (* sum 10) ch) 48)))
@ (imm)
@ (push 48)
@ (push 21100000)
        ldr    r2, =N_21100000
        ldr    r2, [r2]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (push 10)
        mov    r4, $10
@ (stack-ref-n 0)
        ldr    r5, [r10]
@ (mul)
        mul    r4, r5, r4
@ (add)
        add    r2, r4, r2
@ (sub)
@ * use immediate constant 48
        sub    r0, r2, $48
@ (stack-set-n 0)
        str    r0, [r10]
@ (expr #f 0 #f (read_char_))
@ (call read_char_)
        bl     read_char_
@ (br l10)
        b      .l10
.ltorg
.l11:
@ (expr #t 2 = (= negative 1))
@ (imm)
@ (push 1)
@ (stack-ref-n 1)
        ldr    r2, [r10, $4]
@ (eq)
@ * use immediate constant 1
        cmp    r2, $1
@ (bfl l12)
        bne    .l12
@ (expr #t 1 #f (set! sum (- sum)))
@ (stack-ref-n 0)
        ldr    r0, [r10]
@ (negate)
        mov    r1, $0
        sub    r0, r1, r0
@ (stack-set-n 0)
        str    r0, [r10]
.l12:
@ (expr #f 0 #f (return sum))
@ (function-end 3)
        add    r3, r10, $4
        ldr    r10, [r10, $12]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
__main:
@ (function-proc-begin 0 20 19)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $0
        add    r3, r10, $80
        add    r0, r10, $76
        str    r1, [r0]
@ (expr #t 2 #f (set! ch 32))
@ (push 32)
        mov    r0, $32
@ (push 21100000)
        ldr    r2, =N_21100000
        ldr    r2, [r2]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx 1))
@ (push 1)
        mov    r0, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 1 #f (set! return_stack_idx 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 6)
        str    r0, [r10, $24]
@ (expr #t 1 #f (set! eof_reached 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 17)
        str    r0, [r10, $68]
@ (expr #t 1 #f (set! frame_start 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 5)
        str    r0, [r10, $20]
@ (expr #f 0 #f (set! temp (my_scan_int)))
@ (call my_scan_int)
        bl     my_scan_int
@ (stack-set-n 13)
        ldr    r0, [r3, $-4]!
        str    r0, [r10, $52]
@ (expr #t 1 #f (set! idx 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 0)
        str    r0, [r10]
.l13:
@ (expr #t 2 < (< idx temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (lt)
        cmp    r2, r0
@ (bfl l14)
        bge    .l14
@ (expr #f 0 #f (set! word (my_scan_int)))
@ (call my_scan_int)
        bl     my_scan_int
@ (stack-set-n 1)
        ldr    r0, [r3, $-4]!
        str    r0, [r10, $4]
@ (expr #t 3 #f (vector-set! code idx word))
@ (stack-ref-n 1)
        ldr    r0, [r10, $4]
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (push 21000000)
        ldr    r4, =N_21000000
        ldr    r4, [r4]
@ (add)
        add    r2, r4, r2
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! idx (+ idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 0)
        str    r0, [r10]
@ (br l13)
        b      .l13
.ltorg
.l14:
@ (expr #t 1 #f (set! pc 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
.l15:
@ (expr #f 0 #f opcode)
@ (stack-ref-n 3)
        ldr    r0, [r10, $12]
        str    r0, [r3], $4
@ (br l17)
        b      .l17
.ltorg
.l19:
@ (expr #t 2 #f (set! frame_start (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 5)
        str    r0, [r10, $20]
@ (expr #t 2 #f (set! stack_idx (+ frame_start (vector-ref code (+ pc 2)))))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 5)
        ldr    r2, [r10, $20]
@ (add)
        add    r0, r2, r0
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 3)))
@ (imm)
@ (push 3)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 3
        add    r0, r2, $3
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l20:
@ (expr #t 2 #f (set! formals_offset (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 10)
        str    r0, [r10, $40]
@ (expr #t 2 #f (set! all_vars_size (vector-ref code (+ pc 2))))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 11)
        str    r0, [r10, $44]
@ (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 3))))
@ (imm)
@ (push 3)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 3
        add    r0, r2, $3
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 12)
        str    r0, [r10, $48]
@ (expr #t 1 #f (set! temp frame_start))
@ (stack-ref-n 5)
        ldr    r0, [r10, $20]
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! frame_start (- stack_idx formals_offset)))
@ (stack-ref-n 10)
        ldr    r0, [r10, $40]
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
        sub    r0, r2, r0
@ (stack-set-n 5)
        str    r0, [r10, $20]
@ (expr #t 2 #f (set! stack_idx (+ frame_start all_vars_size)))
@ (stack-ref-n 11)
        ldr    r0, [r10, $44]
@ (stack-ref-n 5)
        ldr    r2, [r10, $20]
@ (add)
        add    r0, r2, r0
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 3 #f (vector-set! stack (+ frame_start dynamic_link) temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref-n 12)
        ldr    r2, [r10, $48]
@ (stack-ref-n 5)
        ldr    r4, [r10, $20]
@ (add)
        add    r2, r4, r2
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! pc (+ pc 4)))
@ (imm)
@ (push 4)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 4
        add    r0, r2, $4
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l21:
@ (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 12)
        str    r0, [r10, $48]
@ (expr #t 1 #f (set! temp (vector-ref stack frame_start)))
@ (stack-ref-n 5)
        ldr    r0, [r10, $20]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 1 #f (set! stack_idx frame_start))
@ (stack-ref-n 5)
        ldr    r0, [r10, $20]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! frame_start (vector-ref stack (+ frame_start dynamic_link))))
@ (stack-ref-n 12)
        ldr    r0, [r10, $48]
@ (stack-ref-n 5)
        ldr    r2, [r10, $20]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 5)
        str    r0, [r10, $20]
@ (expr #t 2 #f (vector-set! stack stack_idx temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l22:
@ (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 12)
        str    r0, [r10, $48]
@ (expr #t 1 #f (set! stack_idx frame_start))
@ (stack-ref-n 5)
        ldr    r0, [r10, $20]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! frame_start (vector-ref stack (+ frame_start dynamic_link))))
@ (stack-ref-n 12)
        ldr    r0, [r10, $48]
@ (stack-ref-n 5)
        ldr    r2, [r10, $20]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 5)
        str    r0, [r10, $20]
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l23:
@ (expr #t 2 #f (vector-set! stack stack_idx (+ frame_start (vector-ref code (+ pc 1)))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 5)
        ldr    r2, [r10, $20]
@ (add)
        add    r0, r2, r0
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l24:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (vector-set! stack temp (vector-ref stack (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l25:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 3 #f (vector-set! stack (vector-ref stack (- stack_idx 1)) (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r4, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r2, r4, $1
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l26:
@ (expr #t 2 #f (vector-set! stack stack_idx (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l27:
@ (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l28:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (+ (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (add)
        add    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l29:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (- (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (sub)
        sub    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l30:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (* (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (mul)
        mul    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l31:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #f 0 #f (vector-set! stack temp (quotient (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
        str    r0, [r3], $4
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (div)
        ldr    r0, [r3, $-4]!
        ldr    r1, [r3, $-4]
        bl     signed_quotient
        str    r0, [r3, $-4]
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (stack-set)
        ldr    r4, [r3, $-8]!
        ldr    r6, [r3, $4]
        str    r4, [r8, r6, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l32:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #f 0 #f (vector-set! stack temp (remainder (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
        str    r0, [r3], $4
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (mod)
        ldr    r0, [r3, $-4]!
        ldr    r1, [r3, $-4]
        bl     signed_remainder
        str    r0, [r3, $-4]
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (stack-set)
        ldr    r4, [r3, $-8]!
        ldr    r6, [r3, $4]
        str    r4, [r8, r6, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l33:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #f 0 #f (vector-set! stack temp (abs (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (abs)
        sub    r4, r3, $4
        ldr    r5, [r4]
        cmp    r5, $0
        bge    .l104
        mov    r0, $0
        sub    r5, r0, r5
        str    r5, [r4]
.l104:
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (stack-set)
        ldr    r4, [r3, $-8]!
        ldr    r6, [r3, $4]
        str    r4, [r8, r6, lsl $2]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l34:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (vector-set! stack temp (- (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (negate)
        mov    r1, $0
        sub    r0, r1, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l35:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (shl (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (shl)
        mov    r0, r2, lsl r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l36:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (shr (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (shr)
        mov    r0, r2, asr r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l37:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (bitwise-ior (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (bitor)
        orr    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l38:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (bitwise-and (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (bitand)
        and    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l39:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (vector-set! stack temp (bitwise-not (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (bitnot)
        mvn    r0, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l40:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 1 #f (set! cc (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 8)
        str    r0, [r10, $32]
@ (expr #t 1 #f (set! stack_idx temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 != (!= cc 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 8)
        ldr    r2, [r10, $32]
@ (ne)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l68)
        beq    .l68
@ (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (br l69)
        b      .l69
.ltorg
.l68:
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
.l69:
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l41:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 1 #f (set! cc (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 8)
        str    r0, [r10, $32]
@ (expr #t 1 #f (set! stack_idx temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 = (= cc 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 8)
        ldr    r2, [r10, $32]
@ (eq)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l70)
        bne    .l70
@ (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (br l71)
        b      .l71
.ltorg
.l70:
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
.l71:
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l42:
@ (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l43:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 = (= (vector-ref stack temp2) (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (eq)
        cmp    r2, r0
@ (bfl l72)
        bne    .l72
@ (expr #t 2 #f (vector-set! stack temp 1))
@ (push 1)
        mov    r0, $1
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (br l73)
        b      .l73
.ltorg
.l72:
@ (expr #t 2 #f (vector-set! stack temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
.l73:
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l44:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 < (< (vector-ref stack temp2) (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (lt)
        cmp    r2, r0
@ (bfl l74)
        bge    .l74
@ (expr #t 2 #f (vector-set! stack temp 1))
@ (push 1)
        mov    r0, $1
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (br l75)
        b      .l75
.ltorg
.l74:
@ (expr #t 2 #f (vector-set! stack temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
.l75:
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l45:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 > (> (vector-ref stack temp2) (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (gt)
        cmp    r2, r0
@ (bfl l76)
        ble    .l76
@ (expr #t 2 #f (vector-set! stack temp 1))
@ (push 1)
        mov    r0, $1
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (br l77)
        b      .l77
.ltorg
.l76:
@ (expr #t 2 #f (vector-set! stack temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
.l77:
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l46:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 <= (<= (vector-ref stack temp2) (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (le)
        cmp    r2, r0
@ (bfl l79)
        bgt    .l79
@ (expr #t 2 #f (vector-set! stack temp 1))
@ (push 1)
        mov    r0, $1
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (br l80)
        b      .l80
.ltorg
.l79:
@ (expr #t 2 #f (vector-set! stack temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
.l80:
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l47:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 >= (>= (vector-ref stack temp2) (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (ge)
        cmp    r2, r0
@ (bfl l81)
        blt    .l81
@ (expr #t 2 #f (vector-set! stack temp 1))
@ (push 1)
        mov    r0, $1
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (br l82)
        b      .l82
.ltorg
.l81:
@ (expr #t 2 #f (vector-set! stack temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
.l82:
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l48:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 != (!= (vector-ref stack temp2) (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (ne)
        cmp    r2, r0
@ (bfl l83)
        beq    .l83
@ (expr #t 2 #f (vector-set! stack temp 1))
@ (push 1)
        mov    r0, $1
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (br l84)
        b      .l84
.ltorg
.l83:
@ (expr #t 2 #f (vector-set! stack temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
.l84:
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l49:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (vector-set! stack temp (bitwise-and (bitwise-not (vector-ref stack temp)) 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (bitnot)
        mvn    r2, r2
@ (bitand)
@ * use immediate constant 1
        and    r0, r2, $1
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l50:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (bitwise-and (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (bitand)
        and    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l51:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (bitwise-ior (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (bitor)
        orr    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l52:
@ (expr #t 3 #f (vector-set! return_stack return_stack_idx (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-ref-n 6)
        ldr    r2, [r10, $24]
@ (push 21050000)
        ldr    r4, =N_21050000
        ldr    r4, [r4]
@ (add)
        add    r2, r4, r2
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! return_stack_idx (+ return_stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 6)
        ldr    r2, [r10, $24]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 6)
        str    r0, [r10, $24]
@ (expr #t 2 = (= return_stack_idx 50000))
@ (push 50000)
        ldr    r0, =N_50000
        ldr    r0, [r0]
@ (stack-ref-n 6)
        ldr    r2, [r10, $24]
@ (eq)
        cmp    r2, r0
@ (bfl l86)
        bne    .l86
@ (expr #f 0 #f (__put4chars 1937006947))
@ (push 1937006947)
        ldr    r5, =N_1937006947
        ldr    r5, [r5]
        str    r5, [r3], $4
@ (call __put4chars)
        bl     __put4chars
@ (expr #f 0 #f (__put4chars 1797287798))
@ (push 1797287798)
        ldr    r5, =N_1797287798
        ldr    r5, [r5]
        str    r5, [r3], $4
@ (call __put4chars)
        bl     __put4chars
@ (expr #f 0 #f (__put4chars 1701996140))
@ (push 1701996140)
        ldr    r5, =N_1701996140
        ldr    r5, [r5]
        str    r5, [r3], $4
@ (call __put4chars)
        bl     __put4chars
@ (expr #f 0 #f (putchar 111))
@ (push 111)
        mov    r5, $111
        str    r5, [r3], $4
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (putchar 119))
@ (push 119)
        mov    r5, $119
        str    r5, [r3], $4
@ (write-char)
        ldr    r2, [r3, $-4]!
        bl     _print_character
@ (expr #f 0 #f (my_putchar 10))
@ (push 10)
        mov    r5, $10
        str    r5, [r3], $4
@ (call my_putchar)
        bl     my_putchar
@ (expr #f 0 #f (exit 0))
@ (push 0)
        mov    r5, $0
        str    r5, [r3], $4
@ (exit)
        b      _cleanup
.l86:
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l53:
@ (expr #t 2 #f (set! pc (vector-ref return_stack (- return_stack_idx 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 6)
        ldr    r2, [r10, $24]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (push 21050000)
        ldr    r2, =N_21050000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! return_stack_idx (- return_stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 6)
        ldr    r2, [r10, $24]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 6)
        str    r0, [r10, $24]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l54:
@ (expr #t 1 #f (set! val_ 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 7)
        str    r0, [r10, $28]
@ (expr #t 2 = (= eof_reached 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 17)
        ldr    r2, [r10, $68]
@ (eq)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l87)
        bne    .l87
@ (expr #f 0 #f (set! val_ (getchar)))
@ (read-char)
        bl     _read_char
        str    r0, [r3], $4
@ (stack-set-n 7)
        ldr    r0, [r3, $-4]!
        str    r0, [r10, $28]
@ (expr #t 2 = (= val_ (- 1)))
@ (push 1)
        mov    r0, $1
@ (negate)
        mov    r1, $0
        sub    r0, r1, r0
@ (stack-ref-n 7)
        ldr    r2, [r10, $28]
@ (eq)
        cmp    r2, r0
@ (bfl l88)
        bne    .l88
@ (expr #t 1 #f (set! eof_reached 1))
@ (push 1)
        mov    r0, $1
@ (stack-set-n 17)
        str    r0, [r10, $68]
@ (br l89)
        b      .l89
.ltorg
.l88:
@ (expr #t 2 #f (set! val_ (bitwise-and val_ 255)))
@ (imm)
@ (push 255)
@ (stack-ref-n 7)
        ldr    r2, [r10, $28]
@ (bitand)
@ * use immediate constant 255
        and    r0, r2, $255
@ (stack-set-n 7)
        str    r0, [r10, $28]
.l89:
.l87:
@ (expr #t 2 #f (vector-set! stack stack_idx val_))
@ (stack-ref-n 7)
        ldr    r0, [r10, $28]
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l55:
@ (expr #t 2 = (= eof_reached 1))
@ (imm)
@ (push 1)
@ (stack-ref-n 17)
        ldr    r2, [r10, $68]
@ (eq)
@ * use immediate constant 1
        cmp    r2, $1
@ (bfl l90)
        bne    .l90
@ (expr #t 2 #f (vector-set! stack stack_idx 1))
@ (push 1)
        mov    r0, $1
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (br l91)
        b      .l91
.ltorg
.l90:
@ (expr #t 2 #f (vector-set! stack stack_idx 0))
@ (push 0)
        mov    r0, $0
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
.l91:
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l56:
@ (expr #t 2 #f (set! temp (vector-ref stack (- stack_idx 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 1 #f (set! done_displaying_int 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 16)
        str    r0, [r10, $64]
@ (expr #t 2 < (< temp 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (lt)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l92)
        bge    .l92
@ (expr #f 0 #f (my_putchar 45))
@ (push 45)
        mov    r5, $45
        str    r5, [r3], $4
@ (call my_putchar)
        bl     my_putchar
@ (expr #t 4 #f (&& (= (bitwise-and temp 65535) 0) (= (shr temp 16) (- 32768))))
@ (push 32768)
        ldr    r0, =N_32768
        ldr    r0, [r0]
@ (negate)
        mov    r1, $0
        sub    r0, r1, r0
@ (imm)
@ (push 16)
@ (stack-ref-n 13)
        ldr    r4, [r10, $52]
@ (shr)
@ * use immediate constant 16
        mov    r2, r4, asr $16
@ (eq)
        cmp    r2, r0
        moveq  r0, $1
        movne  r0, $0
@ (imm)
@ (push 0)
@ (push 65535)
        mov    r4, $1
        mov    r4, r4, lsl $16
        sub    r4, r4, $1
@ (stack-ref-n 13)
        ldr    r5, [r10, $52]
@ (bitand)
        and    r4, r5, r4
@ (eq)
@ * use immediate constant 0
        cmp    r4, $0
        moveq  r2, $1
        movne  r2, $0
@ (and)
        and    r0, r2, r0
@ (bfl l93)
        cmp    r0, $0
        beq    .l93
@ (expr #t 2 #f (vector-set! stack stack_idx 56))
@ (push 56)
        mov    r0, $56
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 52))
@ (push 52)
        mov    r0, $52
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 54))
@ (push 54)
        mov    r0, $54
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 51))
@ (push 51)
        mov    r0, $51
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 56))
@ (push 56)
        mov    r0, $56
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 52))
@ (push 52)
        mov    r0, $52
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 55))
@ (push 55)
        mov    r0, $55
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 52))
@ (push 52)
        mov    r0, $52
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 49))
@ (push 49)
        mov    r0, $49
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (vector-set! stack stack_idx 50))
@ (push 50)
        mov    r0, $50
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 1 #f (set! count 10))
@ (push 10)
        mov    r0, $10
@ (stack-set-n 15)
        str    r0, [r10, $60]
@ (expr #t 1 #f (set! temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 13)
        str    r0, [r10, $52]
.l95:
@ (expr #f 0 #f (my_putchar (vector-ref stack (- stack_idx 1))))
@ (imm)
@ (push 1)
        mov    r5, $1
        str    r5, [r3], $4
@ (stack-ref-n 4)
        ldr    r0, [r10, $16]
        str    r0, [r3], $4
@ (sub)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        sub    r4, r7, r5
        str    r4, [r3, $-4]
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (call my_putchar)
        bl     my_putchar
@ (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! temp (+ temp 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 < (< temp count))
@ (stack-ref-n 15)
        ldr    r0, [r10, $60]
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (lt)
        cmp    r2, r0
@ (bfl l96)
        bge    .l96
@ (br l95)
        b      .l95
.ltorg
.l96:
@ (expr #t 1 #f (set! done_displaying_int 1))
@ (push 1)
        mov    r0, $1
@ (stack-set-n 16)
        str    r0, [r10, $64]
.l93:
@ (expr #t 1 #f (! done_displaying_int))
@ (stack-ref-n 16)
        ldr    r0, [r10, $64]
@ (not)
        cmp    r0, $0
        moveq  r0, $1
        movne  r0, $0
@ (bfl l97)
        cmp    r0, $0
        beq    .l97
@ (expr #t 1 #f (set! temp (- temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (negate)
        mov    r1, $0
        sub    r0, r1, r0
@ (stack-set-n 13)
        str    r0, [r10, $52]
.l97:
.l92:
@ (expr #t 1 #f (! done_displaying_int))
@ (stack-ref-n 16)
        ldr    r0, [r10, $64]
@ (not)
        cmp    r0, $0
        moveq  r0, $1
        movne  r0, $0
@ (bfl l98)
        cmp    r0, $0
        beq    .l98
@ (expr #t 1 #f (set! count 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 15)
        str    r0, [r10, $60]
.l99:
@ (expr #f 0 #f (vector-set! stack stack_idx (+ (remainder temp 10) 48)))
@ (imm)
@ (push 48)
        mov    r5, $48
        str    r5, [r3], $4
@ (push 10)
        mov    r5, $10
        str    r5, [r3], $4
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (mod)
        ldr    r0, [r3, $-4]!
        ldr    r1, [r3, $-4]
        bl     signed_remainder
        str    r0, [r3, $-4]
@ (add)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        add    r4, r7, r5
        str    r4, [r3, $-4]
@ (stack-ref-n 4)
        ldr    r0, [r10, $16]
        str    r0, [r3], $4
@ (stack-set)
        ldr    r4, [r3, $-8]!
        ldr    r6, [r3, $4]
        str    r4, [r8, r6, lsl $2]
@ (expr #f 0 #f (set! temp (quotient temp 10)))
@ (push 10)
        mov    r5, $10
        str    r5, [r3], $4
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (div)
        ldr    r0, [r3, $-4]!
        ldr    r1, [r3, $-4]
        bl     signed_quotient
        str    r0, [r3, $-4]
@ (stack-set-n 13)
        ldr    r0, [r3, $-4]!
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! count (+ count 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 15)
        ldr    r2, [r10, $60]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 15)
        str    r0, [r10, $60]
@ (expr #t 2 != (!= temp 0))
@ (imm)
@ (push 0)
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (ne)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l100)
        beq    .l100
@ (br l99)
        b      .l99
.ltorg
.l100:
@ (expr #t 1 #f (set! temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 13)
        str    r0, [r10, $52]
.l101:
@ (expr #f 0 #f (my_putchar (vector-ref stack (- stack_idx 1))))
@ (imm)
@ (push 1)
        mov    r5, $1
        str    r5, [r3], $4
@ (stack-ref-n 4)
        ldr    r0, [r10, $16]
        str    r0, [r3], $4
@ (sub)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        sub    r4, r7, r5
        str    r4, [r3, $-4]
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (call my_putchar)
        bl     my_putchar
@ (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! temp (+ temp 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 < (< temp count))
@ (stack-ref-n 15)
        ldr    r0, [r10, $60]
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (lt)
        cmp    r2, r0
@ (bfl l102)
        bge    .l102
@ (br l101)
        b      .l101
.ltorg
.l102:
.l98:
@ (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l57:
@ (expr #f 0 #f (my_putchar 10))
@ (push 10)
        mov    r5, $10
        str    r5, [r3], $4
@ (call my_putchar)
        bl     my_putchar
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l58:
@ (expr #f 0 #f (exit 0))
@ (push 0)
        mov    r5, $0
        str    r5, [r3], $4
@ (exit)
        b      _cleanup
@ (br l15)
        b      .l15
.ltorg
.l59:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #f 0 #f (my_putchar (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
        str    r0, [r3], $4
@ (stack-ref)
        sub    r0, r3, $4
        ldr    r5, [r0]
        ldr    r6, [r8, r5, lsl $2]
        str    r6, [r0]
@ (call my_putchar)
        bl     my_putchar
@ (expr #t 1 #f (set! stack_idx temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l60:
@ (expr #t 2 #f (set! temp (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 1 #f (set! n (vector-ref stack temp)))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 9)
        str    r0, [r10, $36]
@ (expr #t 1 #f (set! stack_idx temp))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 3 #f (set! pc (vector-ref code (+ (+ pc n) 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 9)
        ldr    r2, [r10, $36]
@ (stack-ref-n 2)
        ldr    r4, [r10, $8]
@ (add)
        add    r2, r4, r2
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l61:
@ (expr #t 2 #f (vector-set! stack stack_idx (vector-ref stack (+ frame_start (vector-ref code (+ pc 1))))))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 5)
        ldr    r2, [r10, $20]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l62:
@ (expr #t 3 #f (vector-set! stack (+ frame_start (vector-ref code (+ pc 1))) (vector-ref stack (- stack_idx 1))))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r4, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r2, r4, $1
@ (push 21000000)
        ldr    r4, =N_21000000
        ldr    r4, [r4]
@ (add)
        add    r2, r4, r2
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (stack-ref-n 5)
        ldr    r4, [r10, $20]
@ (add)
        add    r2, r4, r2
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l63:
@ (expr #f 0 #f (exit 0))
@ (push 0)
        mov    r5, $0
        str    r5, [r3], $4
@ (exit)
        b      _cleanup
@ (br l15)
        b      .l15
.ltorg
.l64:
@ (expr #t 2 #f (set! temp (- stack_idx 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-set-n 13)
        str    r0, [r10, $52]
@ (expr #t 2 #f (set! temp2 (- stack_idx 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 4)
        ldr    r2, [r10, $16]
@ (sub)
@ * use immediate constant 1
        sub    r0, r2, $1
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (expr #t 2 #f (vector-set! stack temp (bitwise-xor (vector-ref stack temp2) (vector-ref stack temp))))
@ (stack-ref-n 13)
        ldr    r0, [r10, $52]
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (bitxor)
        eor    r0, r2, r0
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (stack-set)
        str    r0, [r8, r2, lsl $2]
@ (expr #t 1 #f (set! stack_idx temp2))
@ (stack-ref-n 14)
        ldr    r0, [r10, $56]
@ (stack-set-n 4)
        str    r0, [r10, $16]
@ (expr #t 2 #f (set! pc (+ pc 1)))
@ (imm)
@ (push 1)
@ (stack-ref-n 2)
        ldr    r2, [r10, $8]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        ldr    r2, =N_21000000
        ldr    r2, [r2]
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l15)
        b      .l15
.ltorg
.l17:
@ (brtable (0 l19) (1 l20) (2 l21) (3 l22) (4 l23) (5 l24) (6 l25) (7 l26) (8 l27) (9 l28) (10 l29) (11 l30) (12 l31) (13 l32) (14 l33) (15 l34) (16 l35) (17 l36) (18 l37) (19 l38) (20 l39) (21 l40) (22 l41) (23 l42) (24 l43) (25 l44) (26 l45) (27 l46) (28 l47) (29 l48) (30 l49) (31 l50) (32 l51) (33 l52) (34 l53) (35 l54) (36 l55) (37 l56) (38 l57) (39 l58) (40 l59) (41 l60) (42 l61) (43 l62) (44 l63) (45 l64))
        ldr    r0, [r3, $-4]!
        ldr    r1, =.l105
        add    pc, r1, r0, lsl $2
.l105:
        b      .l19
        b      .l20
        b      .l21
        b      .l22
        b      .l23
        b      .l24
        b      .l25
        b      .l26
        b      .l27
        b      .l28
        b      .l29
        b      .l30
        b      .l31
        b      .l32
        b      .l33
        b      .l34
        b      .l35
        b      .l36
        b      .l37
        b      .l38
        b      .l39
        b      .l40
        b      .l41
        b      .l42
        b      .l43
        b      .l44
        b      .l45
        b      .l46
        b      .l47
        b      .l48
        b      .l49
        b      .l50
        b      .l51
        b      .l52
        b      .l53
        b      .l54
        b      .l55
        b      .l56
        b      .l57
        b      .l58
        b      .l59
        b      .l60
        b      .l61
        b      .l62
        b      .l63
        b      .l64
.l18:
@ (br l15)
        b      .l15
.ltorg
@ (expr #t 1 #f (return 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 0)
        str    r0, [r10]
@ (function-end 19)
        add    r3, r10, $4
        ldr    r10, [r10, $76]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
@X@N_1701996140:
@X@.word 1701996140
@X@N_1797287798:
@X@.word 1797287798
@X@N_1937006947:
@X@.word 1937006947
@X@N_50000:
@X@.word 50000
@X@N_876098358:
@X@.word 876098358
@X@N_842085431:
@X@.word 842085431
@X@N_32768:
@X@.word 32768
@X@N_21050000:
@X@.word 21050000
@X@N_21000000:
@X@.word 21000000
@X@N_21100000:
@X@.word 21100000
@X@N_21100005:
@X@.word 21100005