; (top-level-begin 0 21100005)
        mov    eax, stack
        mov    esi, eax
        mov    ebp, eax
        add    eax, 21100005 * 4
        mov    edi, eax
; (call __main)
        call   __main
; (exit)
        call   _my_exit
__mult:
; (function-proc-begin 2 4 3)
        mov    ecx, ebp
        mov    edx, edi
        sub    edx, 4 * 2
        mov    ebp, edx
        add    edi, 4 * 4
        add    edx, 4 * 3
        mov    [edx], ecx
; (expr #f 0 #f (return (* x y)))
; (stack-ref-n 1)
        mov    eax, [ebp + 4]
        mov    [edi], eax
        add    edi, 4
; (stack-ref-n 0)
        mov    eax, [ebp]
        mov    [edi], eax
        add    edi, 4
; (mul)
        call   my_mul
; (stack-set-n 0)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp], edx
; (function-end 3)
        mov    edi, ebp
        add    edi, 4
        add    ebp, 4 * 3
        mov    ebp, [ebp]
; (return)
        ret    
__div:
; (function-proc-begin 2 4 3)
        mov    ecx, ebp
        mov    edx, edi
        sub    edx, 4 * 2
        mov    ebp, edx
        add    edi, 4 * 4
        add    edx, 4 * 3
        mov    [edx], ecx
; (expr #f 0 #f (return (quotient x y)))
; (stack-ref-n 1)
        mov    eax, [ebp + 4]
        mov    [edi], eax
        add    edi, 4
; (stack-ref-n 0)
        mov    eax, [ebp]
        mov    [edi], eax
        add    edi, 4
; (div)
        call   my_div
; (stack-set-n 0)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp], edx
; (function-end 3)
        mov    edi, ebp
        add    edi, 4
        add    ebp, 4 * 3
        mov    ebp, [ebp]
; (return)
        ret    
my_putchar:
; (function-proc-begin 1 2 1)
        mov    ecx, ebp
        mov    edx, edi
        sub    edx, 4 * 1
        mov    ebp, edx
        add    edi, 4 * 2
        add    edx, 4 * 1
        mov    [edx], ecx
; (expr #t 2 #f (set! ch (bitwise-and ch 255)))
; (imm)
; (push 255)
; (stack-ref-n 0)
        mov    ebx, [ebp]
; (bitand)
; * use immediate constant 255
        and    ebx, 255
        mov    eax, ebx
; (stack-set-n 0)
        mov    [ebp], eax
; (expr #f 0 #f (putchar ch))
; (stack-ref-n 0)
        mov    eax, [ebp]
        mov    [edi], eax
        add    edi, 4
; (write-char)
        call   _write_char
; (expr #f 0 #f (return-from-procedure))
; (proc-end 1)
        mov    edi, ebp
        add    ebp, 4 * 1
        mov    ebp, [ebp]
; (return)
        ret    
my_fgetc:
; (function-proc-begin 0 2 1)
        mov    ecx, ebp
        mov    edx, edi
        mov    ebp, edx
        add    edi, 4 * 2
        add    edx, 4 * 1
        mov    [edx], ecx
; (expr #f 0 #f (return (getchar)))
; (read-char)
        call   _read_char
        mov    [edi], eax
        add    edi, 4
; (stack-set-n 0)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp], edx
; (function-end 1)
        mov    edi, ebp
        add    edi, 4
        add    ebp, 4 * 1
        mov    ebp, [ebp]
; (return)
        ret    
read_char_:
; (function-proc-begin 0 1 0)
        mov    ecx, ebp
        mov    edx, edi
        mov    ebp, edx
        add    edi, 4 * 1
        mov    [edx], ecx
; (expr #t 2 = (= ch (- 1)))
; (push 1)
        mov    eax, 1
; (negate)
        neg    eax
; (push 21100000)
        mov    ebx, 21100000
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (eq)
        cmp    ebx, eax
; (bfl l0)
        jne      .l0
; (expr #f 0 #f (return-from-procedure))
; (proc-end 0)
        mov    edi, ebp
        mov    ebp, [ebp]
; (return)
        ret    
.l0:
; (expr #f 0 #f (set! ch (getchar)))
; (read-char)
        call   _read_char
        mov    [edi], eax
        add    edi, 4
; (push 21100000)
        mov    dword [edi], 21100000
        add    edi, 4
; (stack-set)
        sub    edi, 8
        mov    ecx, [edi]
        mov    edx, [edi + 4]
        mov    [esi + edx * 4], ecx
; (expr #f 0 #f (return-from-procedure))
; (proc-end 0)
        mov    edi, ebp
        mov    ebp, [ebp]
; (return)
        ret    
.l1:
skip_blanks:
; (function-proc-begin 0 1 0)
        mov    ecx, ebp
        mov    edx, edi
        mov    ebp, edx
        add    edi, 4 * 1
        mov    [edx], ecx
.l2:
; (expr #t 4 #f (|| (|| (= ch 32) (= ch 10)) (= ch 13)))
; (imm)
; (push 13)
; (push 21100000)
        mov    ebx, 21100000
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (eq)
; * use immediate constant 13
        cmp    ebx, 13
        sete  al
        and    eax, 255
; (imm)
; (push 10)
; (push 21100000)
        mov    ecx, 21100000
; (stack-ref)
        mov    ecx, [esi + ecx * 4]
; (eq)
; * use immediate constant 10
        cmp    ecx, 10
        sete  bl
        and    ebx, 255
; (imm)
; (push 32)
; (push 21100000)
        mov    edx, 21100000
; (stack-ref)
        mov    edx, [esi + edx * 4]
; (eq)
; * use immediate constant 32
        cmp    edx, 32
        sete  cl
        and    ecx, 255
; (or)
        or     ecx, ebx
        mov    ebx, ecx
; (or)
        or     ebx, eax
        mov    eax, ebx
; (bfl l3)
        test   eax, eax
        je     .l3
; (expr #f 0 #f (set! ch (getchar)))
; (read-char)
        call   _read_char
        mov    [edi], eax
        add    edi, 4
; (push 21100000)
        mov    dword [edi], 21100000
        add    edi, 4
; (stack-set)
        sub    edi, 8
        mov    ecx, [edi]
        mov    edx, [edi + 4]
        mov    [esi + edx * 4], ecx
; (br l2)
        jmp    .l2
.l3:
; (expr #f 0 #f (return-from-procedure))
; (proc-end 0)
        mov    edi, ebp
        mov    ebp, [ebp]
; (return)
        ret    
my_scan_int:
; (function-proc-begin 0 4 3)
        mov    ecx, ebp
        mov    edx, edi
        mov    ebp, edx
        add    edi, 4 * 4
        add    edx, 4 * 3
        mov    [edx], ecx
; (expr #t 1 #f (set! sum 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 0)
        mov    [ebp], eax
; (expr #t 1 #f (set! negative 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 1)
        mov    [ebp + 4], eax
; (expr #f 0 #f (skip_blanks))
; (call skip_blanks)
        call   skip_blanks
; (expr #t 2 = (= ch 45))
; (imm)
; (push 45)
; (push 21100000)
        mov    ebx, 21100000
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (eq)
; * use immediate constant 45
        cmp    ebx, 45
; (bfl l4)
        jne      .l4
; (expr #t 1 #f (set! negative 1))
; (push 1)
        mov    eax, 1
; (stack-set-n 1)
        mov    [ebp + 4], eax
; (expr #f 0 #f (read_char_))
; (call read_char_)
        call   read_char_
.l4:
.l5:
; (expr #t 3 #f (&& (>= ch 48) (<= ch 57)))
; (imm)
; (push 57)
; (push 21100000)
        mov    ebx, 21100000
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (le)
; * use immediate constant 57
        cmp    ebx, 57
        setle al
        and    eax, 255
; (imm)
; (push 48)
; (push 21100000)
        mov    ecx, 21100000
; (stack-ref)
        mov    ecx, [esi + ecx * 4]
; (ge)
; * use immediate constant 48
        cmp    ecx, 48
        setge bl
        and    ebx, 255
; (and)
        and    ebx, eax
        mov    eax, ebx
; (bfl l6)
        test   eax, eax
        je     .l6
; (expr #f 0 #f (set! sum (- (+ (* sum 10) ch) 48)))
; (imm)
; (push 48)
        mov    dword [edi], 48
        add    edi, 4
; (push 21100000)
        mov    dword [edi], 21100000
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (push 10)
        mov    dword [edi], 10
        add    edi, 4
; (stack-ref-n 0)
        mov    eax, [ebp]
        mov    [edi], eax
        add    edi, 4
; (mul)
        call   my_mul
; (add)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        add    eax, ebx
        mov    [edi - 4], eax
; (sub)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        sub    eax, ebx
        mov    [edi - 4], eax
; (stack-set-n 0)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp], edx
; (expr #f 0 #f (read_char_))
; (call read_char_)
        call   read_char_
; (br l5)
        jmp    .l5
.l6:
; (expr #t 2 = (= negative 1))
; (imm)
; (push 1)
; (stack-ref-n 1)
        mov    ebx, [ebp + 4]
; (eq)
; * use immediate constant 1
        cmp    ebx, 1
; (bfl l7)
        jne      .l7
; (expr #t 1 #f (set! sum (- sum)))
; (stack-ref-n 0)
        mov    eax, [ebp]
; (negate)
        neg    eax
; (stack-set-n 0)
        mov    [ebp], eax
.l7:
; (expr #f 0 #f (return sum))
; (function-end 3)
        mov    edi, ebp
        add    edi, 4
        add    ebp, 4 * 3
        mov    ebp, [ebp]
; (return)
        ret    
__main:
; (function-proc-begin 0 21 20)
        mov    ecx, ebp
        mov    edx, edi
        mov    ebp, edx
        add    edi, 4 * 21
        add    edx, 4 * 20
        mov    [edx], ecx
; (expr #t 2 #f (set! ch 32))
; (push 32)
        mov    eax, 32
; (push 21100000)
        mov    ebx, 21100000
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx 1))
; (push 1)
        mov    eax, 1
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 1 #f (set! return_stack_idx 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 6)
        mov    [ebp + 24], eax
; (expr #t 1 #f (set! eof_reached 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 18)
        mov    [ebp + 72], eax
; (expr #t 1 #f (set! frame_start 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 5)
        mov    [ebp + 20], eax
; (expr #f 0 #f (set! temp (my_scan_int)))
; (call my_scan_int)
        call   my_scan_int
; (stack-set-n 13)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp + 4 * 13], edx
; (expr #t 1 #f (set! idx 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 0)
        mov    [ebp], eax
.l8:
; (expr #t 2 < (< idx temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref-n 0)
        mov    ebx, [ebp]
; (lt)
        cmp    ebx, eax
; (bfl l9)
        jge      .l9
; (expr #f 0 #f (set! word (my_scan_int)))
; (call my_scan_int)
        call   my_scan_int
; (stack-set-n 1)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp + 4 * 1], edx
; (expr #t 3 #f (vector-set! code idx word))
; (stack-ref-n 1)
        mov    eax, [ebp + 4]
; (stack-ref-n 0)
        mov    ebx, [ebp]
; (push 21000000)
        mov    ecx, 21000000
; (add)
        add    ecx, ebx
        mov    ebx, ecx
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! idx (+ idx 1)))
; (inc 0)
        inc dword [ebp + 0]
; (br l8)
        jmp    .l8
.l9:
; (expr #t 1 #f (set! pc 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
.l10:
; (expr #f 0 #f opcode)
; (stack-ref-n 3)
        mov    eax, [ebp + 12]
        mov    [edi], eax
        add    edi, 4
; (br l12)
        jmp    .l12
.l14:
; (expr #t 2 #f (set! frame_start (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 5)
        mov    [ebp + 20], eax
; (expr #t 2 #f (set! stack_idx (+ frame_start (vector-ref code (+ pc 2)))))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 5)
        mov    ebx, [ebp + 20]
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 3)))
; (imm)
; (push 3)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 3
        add    ebx, 3
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l15:
; (expr #t 2 #f (set! formals_offset (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 10)
        mov    [ebp + 40], eax
; (expr #t 2 #f (set! all_vars_size (vector-ref code (+ pc 2))))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 11)
        mov    [ebp + 44], eax
; (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 3))))
; (imm)
; (push 3)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 3
        add    ebx, 3
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 12)
        mov    [ebp + 48], eax
; (expr #t 1 #f (set! temp frame_start))
; (stack-ref-n 5)
        mov    eax, [ebp + 20]
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! frame_start (- stack_idx formals_offset)))
; (stack-ref-n 10)
        mov    eax, [ebp + 40]
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
        sub    ebx, eax
        mov    eax, ebx
; (stack-set-n 5)
        mov    [ebp + 20], eax
; (expr #t 2 #f (set! stack_idx (+ frame_start all_vars_size)))
; (stack-ref-n 11)
        mov    eax, [ebp + 44]
; (stack-ref-n 5)
        mov    ebx, [ebp + 20]
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 3 #f (vector-set! stack (+ frame_start dynamic_link) temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref-n 12)
        mov    ebx, [ebp + 48]
; (stack-ref-n 5)
        mov    ecx, [ebp + 20]
; (add)
        add    ecx, ebx
        mov    ebx, ecx
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! pc (+ pc 4)))
; (imm)
; (push 4)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 4
        add    ebx, 4
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l16:
; (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 12)
        mov    [ebp + 48], eax
; (expr #t 1 #f (set! temp (vector-ref stack frame_start)))
; (stack-ref-n 5)
        mov    eax, [ebp + 20]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 1 #f (set! stack_idx frame_start))
; (stack-ref-n 5)
        mov    eax, [ebp + 20]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! frame_start (vector-ref stack (+ frame_start dynamic_link))))
; (stack-ref-n 12)
        mov    eax, [ebp + 48]
; (stack-ref-n 5)
        mov    ebx, [ebp + 20]
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 5)
        mov    [ebp + 20], eax
; (expr #t 2 #f (vector-set! stack stack_idx temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l17:
; (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 12)
        mov    [ebp + 48], eax
; (expr #t 1 #f (set! stack_idx frame_start))
; (stack-ref-n 5)
        mov    eax, [ebp + 20]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! frame_start (vector-ref stack (+ frame_start dynamic_link))))
; (stack-ref-n 12)
        mov    eax, [ebp + 48]
; (stack-ref-n 5)
        mov    ebx, [ebp + 20]
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 5)
        mov    [ebp + 20], eax
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l18:
; (expr #t 2 #f (vector-set! stack stack_idx (+ frame_start (vector-ref code (+ pc 1)))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 5)
        mov    ebx, [ebp + 20]
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l19:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (vector-set! stack temp (vector-ref stack (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l20:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 3 #f (vector-set! stack (vector-ref stack (- stack_idx 1)) (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ecx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ecx, 1
        mov    ebx, ecx
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l21:
; (expr #t 2 #f (vector-set! stack stack_idx (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l22:
; (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
; (dec 4)
        dec dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l23:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (+ (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l24:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (- (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (sub)
        sub    ebx, eax
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l25:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #f 0 #f (vector-set! stack temp (* (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (mul)
        call   my_mul
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-set)
        sub    edi, 8
        mov    ecx, [edi]
        mov    edx, [edi + 4]
        mov    [esi + edx * 4], ecx
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l26:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #f 0 #f (vector-set! stack temp (quotient (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (div)
        call   my_div
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-set)
        sub    edi, 8
        mov    ecx, [edi]
        mov    edx, [edi + 4]
        mov    [esi + edx * 4], ecx
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l27:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #f 0 #f (vector-set! stack temp (remainder (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (mod)
        call   my_mod
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-set)
        sub    edi, 8
        mov    ecx, [edi]
        mov    edx, [edi + 4]
        mov    [esi + edx * 4], ecx
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l28:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #f 0 #f (vector-set! stack temp (abs (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (abs)
        call   my_abs
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-set)
        sub    edi, 8
        mov    ecx, [edi]
        mov    edx, [edi + 4]
        mov    [esi + edx * 4], ecx
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l29:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (vector-set! stack temp (- (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (negate)
        neg    eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l30:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (shl (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (shl)
        push  ebx
        push  ecx
        push  eax
        push  ebx
        sub    rsp, 4
        mov    ecx, [rsp + 8]
        mov    ebx, [rsp + 4]
        shl    ebx, cl
        mov    [rsp], ebx
        mov    ecx, [rsp + 12]
        mov    ebx, [rsp + 16]
        mov    eax, [rsp]
        add    rsp, 20
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l31:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (shr (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (shr)
        push  ebx
        push  ecx
        push  eax
        push  ebx
        sub    rsp, 4
        mov    ecx, [rsp + 8]
        mov    ebx, [rsp + 4]
        sar    ebx, cl
        mov    [rsp], ebx
        mov    ecx, [rsp + 12]
        mov    ebx, [rsp + 16]
        mov    eax, [rsp]
        add    rsp, 20
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l32:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (bitwise-or (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (bitor)
        or     ebx, eax
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l33:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (bitwise-and (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (bitand)
        and    ebx, eax
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l34:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (vector-set! stack temp (bitwise-not (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (bitnot)
        not    eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l35:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 1 #f (set! cc (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 8)
        mov    [ebp + 32], eax
; (expr #t 1 #f (set! stack_idx temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 != (!= cc 0))
; (imm)
; (push 0)
; (stack-ref-n 8)
        mov    ebx, [ebp + 32]
; (ne)
; * use immediate constant 0
        cmp    ebx, 0
; (bfl l60)
        je       .l60
; (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (br l61)
        jmp    .l61
.l60:
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
.l61:
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l36:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 1 #f (set! cc (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 8)
        mov    [ebp + 32], eax
; (expr #t 1 #f (set! stack_idx temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 = (= cc 0))
; (imm)
; (push 0)
; (stack-ref-n 8)
        mov    ebx, [ebp + 32]
; (eq)
; * use immediate constant 0
        cmp    ebx, 0
; (bfl l62)
        jne      .l62
; (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (br l63)
        jmp    .l63
.l62:
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
.l63:
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l37:
; (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l38:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 = (= (vector-ref stack temp2) (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (eq)
        cmp    ebx, eax
; (bfl l64)
        jne      .l64
; (expr #t 2 #f (vector-set! stack temp 1))
; (push 1)
        mov    eax, 1
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (br l65)
        jmp    .l65
.l64:
; (expr #t 2 #f (vector-set! stack temp 0))
; (push 0)
        xor    eax, eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
.l65:
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l39:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 < (< (vector-ref stack temp2) (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (lt)
        cmp    ebx, eax
; (bfl l66)
        jge      .l66
; (expr #t 2 #f (vector-set! stack temp 1))
; (push 1)
        mov    eax, 1
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (br l67)
        jmp    .l67
.l66:
; (expr #t 2 #f (vector-set! stack temp 0))
; (push 0)
        xor    eax, eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
.l67:
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l40:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 > (> (vector-ref stack temp2) (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (gt)
        cmp    ebx, eax
; (bfl l68)
        jle      .l68
; (expr #t 2 #f (vector-set! stack temp 1))
; (push 1)
        mov    eax, 1
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (br l69)
        jmp    .l69
.l68:
; (expr #t 2 #f (vector-set! stack temp 0))
; (push 0)
        xor    eax, eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
.l69:
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l41:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 <= (<= (vector-ref stack temp2) (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (le)
        cmp    ebx, eax
; (bfl l70)
        jg       .l70
; (expr #t 2 #f (vector-set! stack temp 1))
; (push 1)
        mov    eax, 1
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (br l71)
        jmp    .l71
.l70:
; (expr #t 2 #f (vector-set! stack temp 0))
; (push 0)
        xor    eax, eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
.l71:
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l42:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 >= (>= (vector-ref stack temp2) (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (ge)
        cmp    ebx, eax
; (bfl l72)
        jl       .l72
; (expr #t 2 #f (vector-set! stack temp 1))
; (push 1)
        mov    eax, 1
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (br l73)
        jmp    .l73
.l72:
; (expr #t 2 #f (vector-set! stack temp 0))
; (push 0)
        xor    eax, eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
.l73:
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l43:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 != (!= (vector-ref stack temp2) (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (ne)
        cmp    ebx, eax
; (bfl l74)
        je       .l74
; (expr #t 2 #f (vector-set! stack temp 1))
; (push 1)
        mov    eax, 1
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (br l75)
        jmp    .l75
.l74:
; (expr #t 2 #f (vector-set! stack temp 0))
; (push 0)
        xor    eax, eax
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
.l75:
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l44:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (vector-set! stack temp (bitwise-and (bitwise-not (vector-ref stack temp)) 1)))
; (imm)
; (push 1)
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (bitnot)
        not    ebx
; (bitand)
; * use immediate constant 1
        and    ebx, 1
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l45:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (bitwise-and (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (bitand)
        and    ebx, eax
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l46:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (bitwise-or (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (bitor)
        or     ebx, eax
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l47:
; (expr #t 3 #f (vector-set! return_stack return_stack_idx (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-ref-n 6)
        mov    ebx, [ebp + 24]
; (push 21050000)
        mov    ecx, 21050000
; (add)
        add    ecx, ebx
        mov    ebx, ecx
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! return_stack_idx (+ return_stack_idx 1)))
; (inc 6)
        inc dword [ebp + 24]
; (expr #t 2 = (= return_stack_idx 50000))
; (push 50000)
        mov    eax, 50000
; (stack-ref-n 6)
        mov    ebx, [ebp + 24]
; (eq)
        cmp    ebx, eax
; (bfl l76)
        jne      .l76
; (write-string 14 29811 25441 8299 30319 29285 27750 30575)
        mov    dword [edi], 115
        add    edi, 4
        call   _write_char
        mov    dword [edi], 116
        add    edi, 4
        call   _write_char
        mov    dword [edi], 97
        add    edi, 4
        call   _write_char
        mov    dword [edi], 99
        add    edi, 4
        call   _write_char
        mov    dword [edi], 107
        add    edi, 4
        call   _write_char
        mov    dword [edi], 32
        add    edi, 4
        call   _write_char
        mov    dword [edi], 111
        add    edi, 4
        call   _write_char
        mov    dword [edi], 118
        add    edi, 4
        call   _write_char
        mov    dword [edi], 101
        add    edi, 4
        call   _write_char
        mov    dword [edi], 114
        add    edi, 4
        call   _write_char
        mov    dword [edi], 102
        add    edi, 4
        call   _write_char
        mov    dword [edi], 108
        add    edi, 4
        call   _write_char
        mov    dword [edi], 111
        add    edi, 4
        call   _write_char
        mov    dword [edi], 119
        add    edi, 4
        call   _write_char
; (expr #f 0 #f (my_putchar 10))
; (push 10)
        mov    dword [edi], 10
        add    edi, 4
; (call my_putchar)
        call   my_putchar
; (expr #f 0 #f (exit 0))
; (push 0)
        mov    dword [edi], 0
        add    edi, 4
; (exit)
        call   _my_exit
.l76:
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l48:
; (expr #t 2 #f (set! pc (vector-ref return_stack (- return_stack_idx 1))))
; (imm)
; (push 1)
; (stack-ref-n 6)
        mov    ebx, [ebp + 24]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (push 21050000)
        mov    ebx, 21050000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! return_stack_idx (- return_stack_idx 1)))
; (dec 6)
        dec dword [ebp + 24]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l49:
; (expr #t 1 #f (set! val 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 7)
        mov    [ebp + 28], eax
; (expr #t 2 = (= eof_reached 0))
; (imm)
; (push 0)
; (stack-ref-n 18)
        mov    ebx, [ebp + 72]
; (eq)
; * use immediate constant 0
        cmp    ebx, 0
; (bfl l77)
        jne      .l77
; (expr #f 0 #f (set! val (getchar)))
; (read-char)
        call   _read_char
        mov    [edi], eax
        add    edi, 4
; (stack-set-n 7)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp + 4 * 7], edx
; (expr #t 2 = (= val (- 1)))
; (push 1)
        mov    eax, 1
; (negate)
        neg    eax
; (stack-ref-n 7)
        mov    ebx, [ebp + 28]
; (eq)
        cmp    ebx, eax
; (bfl l78)
        jne      .l78
; (expr #t 1 #f (set! eof_reached 1))
; (push 1)
        mov    eax, 1
; (stack-set-n 18)
        mov    [ebp + 72], eax
; (br l79)
        jmp    .l79
.l78:
; (expr #t 2 #f (set! val (bitwise-and val 255)))
; (imm)
; (push 255)
; (stack-ref-n 7)
        mov    ebx, [ebp + 28]
; (bitand)
; * use immediate constant 255
        and    ebx, 255
        mov    eax, ebx
; (stack-set-n 7)
        mov    [ebp + 28], eax
.l79:
.l77:
; (expr #t 2 #f (vector-set! stack stack_idx val))
; (stack-ref-n 7)
        mov    eax, [ebp + 28]
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l50:
; (expr #t 2 = (= eof_reached 1))
; (imm)
; (push 1)
; (stack-ref-n 18)
        mov    ebx, [ebp + 72]
; (eq)
; * use immediate constant 1
        cmp    ebx, 1
; (bfl l80)
        jne      .l80
; (expr #t 2 #f (vector-set! stack stack_idx 1))
; (push 1)
        mov    eax, 1
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (br l81)
        jmp    .l81
.l80:
; (expr #t 2 #f (vector-set! stack stack_idx 0))
; (push 0)
        xor    eax, eax
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
.l81:
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l51:
; (expr #t 2 #f (set! temp (vector-ref stack (- stack_idx 1))))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 1 #f (set! done_displaying_int 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 17)
        mov    [ebp + 68], eax
; (expr #t 2 < (< temp 0))
; (imm)
; (push 0)
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (lt)
; * use immediate constant 0
        cmp    ebx, 0
; (bfl l82)
        jge      .l82
; (expr #f 0 #f (my_putchar 45))
; (push 45)
        mov    dword [edi], 45
        add    edi, 4
; (call my_putchar)
        call   my_putchar
; (expr #t 4 #f (&& (= (bitwise-and temp 65535) 0) (= (shr temp 16) (- 32768))))
; (push 32768)
        mov    eax, 32768
; (negate)
        neg    eax
; (imm)
; (push 16)
; (stack-ref-n 13)
        mov    ecx, [ebp + 52]
; (shr)
; * use immediate constant 16
        sar    ecx, 16
        mov    ebx, ecx
; (eq)
        cmp    ebx, eax
        sete  al
        and    eax, 255
; (imm)
; (push 0)
; (push 65535)
        mov    ecx, 65535
; (stack-ref-n 13)
        mov    edx, [ebp + 52]
; (bitand)
        and    edx, ecx
        mov    ecx, edx
; (eq)
; * use immediate constant 0
        cmp    ecx, 0
        sete  bl
        and    ebx, 255
; (and)
        and    ebx, eax
        mov    eax, ebx
; (bfl l83)
        test   eax, eax
        je     .l83
; (expr #t 2 #f (vector-set! stack stack_idx 56))
; (push 56)
        mov    eax, 56
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 52))
; (push 52)
        mov    eax, 52
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 54))
; (push 54)
        mov    eax, 54
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 51))
; (push 51)
        mov    eax, 51
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 56))
; (push 56)
        mov    eax, 56
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 52))
; (push 52)
        mov    eax, 52
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 55))
; (push 55)
        mov    eax, 55
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 52))
; (push 52)
        mov    eax, 52
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 49))
; (push 49)
        mov    eax, 49
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (vector-set! stack stack_idx 50))
; (push 50)
        mov    eax, 50
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 1 #f (set! count 10))
; (push 10)
        mov    eax, 10
; (stack-set-n 16)
        mov    [ebp + 64], eax
; (expr #t 1 #f (set! temp 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 13)
        mov    [ebp + 52], eax
.l84:
; (expr #t 2 < (< temp count))
; (stack-ref-n 16)
        mov    eax, [ebp + 64]
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (lt)
        cmp    ebx, eax
; (bfl l85)
        jge      .l85
; (expr #f 0 #f (my_putchar (vector-ref stack (- stack_idx 1))))
; (imm)
; (push 1)
        mov    dword [edi], 1
        add    edi, 4
; (stack-ref-n 4)
        mov    eax, [ebp + 16]
        mov    [edi], eax
        add    edi, 4
; (sub)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        sub    eax, ebx
        mov    [edi - 4], eax
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (call my_putchar)
        call   my_putchar
; (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
; (dec 4)
        dec dword [ebp + 16]
; (expr #t 2 #f (set! temp (+ temp 1)))
; (inc 13)
        inc dword [ebp + 52]
; (br l84)
        jmp    .l84
.l85:
; (expr #t 1 #f (set! done_displaying_int 1))
; (push 1)
        mov    eax, 1
; (stack-set-n 17)
        mov    [ebp + 68], eax
.l83:
; (expr #t 1 #f (! done_displaying_int))
; (stack-ref-n 17)
        mov    eax, [ebp + 68]
; (not)
        not    eax
        and    eax, 1
; (bfl l86)
        test   eax, eax
        je     .l86
; (expr #t 1 #f (set! temp (- temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (negate)
        neg    eax
; (stack-set-n 13)
        mov    [ebp + 52], eax
.l86:
.l82:
; (expr #t 1 #f (! done_displaying_int))
; (stack-ref-n 17)
        mov    eax, [ebp + 68]
; (not)
        not    eax
        and    eax, 1
; (bfl l87)
        test   eax, eax
        je     .l87
; (expr #t 1 #f (set! count 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 16)
        mov    [ebp + 64], eax
.l88:
; (expr #f 0 #f (vector-set! stack stack_idx (+ (remainder temp 10) 48)))
; (imm)
; (push 48)
        mov    dword [edi], 48
        add    edi, 4
; (push 10)
        mov    dword [edi], 10
        add    edi, 4
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (mod)
        call   my_mod
; (add)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        add    eax, ebx
        mov    [edi - 4], eax
; (stack-ref-n 4)
        mov    eax, [ebp + 16]
        mov    [edi], eax
        add    edi, 4
; (stack-set)
        sub    edi, 8
        mov    ecx, [edi]
        mov    edx, [edi + 4]
        mov    [esi + edx * 4], ecx
; (expr #f 0 #f (set! temp (quotient temp 10)))
; (push 10)
        mov    dword [edi], 10
        add    edi, 4
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (div)
        call   my_div
; (stack-set-n 13)
        sub    edi, 4
        mov    edx, [edi]
        mov    [ebp + 4 * 13], edx
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (set! count (+ count 1)))
; (inc 16)
        inc dword [ebp + 64]
; (expr #t 2 != (!= temp 0))
; (imm)
; (push 0)
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (ne)
; * use immediate constant 0
        cmp    ebx, 0
; (bfl l89)
        je       .l89
; (br l88)
        jmp    .l88
.l89:
; (expr #t 1 #f (set! temp 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 13)
        mov    [ebp + 52], eax
.l90:
; (expr #t 2 < (< temp count))
; (stack-ref-n 16)
        mov    eax, [ebp + 64]
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (lt)
        cmp    ebx, eax
; (bfl l91)
        jge      .l91
; (expr #f 0 #f (my_putchar (vector-ref stack (- stack_idx 1))))
; (imm)
; (push 1)
        mov    dword [edi], 1
        add    edi, 4
; (stack-ref-n 4)
        mov    eax, [ebp + 16]
        mov    [edi], eax
        add    edi, 4
; (sub)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        sub    eax, ebx
        mov    [edi - 4], eax
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (call my_putchar)
        call   my_putchar
; (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
; (dec 4)
        dec dword [ebp + 16]
; (expr #t 2 #f (set! temp (+ temp 1)))
; (inc 13)
        inc dword [ebp + 52]
; (br l90)
        jmp    .l90
.l91:
.l87:
; (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
; (dec 4)
        dec dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l52:
; (expr #f 0 #f (my_putchar 10))
; (push 10)
        mov    dword [edi], 10
        add    edi, 4
; (call my_putchar)
        call   my_putchar
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l53:
; (expr #f 0 #f (exit 0))
; (push 0)
        mov    dword [edi], 0
        add    edi, 4
; (exit)
        call   _my_exit
; (br l10)
        jmp    .l10
.l54:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #f 0 #f (my_putchar (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
        mov    [edi], eax
        add    edi, 4
; (stack-ref)
        mov    ebx, edi
        sub    ebx, 4
        mov    ecx, [ebx]
        mov    edx, [esi + ecx * 4]
        mov    [ebx], edx
; (call my_putchar)
        call   my_putchar
; (expr #t 1 #f (set! stack_idx temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l55:
; (expr #t 2 #f (set! temp (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 1 #f (set! n (vector-ref stack temp)))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 9)
        mov    [ebp + 36], eax
; (expr #t 1 #f (set! stack_idx temp))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 3 #f (set! pc (vector-ref code (+ (+ pc n) 1))))
; (imm)
; (push 1)
; (stack-ref-n 9)
        mov    ebx, [ebp + 36]
; (stack-ref-n 2)
        mov    ecx, [ebp + 8]
; (add)
        add    ecx, ebx
        mov    ebx, ecx
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.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)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ebx, 1
        mov    eax, ebx
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 5)
        mov    ebx, [ebp + 20]
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
; (inc 4)
        inc dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.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)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (imm)
; (push 1)
; (stack-ref-n 2)
        mov    ecx, [ebp + 8]
; (add)
; * use immediate constant 1
        add    ecx, 1
        mov    ebx, ecx
; (push 21000000)
        mov    ecx, 21000000
; (add)
        add    ecx, ebx
        mov    ebx, ecx
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (stack-ref-n 5)
        mov    ecx, [ebp + 20]
; (add)
        add    ecx, ebx
        mov    ebx, ecx
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
; (dec 4)
        dec dword [ebp + 16]
; (expr #t 2 #f (set! pc (+ pc 2)))
; (imm)
; (push 2)
; (stack-ref-n 2)
        mov    ebx, [ebp + 8]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 2)
        mov    [ebp + 8], eax
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l58:
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! count (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 16)
        mov    [ebp + 64], eax
; (expr #t 1 #f (set! temp2 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
.l92:
; (expr #t 2 < (< temp2 (- count 2)))
; (imm)
; (push 2)
; (stack-ref-n 16)
        mov    ebx, [ebp + 64]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (lt)
        cmp    ebx, eax
; (bfl l93)
        jge      .l93
; (expr #t 2 #f (set! temp3 (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 15)
        mov    [ebp + 60], eax
; (expr #f 0 #f (my_putchar (bitwise-and temp3 255)))
; (imm)
; (push 255)
        mov    dword [edi], 255
        add    edi, 4
; (stack-ref-n 15)
        mov    eax, [ebp + 60]
        mov    [edi], eax
        add    edi, 4
; (bitand)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        and    eax, ebx
        mov    [edi - 4], eax
; (call my_putchar)
        call   my_putchar
; (expr #f 0 #f (my_putchar (bitwise-and (shr temp3 8) 255)))
; (imm)
; (push 255)
        mov    dword [edi], 255
        add    edi, 4
; (imm)
; (push 8)
        mov    dword [edi], 8
        add    edi, 4
; (stack-ref-n 15)
        mov    eax, [ebp + 60]
        mov    [edi], eax
        add    edi, 4
; (shr)
        sub    edi, 4
        mov    eax, [edi]
        mov    cl, [edi - 4]
        sar    eax, cl
        mov    [edi - 4], eax
; (bitand)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        and    eax, ebx
        mov    [edi - 4], eax
; (call my_putchar)
        call   my_putchar
; (expr #t 2 #f (set! temp2 (+ temp2 2)))
; (imm)
; (push 2)
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (add)
; * use immediate constant 2
        add    ebx, 2
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (br l92)
        jmp    .l92
.l93:
; (expr #t 2 #f (set! temp3 (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 15)
        mov    [ebp + 60], eax
; (expr #f 0 #f (my_putchar (bitwise-and temp3 255)))
; (imm)
; (push 255)
        mov    dword [edi], 255
        add    edi, 4
; (stack-ref-n 15)
        mov    eax, [ebp + 60]
        mov    [edi], eax
        add    edi, 4
; (bitand)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        and    eax, ebx
        mov    [edi - 4], eax
; (call my_putchar)
        call   my_putchar
; (expr #t 3 = (= (bitwise-and count 1) 0))
; (imm)
; (push 0)
; (imm)
; (push 1)
; (stack-ref-n 16)
        mov    ecx, [ebp + 64]
; (bitand)
; * use immediate constant 1
        and    ecx, 1
        mov    ebx, ecx
; (eq)
; * use immediate constant 0
        cmp    ebx, 0
; (bfl l94)
        jne      .l94
; (expr #f 0 #f (my_putchar (bitwise-and (shr temp3 8) 255)))
; (imm)
; (push 255)
        mov    dword [edi], 255
        add    edi, 4
; (imm)
; (push 8)
        mov    dword [edi], 8
        add    edi, 4
; (stack-ref-n 15)
        mov    eax, [ebp + 60]
        mov    [edi], eax
        add    edi, 4
; (shr)
        sub    edi, 4
        mov    eax, [edi]
        mov    cl, [edi - 4]
        sar    eax, cl
        mov    [edi - 4], eax
; (bitand)
        sub    edi, 4
        mov    eax, [edi]
        mov    ebx, [edi - 4]
        and    eax, ebx
        mov    [edi - 4], eax
; (call my_putchar)
        call   my_putchar
.l94:
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.l59:
; (expr #t 2 #f (set! temp (- stack_idx 2)))
; (imm)
; (push 2)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 2
        sub    ebx, 2
        mov    eax, ebx
; (stack-set-n 13)
        mov    [ebp + 52], eax
; (expr #t 2 #f (set! temp2 (- stack_idx 1)))
; (imm)
; (push 1)
; (stack-ref-n 4)
        mov    ebx, [ebp + 16]
; (sub)
; * use immediate constant 1
        sub    ebx, 1
        mov    eax, ebx
; (stack-set-n 14)
        mov    [ebp + 56], eax
; (expr #t 2 #f (vector-set! stack temp (bitwise-xor (vector-ref stack temp2) (vector-ref stack temp))))
; (stack-ref-n 13)
        mov    eax, [ebp + 52]
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-ref-n 14)
        mov    ebx, [ebp + 56]
; (stack-ref)
        mov    ebx, [esi + ebx * 4]
; (bitxor)
        xor    ebx, eax
        mov    eax, ebx
; (stack-ref-n 13)
        mov    ebx, [ebp + 52]
; (stack-set)
        mov    [esi + ebx * 4], eax
; (expr #t 1 #f (set! stack_idx temp2))
; (stack-ref-n 14)
        mov    eax, [ebp + 56]
; (stack-set-n 4)
        mov    [ebp + 16], eax
; (expr #t 2 #f (set! pc (+ pc 1)))
; (inc 2)
        inc dword [ebp + 8]
; (expr #t 2 #f (set! opcode (vector-ref code pc)))
; (stack-ref-n 2)
        mov    eax, [ebp + 8]
; (push 21000000)
        mov    ebx, 21000000
; (add)
        add    ebx, eax
        mov    eax, ebx
; (stack-ref)
        mov    eax, [esi + eax * 4]
; (stack-set-n 3)
        mov    [ebp + 12], eax
; (br l10)
        jmp    .l10
.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))
        sub    edi, 4
        mov    eax, [edi]
        shl    eax, 4
        add    eax, .l95
        jmp    rax
        align  16
.l95:
        jmp    .l14
        align  16
        jmp    .l15
        align  16
        jmp    .l16
        align  16
        jmp    .l17
        align  16
        jmp    .l18
        align  16
        jmp    .l19
        align  16
        jmp    .l20
        align  16
        jmp    .l21
        align  16
        jmp    .l22
        align  16
        jmp    .l23
        align  16
        jmp    .l24
        align  16
        jmp    .l25
        align  16
        jmp    .l26
        align  16
        jmp    .l27
        align  16
        jmp    .l28
        align  16
        jmp    .l29
        align  16
        jmp    .l30
        align  16
        jmp    .l31
        align  16
        jmp    .l32
        align  16
        jmp    .l33
        align  16
        jmp    .l34
        align  16
        jmp    .l35
        align  16
        jmp    .l36
        align  16
        jmp    .l37
        align  16
        jmp    .l38
        align  16
        jmp    .l39
        align  16
        jmp    .l40
        align  16
        jmp    .l41
        align  16
        jmp    .l42
        align  16
        jmp    .l43
        align  16
        jmp    .l44
        align  16
        jmp    .l45
        align  16
        jmp    .l46
        align  16
        jmp    .l47
        align  16
        jmp    .l48
        align  16
        jmp    .l49
        align  16
        jmp    .l50
        align  16
        jmp    .l51
        align  16
        jmp    .l52
        align  16
        jmp    .l53
        align  16
        jmp    .l54
        align  16
        jmp    .l55
        align  16
        jmp    .l56
        align  16
        jmp    .l57
        align  16
        jmp    .l58
        align  16
        jmp    .l59
        align  16
.l13:
; (br l10)
        jmp    .l10
; (expr #t 1 #f (return 0))
; (push 0)
        xor    eax, eax
; (stack-set-n 0)
        mov    [ebp], eax
; (function-end 20)
        mov    edi, ebp
        add    edi, 4
        add    ebp, 4 * 20
        mov    ebp, [ebp]
; (return)
        ret    
