@ (top-level-begin 0 21100005)
        mov    r10, r8
        movw   r4, #62949
        movt   r4, #321
        mov    r4, r4, lsl $2
        add    r3, r10, r4
@ (call __main)
        bl     __main
@ (exit)
        b      _cleanup
__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 #t 2 #f (set! ch (bitwise-and ch 255)))
@ (imm)
@ (push 255)
@ (stack-ref-n 0)
        ldr    r2, [r10]
@ (bitand)
@ * use immediate constant 255
        and    r0, r2, $255
@ (stack-set-n 0)
        str    r0, [r10]
@ (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)
        ldr    r0, =eof_reached
        ldr    r0, [r0]
        cmp    r0, $0
        bne    .l102
        bl     _read_char
        b      .l103
.ltorg
.l102:
        ldr    r0, =in_ch
        mvn    r1, $0
        str    r1, [r0]
.l103:
        ldr    r1, =in_ch
        ldr    r1, [r1]
        str    r1, [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)
        movw  r2, #62944
        movt  r2, #321
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (eq)
        cmp    r2, r0
@ (bfl l0)
        bne    .l0
@ (expr #f 0 #f (return-from-procedure))
@ (proc-end 0)
        mov    r3, r10
        ldr    r10, [r10]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
.l0:
@ (expr #f 0 #f (set! ch (getchar)))
@ (read-char)
        ldr    r0, =eof_reached
        ldr    r0, [r0]
        cmp    r0, $0
        bne    .l104
        bl     _read_char
        b      .l105
.ltorg
.l104:
        ldr    r0, =in_ch
        mvn    r1, $0
        str    r1, [r0]
.l105:
        ldr    r1, =in_ch
        ldr    r1, [r1]
        str    r1, [r3], $4
@ (push 21100000)
        movw  r5, #62944
        movt  r5, #321
        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
.l1:
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]
.l2:
@ (expr #t 4 #f (|| (|| (= ch 32) (= ch 10)) (= ch 13)))
@ (imm)
@ (push 13)
@ (push 21100000)
        movw  r2, #62944
        movt  r2, #321
@ (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)
        movw  r4, #62944
        movt  r4, #321
@ (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)
        movw  r5, #62944
        movt  r5, #321
@ (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 l3)
        cmp    r0, $0
        beq    .l3
@ (expr #f 0 #f (set! ch (getchar)))
@ (read-char)
        ldr    r0, =eof_reached
        ldr    r0, [r0]
        cmp    r0, $0
        bne    .l106
        bl     _read_char
        b      .l107
.ltorg
.l106:
        ldr    r0, =in_ch
        mvn    r1, $0
        str    r1, [r0]
.l107:
        ldr    r1, =in_ch
        ldr    r1, [r1]
        str    r1, [r3], $4
@ (push 21100000)
        movw  r5, #62944
        movt  r5, #321
        str    r5, [r3], $4
@ (stack-set)
        ldr    r4, [r3, $-8]!
        ldr    r6, [r3, $4]
        str    r4, [r8, r6, lsl $2]
@ (br l2)
        b      .l2
.ltorg
.l3:
@ (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)
        movw  r2, #62944
        movt  r2, #321
@ (stack-ref)
        ldr    r2, [r8, r2, lsl $2]
@ (eq)
@ * use immediate constant 45
        cmp    r2, $45
@ (bfl l4)
        bne    .l4
@ (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_
.l4:
.l5:
@ (expr #t 3 #f (&& (>= ch 48) (<= ch 57)))
@ (imm)
@ (push 57)
@ (push 21100000)
        movw  r2, #62944
        movt  r2, #321
@ (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)
        movw  r4, #62944
        movt  r4, #321
@ (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 l6)
        cmp    r0, $0
        beq    .l6
@ (expr #t 4 #f (set! sum (- (+ (* sum 10) ch) 48)))
@ (imm)
@ (push 48)
@ (push 21100000)
        movw  r2, #62944
        movt  r2, #321
@ (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 l5)
        b      .l5
.ltorg
.l6:
@ (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 l7)
        bne    .l7
@ (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]
.l7:
@ (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 21 20)
        stmfd  sp!, {fp, lr}
        add    fp, sp, $4
        mov    r1, r10
        sub    r10, r3, $0
        add    r3, r10, $84
        add    r0, r10, $80
        str    r1, [r0]
@ (expr #t 2 #f (set! ch 32))
@ (push 32)
        mov    r0, $32
@ (push 21100000)
        movw  r2, #62944
        movt  r2, #321
@ (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 18)
        str    r0, [r10, $72]
@ (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]
.l8:
@ (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 l9)
        bge    .l9
@ (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)
        movw  r4, #28480
        movt  r4, #320
@ (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 l8)
        b      .l8
.ltorg
.l9:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
.l10:
@ (expr #f 0 #f opcode)
@ (stack-ref-n 3)
        ldr    r0, [r10, $12]
        str    r0, [r3], $4
@ (br l12)
        b      .l12
.ltorg
.l14:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l15:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l16:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l17:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l18:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l19:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l20:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l21:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l22:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l23:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l24:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l26:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l27:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l28:
@ (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    .l108
        mov    r0, $0
        sub    r5, r0, r5
        str    r5, [r4]
.l108:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l29:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 #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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 #t 2 #f (vector-set! stack temp (bitwise-or (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l33:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l35:
@ (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 l63)
        beq    .l63
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (br l64)
        b      .l64
.ltorg
.l63:
@ (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]
.l64:
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l36:
@ (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 l65)
        bne    .l65
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 2)
        str    r0, [r10, $8]
@ (br l66)
        b      .l66
.ltorg
.l65:
@ (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]
.l66:
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l37:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 = (= (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 l67)
        bne    .l67
@ (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 l68)
        b      .l68
.ltorg
.l67:
@ (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]
.l68:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l39:
@ (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 l69)
        bge    .l69
@ (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 l70)
        b      .l70
.ltorg
.l69:
@ (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]
.l70:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l40:
@ (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 l71)
        ble    .l71
@ (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 l72)
        b      .l72
.ltorg
.l71:
@ (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]
.l72:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l41:
@ (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 l74)
        bgt    .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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l42:
@ (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 l76)
        blt    .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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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]
@ (ne)
        cmp    r2, r0
@ (bfl l78)
        beq    .l78
@ (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 l79)
        b      .l79
.ltorg
.l78:
@ (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]
.l79:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l44:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 #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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.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 #f (vector-set! stack temp (bitwise-or (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l47:
@ (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)
        movw  r4, #12944
        movt  r4, #321
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r0, #50000
@ (stack-ref-n 6)
        ldr    r2, [r10, $24]
@ (eq)
        cmp    r2, r0
@ (bfl l81)
        bne    .l81
@ (write-string 14 29811 25441 8299 30319 29285 27750 30575)
        mov    r5, $115
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $116
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $97
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $99
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $107
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $32
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $111
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $118
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $101
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $114
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $102
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $108
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $111
        str    r5, [r3], $4
        ldr    r2, [r3, $-4]!
        bl     _print_character
        mov    r5, $119
        str    r5, [r3], $4
        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
.l81:
@ (expr #t 2 #f (set! opcode (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l48:
@ (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)
        movw  r2, #12944
        movt  r2, #321
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l49:
@ (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 18)
        ldr    r2, [r10, $72]
@ (eq)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l82)
        bne    .l82
@ (expr #f 0 #f (set! val (getchar)))
@ (read-char)
        ldr    r0, =eof_reached
        ldr    r0, [r0]
        cmp    r0, $0
        bne    .l109
        bl     _read_char
        b      .l110
.ltorg
.l109:
        ldr    r0, =in_ch
        mvn    r1, $0
        str    r1, [r0]
.l110:
        ldr    r1, =in_ch
        ldr    r1, [r1]
        str    r1, [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 l83)
        bne    .l83
@ (expr #t 1 #f (set! eof_reached 1))
@ (push 1)
        mov    r0, $1
@ (stack-set-n 18)
        str    r0, [r10, $72]
@ (br l84)
        b      .l84
.ltorg
.l83:
@ (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]
.l84:
.l82:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l50:
@ (expr #t 2 = (= eof_reached 1))
@ (imm)
@ (push 1)
@ (stack-ref-n 18)
        ldr    r2, [r10, $72]
@ (eq)
@ * use immediate constant 1
        cmp    r2, $1
@ (bfl l85)
        bne    .l85
@ (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 l86)
        b      .l86
.ltorg
.l85:
@ (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]
.l86:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l51:
@ (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 17)
        str    r0, [r10, $68]
@ (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 l87)
        bge    .l87
@ (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)
        movw  r0, #32768
@ (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 l88)
        cmp    r0, $0
        beq    .l88
@ (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 16)
        str    r0, [r10, $64]
@ (expr #t 1 #f (set! temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 13)
        str    r0, [r10, $52]
.l90:
@ (expr #t 2 < (< temp count))
@ (stack-ref-n 16)
        ldr    r0, [r10, $64]
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (lt)
        cmp    r2, r0
@ (bfl l91)
        bge    .l91
@ (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]
@ (br l90)
        b      .l90
.ltorg
.l91:
@ (expr #t 1 #f (set! done_displaying_int 1))
@ (push 1)
        mov    r0, $1
@ (stack-set-n 17)
        str    r0, [r10, $68]
.l88:
@ (expr #t 1 #f (! done_displaying_int))
@ (stack-ref-n 17)
        ldr    r0, [r10, $68]
@ (not)
        cmp    r0, $0
        moveq  r0, $1
        movne  r0, $0
@ (bfl l92)
        cmp    r0, $0
        beq    .l92
@ (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]
.l92:
.l87:
@ (expr #t 1 #f (! done_displaying_int))
@ (stack-ref-n 17)
        ldr    r0, [r10, $68]
@ (not)
        cmp    r0, $0
        moveq  r0, $1
        movne  r0, $0
@ (bfl l93)
        cmp    r0, $0
        beq    .l93
@ (expr #t 1 #f (set! count 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 16)
        str    r0, [r10, $64]
.l94:
@ (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 16)
        ldr    r2, [r10, $64]
@ (add)
@ * use immediate constant 1
        add    r0, r2, $1
@ (stack-set-n 16)
        str    r0, [r10, $64]
@ (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 l95)
        beq    .l95
@ (br l94)
        b      .l94
.ltorg
.l95:
@ (expr #t 1 #f (set! temp 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 13)
        str    r0, [r10, $52]
.l96:
@ (expr #t 2 < (< temp count))
@ (stack-ref-n 16)
        ldr    r0, [r10, $64]
@ (stack-ref-n 13)
        ldr    r2, [r10, $52]
@ (lt)
        cmp    r2, r0
@ (bfl l97)
        bge    .l97
@ (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]
@ (br l96)
        b      .l96
.ltorg
.l97:
.l93:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l52:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l53:
@ (expr #f 0 #f (exit 0))
@ (push 0)
        mov    r5, $0
        str    r5, [r3], $4
@ (exit)
        b      _cleanup
@ (br l10)
        b      .l10
.ltorg
.l54:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l55:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l56:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l57:
@ (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)
        movw  r4, #28480
        movt  r4, #320
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l58:
@ (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! count (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 16)
        str    r0, [r10, $64]
@ (expr #t 1 #f (set! temp2 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (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]
.l99:
@ (expr #t 2 < (< temp2 (- count 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 16)
        ldr    r2, [r10, $64]
@ (sub)
@ * use immediate constant 2
        sub    r0, r2, $2
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (lt)
        cmp    r2, r0
@ (bfl l100)
        bge    .l100
@ (expr #t 2 #f (set! temp3 (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 15)
        str    r0, [r10, $60]
@ (expr #f 0 #f (my_putchar (bitwise-and temp3 255)))
@ (imm)
@ (push 255)
        mov    r5, $255
        str    r5, [r3], $4
@ (stack-ref-n 15)
        ldr    r0, [r10, $60]
        str    r0, [r3], $4
@ (bitand)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        and    r4, r7, r5
        str    r4, [r3, $-4]
@ (call my_putchar)
        bl     my_putchar
@ (expr #f 0 #f (my_putchar (bitwise-and (shr temp3 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 15)
        ldr    r0, [r10, $60]
        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]
@ (call my_putchar)
        bl     my_putchar
@ (expr #t 2 #f (set! temp2 (+ temp2 2)))
@ (imm)
@ (push 2)
@ (stack-ref-n 14)
        ldr    r2, [r10, $56]
@ (add)
@ * use immediate constant 2
        add    r0, r2, $2
@ (stack-set-n 14)
        str    r0, [r10, $56]
@ (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]
@ (br l99)
        b      .l99
.ltorg
.l100:
@ (expr #t 2 #f (set! temp3 (vector-ref code pc)))
@ (stack-ref-n 2)
        ldr    r0, [r10, $8]
@ (push 21000000)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 15)
        str    r0, [r10, $60]
@ (expr #f 0 #f (my_putchar (bitwise-and temp3 255)))
@ (imm)
@ (push 255)
        mov    r5, $255
        str    r5, [r3], $4
@ (stack-ref-n 15)
        ldr    r0, [r10, $60]
        str    r0, [r3], $4
@ (bitand)
        ldr    r7, [r3, $-4]!
        ldr    r5, [r3, $-4]
        and    r4, r7, r5
        str    r4, [r3, $-4]
@ (call my_putchar)
        bl     my_putchar
@ (expr #t 3 = (= (bitwise-and count 1) 0))
@ (imm)
@ (push 0)
@ (imm)
@ (push 1)
@ (stack-ref-n 16)
        ldr    r4, [r10, $64]
@ (bitand)
@ * use immediate constant 1
        and    r2, r4, $1
@ (eq)
@ * use immediate constant 0
        cmp    r2, $0
@ (bfl l101)
        bne    .l101
@ (expr #f 0 #f (my_putchar (bitwise-and (shr temp3 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 15)
        ldr    r0, [r10, $60]
        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]
@ (call my_putchar)
        bl     my_putchar
.l101:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l59:
@ (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)
        movw  r2, #28480
        movt  r2, #320
@ (add)
        add    r0, r2, r0
@ (stack-ref)
        ldr    r0, [r8, r0, lsl $2]
@ (stack-set-n 3)
        str    r0, [r10, $12]
@ (br l10)
        b      .l10
.ltorg
.l12:
@ (brtable (0 l14) (1 l15) (2 l16) (3 l17) (4 l18) (5 l19) (6 l20) (7 l21) (8 l22) (9 l23) (10 l24) (11 l25) (12 l26) (13 l27) (14 l28) (15 l29) (16 l30) (17 l31) (18 l32) (19 l33) (20 l34) (21 l35) (22 l36) (23 l37) (24 l38) (25 l39) (26 l40) (27 l41) (28 l42) (29 l43) (30 l44) (31 l45) (32 l46) (33 l47) (34 l48) (35 l49) (36 l50) (37 l51) (38 l52) (39 l53) (40 l54) (41 l55) (42 l56) (43 l57) (44 l58) (45 l59))
        ldr    r0, [r3, $-4]!
        ldr    r1, =.l111
        add    pc, r1, r0, lsl $2
.l111:
        b      .l14
        b      .l15
        b      .l16
        b      .l17
        b      .l18
        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
.l13:
@ (br l10)
        b      .l10
.ltorg
@ (expr #t 1 #f (return 0))
@ (push 0)
        mov    r0, $0
@ (stack-set-n 0)
        str    r0, [r10]
@ (function-end 20)
        add    r3, r10, $4
        ldr    r10, [r10, $80]
@ (return)
        ldmfd  sp!, {fp, pc}
.ltorg
