# (top-level-begin 0 21100005)
        mov    %rax, %rsi
        mov    %rax, %rbp
        add    $84400020, %rax
        mov    %rax, %rdi
# (call __main)
        call   __main
# (exit)
        call   _my_exit
__put4chars:
# (function-proc-begin 1 2 1)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        sub    $4, %rdx
        mov    %rdx, %rbp
        add    $12, %rdi
        add    $4, %rdx
        mov    %rcx, (%rdx)
# (expr #f 0 #f (putchar (shr x 24)))
# (imm)
# (push 24)
        movl   $24, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (shr)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %cl
        sar    %cl, %eax
        mov    %eax, -4(%rdi)
# (write-char)
        call   _write_char
# (expr #f 0 #f (putchar (bitwise-and (shr x 16) 255)))
# (imm)
# (push 255)
        movl   $255, (%rdi)
        add    $4, %rdi
# (imm)
# (push 16)
        movl   $16, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (shr)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %cl
        sar    %cl, %eax
        mov    %eax, -4(%rdi)
# (bitand)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        and    %ebx, %eax
        mov    %eax, -4(%rdi)
# (write-char)
        call   _write_char
# (expr #f 0 #f (putchar (bitwise-and (shr x 8) 255)))
# (imm)
# (push 255)
        movl   $255, (%rdi)
        add    $4, %rdi
# (imm)
# (push 8)
        movl   $8, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (shr)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %cl
        sar    %cl, %eax
        mov    %eax, -4(%rdi)
# (bitand)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        and    %ebx, %eax
        mov    %eax, -4(%rdi)
# (write-char)
        call   _write_char
# (expr #f 0 #f (putchar (bitwise-and x 255)))
# (imm)
# (push 255)
        movl   $255, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (bitand)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        and    %ebx, %eax
        mov    %eax, -4(%rdi)
# (write-char)
        call   _write_char
# (expr #f 0 #f (return-from-procedure))
# (proc-end 1)
        mov    %rbp, %rdi
        add    $4, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
__write_int_digit:
# (function-proc-begin 1 2 1)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        sub    $4, %rdx
        mov    %rdx, %rbp
        add    $12, %rdi
        add    $4, %rdx
        mov    %rcx, (%rdx)
# (expr #t 2 > (> n 0))
# (imm)
# (push 0)
# (stack-ref-n 0)
        mov    (%rbp), %ebx
# (gt)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l0)
        jle      .l0
# (expr #f 0 #f (__write_int_digit (quotient n 10)))
# (push 10)
        movl   $10, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (div)
        call   my_div
# (call __write_int_digit)
        call   __write_int_digit
# (expr #f 0 #f (putchar (+ (remainder n 10) 48)))
# (imm)
# (push 48)
        movl   $48, (%rdi)
        add    $4, %rdi
# (push 10)
        movl   $10, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (mod)
        call   my_mod
# (add)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        add    %ebx, %eax
        mov    %eax, -4(%rdi)
# (write-char)
        call   _write_char
.l0:
# (expr #f 0 #f (return-from-procedure))
# (proc-end 1)
        mov    %rbp, %rdi
        add    $4, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
__write_integer:
# (function-proc-begin 1 2 1)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        sub    $4, %rdx
        mov    %rdx, %rbp
        add    $12, %rdi
        add    $4, %rdx
        mov    %rcx, (%rdx)
# (expr #t 2 = (= n 0))
# (imm)
# (push 0)
# (stack-ref-n 0)
        mov    (%rbp), %ebx
# (eq)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l1)
        jne      .l1
# (expr #f 0 #f (putchar 48))
# (push 48)
        movl   $48, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #f 0 #f (return-from-procedure))
# (proc-end 1)
        mov    %rbp, %rdi
        add    $4, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
.l1:
# (expr #t 2 < (< n 0))
# (imm)
# (push 0)
# (stack-ref-n 0)
        mov    (%rbp), %ebx
# (lt)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l2)
        jge      .l2
# (expr #f 0 #f (putchar 45))
# (push 45)
        movl   $45, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #t 4 #f (&& (= (bitwise-and n 65535) 0) (= (shr n 16) (- 32768))))
# (push 32768)
        mov    $32768, %eax
# (negate)
        neg    %eax
# (imm)
# (push 16)
# (stack-ref-n 0)
        mov    (%rbp), %ecx
# (shr)
# * use immediate constant 16
        sar    $16, %ecx
        mov    %ecx, %ebx
# (eq)
        cmp    %eax, %ebx
        sete  %al
        and    $255, %eax
# (imm)
# (push 0)
# (push 65535)
        mov    $65535, %ecx
# (stack-ref-n 0)
        mov    (%rbp), %edx
# (bitand)
        and    %ecx, %edx
        mov    %edx, %ecx
# (eq)
# * use immediate constant 0
        cmp    $0, %ecx
        sete  %bl
        and    $255, %ebx
# (and)
        and    %eax, %ebx
        mov    %ebx, %eax
# (bfl l4)
        test   %eax, %eax
        je     .l4
# (expr #f 0 #f (__put4chars 842085431))
# (push 842085431)
        movl   $842085431, (%rdi)
        add    $4, %rdi
# (call __put4chars)
        call   __put4chars
# (expr #f 0 #f (__put4chars 876098358))
# (push 876098358)
        movl   $876098358, (%rdi)
        add    $4, %rdi
# (call __put4chars)
        call   __put4chars
# (expr #f 0 #f (putchar 52))
# (push 52)
        movl   $52, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #f 0 #f (putchar 56))
# (push 56)
        movl   $56, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #f 0 #f (return-from-procedure))
# (proc-end 1)
        mov    %rbp, %rdi
        add    $4, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
.l4:
# (expr #f 0 #f (__write_int_digit (- n)))
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (negate)
        mov    %rdi, %rcx
        sub    $4, %rcx
        mov    (%rcx), %eax
        neg    %eax
        mov    %eax, (%rcx)
# (call __write_int_digit)
        call   __write_int_digit
# (br l3)
        jmp    .l3
.l2:
# (expr #f 0 #f (__write_int_digit n))
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (call __write_int_digit)
        call   __write_int_digit
.l3:
# (expr #f 0 #f (return-from-procedure))
# (proc-end 1)
        mov    %rbp, %rdi
        add    $4, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
__mult:
# (function-proc-begin 2 4 3)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        sub    $8, %rdx
        mov    %rdx, %rbp
        add    $20, %rdi
        add    $12, %rdx
        mov    %rcx, (%rdx)
# (expr #f 0 #f (return (* x y)))
# (stack-ref-n 1)
        mov    4(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (mul)
        call   my_mul
# (stack-set-n 0)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, (%rbp)
# (function-end 3)
        mov    %rbp, %rdi
        add    $4, %rdi
        add    $12, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
__div:
# (function-proc-begin 2 4 3)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        sub    $8, %rdx
        mov    %rdx, %rbp
        add    $20, %rdi
        add    $12, %rdx
        mov    %rcx, (%rdx)
# (expr #f 0 #f (return (quotient x y)))
# (stack-ref-n 1)
        mov    4(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (div)
        call   my_div
# (stack-set-n 0)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, (%rbp)
# (function-end 3)
        mov    %rbp, %rdi
        add    $4, %rdi
        add    $12, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
my_putchar:
# (function-proc-begin 1 2 1)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        sub    $4, %rdx
        mov    %rdx, %rbp
        add    $12, %rdi
        add    $4, %rdx
        mov    %rcx, (%rdx)
# (expr #f 0 #f (putchar ch))
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #f 0 #f (return-from-procedure))
# (proc-end 1)
        mov    %rbp, %rdi
        add    $4, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
my_fgetc:
# (function-proc-begin 0 2 1)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        mov    %rdx, %rbp
        add    $12, %rdi
        add    $4, %rdx
        mov    %rcx, (%rdx)
# (expr #f 0 #f (return (getchar)))
# (read-char)
        call   _read_char
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-set-n 0)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, (%rbp)
# (function-end 1)
        mov    %rbp, %rdi
        add    $4, %rdi
        add    $4, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
read_char_:
# (function-proc-begin 0 1 0)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        mov    %rdx, %rbp
        add    $8, %rdi
        mov    %rcx, (%rdx)
# (expr #t 2 = (= ch (- 1)))
# (push 1)
        mov    $1, %eax
# (negate)
        neg    %eax
# (push 21100000)
        mov    $21100000, %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (eq)
        cmp    %eax, %ebx
# (bfl l5)
        jne      .l5
# (expr #f 0 #f (return-from-procedure))
# (proc-end 0)
        mov    %rbp, %rdi
        mov    (%rbp), %rbp
# (return)
        ret    
.l5:
# (expr #f 0 #f (set! ch (getchar)))
# (read-char)
        call   _read_char
        mov    %eax, (%rdi)
        add    $4, %rdi
# (push 21100000)
        movl   $21100000, (%rdi)
        add    $4, %rdi
# (stack-set)
        sub    $8, %rdi
        mov    (%rdi), %ecx
        mov    4(%rdi), %edx
        mov    %ecx, (%rsi, %rdx, 4)
# (expr #f 0 #f (return-from-procedure))
# (proc-end 0)
        mov    %rbp, %rdi
        mov    (%rbp), %rbp
# (return)
        ret    
.l6:
skip_blanks:
# (function-proc-begin 0 1 0)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        mov    %rdx, %rbp
        add    $8, %rdi
        mov    %rcx, (%rdx)
.l7:
# (expr #t 4 #f (|| (|| (= ch 32) (= ch 10)) (= ch 13)))
# (imm)
# (push 13)
# (push 21100000)
        mov    $21100000, %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (eq)
# * use immediate constant 13
        cmp    $13, %ebx
        sete  %al
        and    $255, %eax
# (imm)
# (push 10)
# (push 21100000)
        mov    $21100000, %ecx
# (stack-ref)
        mov    (%rsi, %rcx, 4), %ecx
# (eq)
# * use immediate constant 10
        cmp    $10, %ecx
        sete  %bl
        and    $255, %ebx
# (imm)
# (push 32)
# (push 21100000)
        mov    $21100000, %edx
# (stack-ref)
        mov    (%rsi, %rdx, 4), %edx
# (eq)
# * use immediate constant 32
        cmp    $32, %edx
        sete  %cl
        and    $255, %ecx
# (or)
        or     %ebx, %ecx
        mov    %ecx, %ebx
# (or)
        or     %eax, %ebx
        mov    %ebx, %eax
# (bfl l8)
        test   %eax, %eax
        je     .l8
# (expr #f 0 #f (set! ch (getchar)))
# (read-char)
        call   _read_char
        mov    %eax, (%rdi)
        add    $4, %rdi
# (push 21100000)
        movl   $21100000, (%rdi)
        add    $4, %rdi
# (stack-set)
        sub    $8, %rdi
        mov    (%rdi), %ecx
        mov    4(%rdi), %edx
        mov    %ecx, (%rsi, %rdx, 4)
# (br l7)
        jmp    .l7
.l8:
# (expr #f 0 #f (return-from-procedure))
# (proc-end 0)
        mov    %rbp, %rdi
        mov    (%rbp), %rbp
# (return)
        ret    
my_scan_int:
# (function-proc-begin 0 4 3)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        mov    %rdx, %rbp
        add    $20, %rdi
        add    $12, %rdx
        mov    %rcx, (%rdx)
# (expr #t 1 #f (set! sum 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 0)
        mov    %eax, (%rbp)
# (expr #t 1 #f (set! negative 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 1)
        mov    %eax, 4(%rbp)
# (expr #f 0 #f (skip_blanks))
# (call skip_blanks)
        call   skip_blanks
# (expr #t 2 = (= ch 45))
# (imm)
# (push 45)
# (push 21100000)
        mov    $21100000, %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (eq)
# * use immediate constant 45
        cmp    $45, %ebx
# (bfl l9)
        jne      .l9
# (expr #t 1 #f (set! negative 1))
# (push 1)
        mov    $1, %eax
# (stack-set-n 1)
        mov    %eax, 4(%rbp)
# (expr #f 0 #f (read_char_))
# (call read_char_)
        call   read_char_
.l9:
.l10:
# (expr #t 3 #f (&& (>= ch 48) (<= ch 57)))
# (imm)
# (push 57)
# (push 21100000)
        mov    $21100000, %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (le)
# * use immediate constant 57
        cmp    $57, %ebx
        setle %al
        and    $255, %eax
# (imm)
# (push 48)
# (push 21100000)
        mov    $21100000, %ecx
# (stack-ref)
        mov    (%rsi, %rcx, 4), %ecx
# (ge)
# * use immediate constant 48
        cmp    $48, %ecx
        setge %bl
        and    $255, %ebx
# (and)
        and    %eax, %ebx
        mov    %ebx, %eax
# (bfl l11)
        test   %eax, %eax
        je     .l11
# (expr #f 0 #f (set! sum (- (+ (* sum 10) ch) 48)))
# (imm)
# (push 48)
        movl   $48, (%rdi)
        add    $4, %rdi
# (push 21100000)
        movl   $21100000, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (push 10)
        movl   $10, (%rdi)
        add    $4, %rdi
# (stack-ref-n 0)
        mov    (%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (mul)
        call   my_mul
# (add)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        add    %ebx, %eax
        mov    %eax, -4(%rdi)
# (sub)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        sub    %ebx, %eax
        mov    %eax, -4(%rdi)
# (stack-set-n 0)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, (%rbp)
# (expr #f 0 #f (read_char_))
# (call read_char_)
        call   read_char_
# (br l10)
        jmp    .l10
.l11:
# (expr #t 2 = (= negative 1))
# (imm)
# (push 1)
# (stack-ref-n 1)
        mov    4(%rbp), %ebx
# (eq)
# * use immediate constant 1
        cmp    $1, %ebx
# (bfl l12)
        jne      .l12
# (expr #t 1 #f (set! sum (- sum)))
# (stack-ref-n 0)
        mov    (%rbp), %eax
# (negate)
        neg    %eax
# (stack-set-n 0)
        mov    %eax, (%rbp)
.l12:
# (expr #f 0 #f (return sum))
# (function-end 3)
        mov    %rbp, %rdi
        add    $4, %rdi
        add    $12, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
__main:
# (function-proc-begin 0 20 19)
        mov    %rbp, %rcx
        mov    %rdi, %rdx
        mov    %rdx, %rbp
        add    $84, %rdi
        add    $76, %rdx
        mov    %rcx, (%rdx)
# (expr #t 2 #f (set! ch 32))
# (push 32)
        mov    $32, %eax
# (push 21100000)
        mov    $21100000, %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx 1))
# (push 1)
        mov    $1, %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 1 #f (set! return_stack_idx 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 6)
        mov    %eax, 24(%rbp)
# (expr #t 1 #f (set! eof_reached 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 17)
        mov    %eax, 68(%rbp)
# (expr #t 1 #f (set! frame_start 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 5)
        mov    %eax, 20(%rbp)
# (expr #f 0 #f (set! temp (my_scan_int)))
# (call my_scan_int)
        call   my_scan_int
# (stack-set-n 13)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, 52(%rbp)
# (expr #t 1 #f (set! idx 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 0)
        mov    %eax, (%rbp)
.l13:
# (expr #t 2 < (< idx temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref-n 0)
        mov    (%rbp), %ebx
# (lt)
        cmp    %eax, %ebx
# (bfl l14)
        jge      .l14
# (expr #f 0 #f (set! word (my_scan_int)))
# (call my_scan_int)
        call   my_scan_int
# (stack-set-n 1)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, 4(%rbp)
# (expr #t 3 #f (vector-set! code idx word))
# (stack-ref-n 1)
        mov    4(%rbp), %eax
# (stack-ref-n 0)
        mov    (%rbp), %ebx
# (push 21000000)
        mov    $21000000, %ecx
# (add)
        add    %ebx, %ecx
        mov    %ecx, %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! idx (+ idx 1)))
# (inc 0)
        addl   $1, (%rbp)
# (br l13)
        jmp    .l13
.l14:
# (expr #t 1 #f (set! pc 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
.l15:
# (expr #f 0 #f opcode)
# (stack-ref-n 3)
        mov    12(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (br l17)
        jmp    .l17
.l19:
# (expr #t 2 #f (set! frame_start (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 5)
        mov    %eax, 20(%rbp)
# (expr #t 2 #f (set! stack_idx (+ frame_start (vector-ref code (+ pc 2)))))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 5)
        mov    20(%rbp), %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 3)))
# (imm)
# (push 3)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 3
        add    $3, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l20:
# (expr #t 2 #f (set! formals_offset (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 10)
        mov    %eax, 40(%rbp)
# (expr #t 2 #f (set! all_vars_size (vector-ref code (+ pc 2))))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 11)
        mov    %eax, 44(%rbp)
# (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 3))))
# (imm)
# (push 3)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 3
        add    $3, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 12)
        mov    %eax, 48(%rbp)
# (expr #t 1 #f (set! temp frame_start))
# (stack-ref-n 5)
        mov    20(%rbp), %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! frame_start (- stack_idx formals_offset)))
# (stack-ref-n 10)
        mov    40(%rbp), %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
        sub    %eax, %ebx
        mov    %ebx, %eax
# (stack-set-n 5)
        mov    %eax, 20(%rbp)
# (expr #t 2 #f (set! stack_idx (+ frame_start all_vars_size)))
# (stack-ref-n 11)
        mov    44(%rbp), %eax
# (stack-ref-n 5)
        mov    20(%rbp), %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 3 #f (vector-set! stack (+ frame_start dynamic_link) temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref-n 12)
        mov    48(%rbp), %ebx
# (stack-ref-n 5)
        mov    20(%rbp), %ecx
# (add)
        add    %ebx, %ecx
        mov    %ecx, %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! pc (+ pc 4)))
# (imm)
# (push 4)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 4
        add    $4, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l21:
# (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 12)
        mov    %eax, 48(%rbp)
# (expr #t 1 #f (set! temp (vector-ref stack frame_start)))
# (stack-ref-n 5)
        mov    20(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 1 #f (set! stack_idx frame_start))
# (stack-ref-n 5)
        mov    20(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! frame_start (vector-ref stack (+ frame_start dynamic_link))))
# (stack-ref-n 12)
        mov    48(%rbp), %eax
# (stack-ref-n 5)
        mov    20(%rbp), %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 5)
        mov    %eax, 20(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l22:
# (expr #t 2 #f (set! dynamic_link (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 12)
        mov    %eax, 48(%rbp)
# (expr #t 1 #f (set! stack_idx frame_start))
# (stack-ref-n 5)
        mov    20(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! frame_start (vector-ref stack (+ frame_start dynamic_link))))
# (stack-ref-n 12)
        mov    48(%rbp), %eax
# (stack-ref-n 5)
        mov    20(%rbp), %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 5)
        mov    %eax, 20(%rbp)
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l23:
# (expr #t 2 #f (vector-set! stack stack_idx (+ frame_start (vector-ref code (+ pc 1)))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 5)
        mov    20(%rbp), %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l24:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (vector-set! stack temp (vector-ref stack (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l25:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 3 #f (vector-set! stack (vector-ref stack (- stack_idx 1)) (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ecx
# (sub)
# * use immediate constant 1
        sub    $1, %ecx
        mov    %ecx, %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l26:
# (expr #t 2 #f (vector-set! stack stack_idx (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l27:
# (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
# (dec 4)
        subl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l28:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (+ (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l29:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (- (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (sub)
        sub    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l30:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #f 0 #f (vector-set! stack temp (* (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (stack-ref-n 14)
        mov    56(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (mul)
        call   my_mul
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-set)
        sub    $8, %rdi
        mov    (%rdi), %ecx
        mov    4(%rdi), %edx
        mov    %ecx, (%rsi, %rdx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l31:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #f 0 #f (vector-set! stack temp (quotient (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (stack-ref-n 14)
        mov    56(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (div)
        call   my_div
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-set)
        sub    $8, %rdi
        mov    (%rdi), %ecx
        mov    4(%rdi), %edx
        mov    %ecx, (%rsi, %rdx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l32:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #f 0 #f (vector-set! stack temp (remainder (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (stack-ref-n 14)
        mov    56(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (mod)
        call   my_mod
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-set)
        sub    $8, %rdi
        mov    (%rdi), %ecx
        mov    4(%rdi), %edx
        mov    %ecx, (%rsi, %rdx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l33:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #f 0 #f (vector-set! stack temp (abs (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (abs)
        call   my_abs
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-set)
        sub    $8, %rdi
        mov    (%rdi), %ecx
        mov    4(%rdi), %edx
        mov    %ecx, (%rsi, %rdx, 4)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l34:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (vector-set! stack temp (- (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (negate)
        neg    %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l35:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (shl (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (shl)
        push   %rbx
        push   %rcx
        push   %rax
        push   %rbx
        sub    $8, %rsp
        mov    16(%rsp), %ecx
        mov    8(%rsp), %ebx
        shl    %cl, %ebx
        mov    %ebx, (%rsp)
        mov    24(%rsp), %ecx
        mov    32(%rsp), %ebx
        mov    (%rsp), %eax
        add    $40, %rsp
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l36:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (shr (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (shr)
        push   %rbx
        push   %rcx
        push   %rax
        push   %rbx
        sub    $8, %rsp
        mov    16(%rsp), %ecx
        mov    8(%rsp), %ebx
        sar    %cl, %ebx
        mov    %ebx, (%rsp)
        mov    24(%rsp), %ecx
        mov    32(%rsp), %ebx
        mov    (%rsp), %eax
        add    $40, %rsp
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l37:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (bitwise-or (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (bitor)
        or     %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l38:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (bitwise-and (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (bitand)
        and    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l39:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (vector-set! stack temp (bitwise-not (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (bitnot)
        not    %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l40:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 1 #f (set! cc (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 8)
        mov    %eax, 32(%rbp)
# (expr #t 1 #f (set! stack_idx temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 != (!= cc 0))
# (imm)
# (push 0)
# (stack-ref-n 8)
        mov    32(%rbp), %ebx
# (ne)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l65)
        je       .l65
# (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (br l66)
        jmp    .l66
.l65:
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
.l66:
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l41:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 1 #f (set! cc (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 8)
        mov    %eax, 32(%rbp)
# (expr #t 1 #f (set! stack_idx temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 = (= cc 0))
# (imm)
# (push 0)
# (stack-ref-n 8)
        mov    32(%rbp), %ebx
# (eq)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l67)
        jne      .l67
# (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (br l68)
        jmp    .l68
.l67:
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
.l68:
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l42:
# (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l43:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 = (= (vector-ref stack temp2) (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (eq)
        cmp    %eax, %ebx
# (bfl l69)
        jne      .l69
# (expr #t 2 #f (vector-set! stack temp 1))
# (push 1)
        mov    $1, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (br l70)
        jmp    .l70
.l69:
# (expr #t 2 #f (vector-set! stack temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
.l70:
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l44:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 < (< (vector-ref stack temp2) (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (lt)
        cmp    %eax, %ebx
# (bfl l71)
        jge      .l71
# (expr #t 2 #f (vector-set! stack temp 1))
# (push 1)
        mov    $1, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (br l72)
        jmp    .l72
.l71:
# (expr #t 2 #f (vector-set! stack temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
.l72:
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l45:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 > (> (vector-ref stack temp2) (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (gt)
        cmp    %eax, %ebx
# (bfl l73)
        jle      .l73
# (expr #t 2 #f (vector-set! stack temp 1))
# (push 1)
        mov    $1, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (br l74)
        jmp    .l74
.l73:
# (expr #t 2 #f (vector-set! stack temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
.l74:
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l46:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 <= (<= (vector-ref stack temp2) (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (le)
        cmp    %eax, %ebx
# (bfl l75)
        jg       .l75
# (expr #t 2 #f (vector-set! stack temp 1))
# (push 1)
        mov    $1, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (br l76)
        jmp    .l76
.l75:
# (expr #t 2 #f (vector-set! stack temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
.l76:
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l47:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 >= (>= (vector-ref stack temp2) (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (ge)
        cmp    %eax, %ebx
# (bfl l77)
        jl       .l77
# (expr #t 2 #f (vector-set! stack temp 1))
# (push 1)
        mov    $1, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (br l78)
        jmp    .l78
.l77:
# (expr #t 2 #f (vector-set! stack temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
.l78:
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l48:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 != (!= (vector-ref stack temp2) (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (ne)
        cmp    %eax, %ebx
# (bfl l79)
        je       .l79
# (expr #t 2 #f (vector-set! stack temp 1))
# (push 1)
        mov    $1, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (br l80)
        jmp    .l80
.l79:
# (expr #t 2 #f (vector-set! stack temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
.l80:
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l49:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (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    52(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (bitnot)
        not    %ebx
# (bitand)
# * use immediate constant 1
        and    $1, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l50:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (bitwise-and (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (bitand)
        and    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l51:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (bitwise-or (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (bitor)
        or     %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l52:
# (expr #t 3 #f (vector-set! return_stack return_stack_idx (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-ref-n 6)
        mov    24(%rbp), %ebx
# (push 21050000)
        mov    $21050000, %ecx
# (add)
        add    %ebx, %ecx
        mov    %ecx, %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! pc (vector-ref code (+ pc 1))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! return_stack_idx (+ return_stack_idx 1)))
# (inc 6)
        addl   $1, 24(%rbp)
# (expr #t 2 = (= return_stack_idx 50000))
# (push 50000)
        mov    $50000, %eax
# (stack-ref-n 6)
        mov    24(%rbp), %ebx
# (eq)
        cmp    %eax, %ebx
# (bfl l81)
        jne      .l81
# (expr #f 0 #f (__put4chars 1937006947))
# (push 1937006947)
        movl   $1937006947, (%rdi)
        add    $4, %rdi
# (call __put4chars)
        call   __put4chars
# (expr #f 0 #f (__put4chars 1797287798))
# (push 1797287798)
        movl   $1797287798, (%rdi)
        add    $4, %rdi
# (call __put4chars)
        call   __put4chars
# (expr #f 0 #f (__put4chars 1701996140))
# (push 1701996140)
        movl   $1701996140, (%rdi)
        add    $4, %rdi
# (call __put4chars)
        call   __put4chars
# (expr #f 0 #f (putchar 111))
# (push 111)
        movl   $111, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #f 0 #f (putchar 119))
# (push 119)
        movl   $119, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #f 0 #f (putchar 10))
# (push 10)
        movl   $10, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #f 0 #f (exit 0))
# (push 0)
        movl   $0, (%rdi)
        add    $4, %rdi
# (exit)
        call   _my_exit
.l81:
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l53:
# (expr #t 2 #f (set! pc (vector-ref return_stack (- return_stack_idx 1))))
# (imm)
# (push 1)
# (stack-ref-n 6)
        mov    24(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (push 21050000)
        mov    $21050000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! return_stack_idx (- return_stack_idx 1)))
# (dec 6)
        subl   $1, 24(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l54:
# (expr #t 1 #f (set! val_ 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 7)
        mov    %eax, 28(%rbp)
# (expr #t 2 = (= eof_reached 0))
# (imm)
# (push 0)
# (stack-ref-n 17)
        mov    68(%rbp), %ebx
# (eq)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l82)
        jne      .l82
# (expr #f 0 #f (set! val_ (getchar)))
# (read-char)
        call   _read_char
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-set-n 7)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, 28(%rbp)
# (expr #t 2 = (= val_ (- 1)))
# (push 1)
        mov    $1, %eax
# (negate)
        neg    %eax
# (stack-ref-n 7)
        mov    28(%rbp), %ebx
# (eq)
        cmp    %eax, %ebx
# (bfl l83)
        jne      .l83
# (expr #t 1 #f (set! eof_reached 1))
# (push 1)
        mov    $1, %eax
# (stack-set-n 17)
        mov    %eax, 68(%rbp)
# (br l84)
        jmp    .l84
.l83:
# (expr #t 2 #f (set! val_ (bitwise-and val_ 255)))
# (imm)
# (push 255)
# (stack-ref-n 7)
        mov    28(%rbp), %ebx
# (bitand)
# * use immediate constant 255
        and    $255, %ebx
        mov    %ebx, %eax
# (stack-set-n 7)
        mov    %eax, 28(%rbp)
.l84:
.l82:
# (expr #t 2 #f (vector-set! stack stack_idx val_))
# (stack-ref-n 7)
        mov    28(%rbp), %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l55:
# (expr #t 2 = (= eof_reached 1))
# (imm)
# (push 1)
# (stack-ref-n 17)
        mov    68(%rbp), %ebx
# (eq)
# * use immediate constant 1
        cmp    $1, %ebx
# (bfl l85)
        jne      .l85
# (expr #t 2 #f (vector-set! stack stack_idx 1))
# (push 1)
        mov    $1, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (br l86)
        jmp    .l86
.l85:
# (expr #t 2 #f (vector-set! stack stack_idx 0))
# (push 0)
        xor    %eax, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
.l86:
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l56:
# (expr #t 2 #f (set! temp (vector-ref stack (- stack_idx 1))))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 1 #f (set! done_displaying_int 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 16)
        mov    %eax, 64(%rbp)
# (expr #t 2 < (< temp 0))
# (imm)
# (push 0)
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (lt)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l87)
        jge      .l87
# (expr #f 0 #f (putchar 45))
# (push 45)
        movl   $45, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #t 4 #f (&& (= (bitwise-and temp 65535) 0) (= (shr temp 16) (- 32768))))
# (push 32768)
        mov    $32768, %eax
# (negate)
        neg    %eax
# (imm)
# (push 16)
# (stack-ref-n 13)
        mov    52(%rbp), %ecx
# (shr)
# * use immediate constant 16
        sar    $16, %ecx
        mov    %ecx, %ebx
# (eq)
        cmp    %eax, %ebx
        sete  %al
        and    $255, %eax
# (imm)
# (push 0)
# (push 65535)
        mov    $65535, %ecx
# (stack-ref-n 13)
        mov    52(%rbp), %edx
# (bitand)
        and    %ecx, %edx
        mov    %edx, %ecx
# (eq)
# * use immediate constant 0
        cmp    $0, %ecx
        sete  %bl
        and    $255, %ebx
# (and)
        and    %eax, %ebx
        mov    %ebx, %eax
# (bfl l88)
        test   %eax, %eax
        je     .l88
# (expr #t 2 #f (vector-set! stack stack_idx 56))
# (push 56)
        mov    $56, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 52))
# (push 52)
        mov    $52, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 54))
# (push 54)
        mov    $54, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 51))
# (push 51)
        mov    $51, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 56))
# (push 56)
        mov    $56, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 52))
# (push 52)
        mov    $52, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 55))
# (push 55)
        mov    $55, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 52))
# (push 52)
        mov    $52, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 49))
# (push 49)
        mov    $49, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (vector-set! stack stack_idx 50))
# (push 50)
        mov    $50, %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 1 #f (set! count 10))
# (push 10)
        mov    $10, %eax
# (stack-set-n 15)
        mov    %eax, 60(%rbp)
# (expr #t 1 #f (set! temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
.l89:
# (expr #f 0 #f (putchar (vector-ref stack (- stack_idx 1))))
# (imm)
# (push 1)
        movl   $1, (%rdi)
        add    $4, %rdi
# (stack-ref-n 4)
        mov    16(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (sub)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        sub    %ebx, %eax
        mov    %eax, -4(%rdi)
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (write-char)
        call   _write_char
# (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
# (dec 4)
        subl   $1, 16(%rbp)
# (expr #t 2 #f (set! temp (+ temp 1)))
# (inc 13)
        addl   $1, 52(%rbp)
# (expr #t 2 < (< temp count))
# (stack-ref-n 15)
        mov    60(%rbp), %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (lt)
        cmp    %eax, %ebx
# (bfl l90)
        jge      .l90
# (br l89)
        jmp    .l89
.l90:
# (expr #t 1 #f (set! done_displaying_int 1))
# (push 1)
        mov    $1, %eax
# (stack-set-n 16)
        mov    %eax, 64(%rbp)
.l88:
# (expr #t 1 #f (! done_displaying_int))
# (stack-ref-n 16)
        mov    64(%rbp), %eax
# (not)
        not    %eax
        and    $1, %eax
# (bfl l91)
        test   %eax, %eax
        je     .l91
# (expr #t 1 #f (set! temp (- temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (negate)
        neg    %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
.l91:
.l87:
# (expr #t 1 #f (! done_displaying_int))
# (stack-ref-n 16)
        mov    64(%rbp), %eax
# (not)
        not    %eax
        and    $1, %eax
# (bfl l92)
        test   %eax, %eax
        je     .l92
# (expr #t 1 #f (set! count 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 15)
        mov    %eax, 60(%rbp)
.l93:
# (expr #f 0 #f (vector-set! stack stack_idx (+ (remainder temp 10) 48)))
# (imm)
# (push 48)
        movl   $48, (%rdi)
        add    $4, %rdi
# (push 10)
        movl   $10, (%rdi)
        add    $4, %rdi
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (mod)
        call   my_mod
# (add)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        add    %ebx, %eax
        mov    %eax, -4(%rdi)
# (stack-ref-n 4)
        mov    16(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-set)
        sub    $8, %rdi
        mov    (%rdi), %ecx
        mov    4(%rdi), %edx
        mov    %ecx, (%rsi, %rdx, 4)
# (expr #f 0 #f (set! temp (quotient temp 10)))
# (push 10)
        movl   $10, (%rdi)
        add    $4, %rdi
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (div)
        call   my_div
# (stack-set-n 13)
        sub    $4, %rdi
        mov    (%rdi), %edx
        mov    %edx, 52(%rbp)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (set! count (+ count 1)))
# (inc 15)
        addl   $1, 60(%rbp)
# (expr #t 2 != (!= temp 0))
# (imm)
# (push 0)
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (ne)
# * use immediate constant 0
        cmp    $0, %ebx
# (bfl l94)
        je       .l94
# (br l93)
        jmp    .l93
.l94:
# (expr #t 1 #f (set! temp 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
.l95:
# (expr #f 0 #f (putchar (vector-ref stack (- stack_idx 1))))
# (imm)
# (push 1)
        movl   $1, (%rdi)
        add    $4, %rdi
# (stack-ref-n 4)
        mov    16(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (sub)
        sub    $4, %rdi
        mov    (%rdi), %eax
        mov    -4(%rdi), %ebx
        sub    %ebx, %eax
        mov    %eax, -4(%rdi)
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (write-char)
        call   _write_char
# (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
# (dec 4)
        subl   $1, 16(%rbp)
# (expr #t 2 #f (set! temp (+ temp 1)))
# (inc 13)
        addl   $1, 52(%rbp)
# (expr #t 2 < (< temp count))
# (stack-ref-n 15)
        mov    60(%rbp), %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (lt)
        cmp    %eax, %ebx
# (bfl l96)
        jge      .l96
# (br l95)
        jmp    .l95
.l96:
.l92:
# (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
# (dec 4)
        subl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l57:
# (expr #f 0 #f (putchar 10))
# (push 10)
        movl   $10, (%rdi)
        add    $4, %rdi
# (write-char)
        call   _write_char
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l58:
# (expr #f 0 #f (exit 0))
# (push 0)
        movl   $0, (%rdi)
        add    $4, %rdi
# (exit)
        call   _my_exit
# (br l15)
        jmp    .l15
.l59:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #f 0 #f (putchar (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
        mov    %eax, (%rdi)
        add    $4, %rdi
# (stack-ref)
        mov    %rdi, %rbx
        sub    $4, %rbx
        mov    (%rbx), %ecx
        mov    (%rsi, %rcx, 4), %edx
        mov    %edx, (%rbx)
# (write-char)
        call   _write_char
# (expr #t 1 #f (set! stack_idx temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l60:
# (expr #t 2 #f (set! temp (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 1 #f (set! n (vector-ref stack temp)))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 9)
        mov    %eax, 36(%rbp)
# (expr #t 1 #f (set! stack_idx temp))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 3 #f (set! pc (vector-ref code (+ (+ pc n) 1))))
# (imm)
# (push 1)
# (stack-ref-n 9)
        mov    36(%rbp), %ebx
# (stack-ref-n 2)
        mov    8(%rbp), %ecx
# (add)
        add    %ebx, %ecx
        mov    %ecx, %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l61:
# (expr #t 2 #f (vector-set! stack stack_idx (vector-ref stack (+ frame_start (vector-ref code (+ pc 1))))))
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 1
        add    $1, %ebx
        mov    %ebx, %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 5)
        mov    20(%rbp), %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (+ stack_idx 1)))
# (inc 4)
        addl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l62:
# (expr #t 3 #f (vector-set! stack (+ frame_start (vector-ref code (+ pc 1))) (vector-ref stack (- stack_idx 1))))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (imm)
# (push 1)
# (stack-ref-n 2)
        mov    8(%rbp), %ecx
# (add)
# * use immediate constant 1
        add    $1, %ecx
        mov    %ecx, %ebx
# (push 21000000)
        mov    $21000000, %ecx
# (add)
        add    %ebx, %ecx
        mov    %ecx, %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (stack-ref-n 5)
        mov    20(%rbp), %ecx
# (add)
        add    %ebx, %ecx
        mov    %ecx, %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 2 #f (set! stack_idx (- stack_idx 1)))
# (dec 4)
        subl   $1, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 2)))
# (imm)
# (push 2)
# (stack-ref-n 2)
        mov    8(%rbp), %ebx
# (add)
# * use immediate constant 2
        add    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 2)
        mov    %eax, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l63:
# (expr #f 0 #f (exit 0))
# (push 0)
        movl   $0, (%rdi)
        add    $4, %rdi
# (exit)
        call   _my_exit
# (br l15)
        jmp    .l15
.l64:
# (expr #t 2 #f (set! temp (- stack_idx 2)))
# (imm)
# (push 2)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 2
        sub    $2, %ebx
        mov    %ebx, %eax
# (stack-set-n 13)
        mov    %eax, 52(%rbp)
# (expr #t 2 #f (set! temp2 (- stack_idx 1)))
# (imm)
# (push 1)
# (stack-ref-n 4)
        mov    16(%rbp), %ebx
# (sub)
# * use immediate constant 1
        sub    $1, %ebx
        mov    %ebx, %eax
# (stack-set-n 14)
        mov    %eax, 56(%rbp)
# (expr #t 2 #f (vector-set! stack temp (bitwise-xor (vector-ref stack temp2) (vector-ref stack temp))))
# (stack-ref-n 13)
        mov    52(%rbp), %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-ref-n 14)
        mov    56(%rbp), %ebx
# (stack-ref)
        mov    (%rsi, %rbx, 4), %ebx
# (bitxor)
        xor    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref-n 13)
        mov    52(%rbp), %ebx
# (stack-set)
        mov    %eax, (%rsi, %rbx, 4)
# (expr #t 1 #f (set! stack_idx temp2))
# (stack-ref-n 14)
        mov    56(%rbp), %eax
# (stack-set-n 4)
        mov    %eax, 16(%rbp)
# (expr #t 2 #f (set! pc (+ pc 1)))
# (inc 2)
        addl   $1, 8(%rbp)
# (expr #t 2 #f (set! opcode (vector-ref code pc)))
# (stack-ref-n 2)
        mov    8(%rbp), %eax
# (push 21000000)
        mov    $21000000, %ebx
# (add)
        add    %eax, %ebx
        mov    %ebx, %eax
# (stack-ref)
        mov    (%rsi, %rax, 4), %eax
# (stack-set-n 3)
        mov    %eax, 12(%rbp)
# (br l15)
        jmp    .l15
.l17:
# (brtable (0 l19) (1 l20) (2 l21) (3 l22) (4 l23) (5 l24) (6 l25) (7 l26) (8 l27) (9 l28) (10 l29) (11 l30) (12 l31) (13 l32) (14 l33) (15 l34) (16 l35) (17 l36) (18 l37) (19 l38) (20 l39) (21 l40) (22 l41) (23 l42) (24 l43) (25 l44) (26 l45) (27 l46) (28 l47) (29 l48) (30 l49) (31 l50) (32 l51) (33 l52) (34 l53) (35 l54) (36 l55) (37 l56) (38 l57) (39 l58) (40 l59) (41 l60) (42 l61) (43 l62) (44 l63) (45 l64))
        sub    $4, %rdi
        mov    (%rdi), %eax
        shl    $4, %eax
        lea    .l97(%rax), %rax
        jmp    *%rax
        .align 16
.l97:
        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
        jmp    .l60
        .align 16
        jmp    .l61
        .align 16
        jmp    .l62
        .align 16
        jmp    .l63
        .align 16
        jmp    .l64
        .align 16
.l18:
# (br l15)
        jmp    .l15
# (expr #t 1 #f (return 0))
# (push 0)
        xor    %eax, %eax
# (stack-set-n 0)
        mov    %eax, (%rbp)
# (function-end 19)
        mov    %rbp, %rdi
        add    $4, %rdi
        add    $76, %rbp
        mov    (%rbp), %rbp
# (return)
        ret    
