LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_car
struct value*
builtin_car(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("car", args, 1);
    ASSERT_TYPE("car", args, 0, VALUE_PAIR);

    struct value* pair = CAR(args);
    return CAR(pair);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x46f8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x7, (%rax)
jne 0x4700
movq %rbx, %rdi
callq 0x5b2b
movq %rax, %rdi
popq %rbx
jmp 0x5b2b
movq %rbx, %rdi
callq 0x1978
movq %rbx, %rdi
callq 0x19b1
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_cdr
struct value*
builtin_cdr(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("cdr", args, 1);
    ASSERT_TYPE("cdr", args, 0, VALUE_PAIR);

    struct value* pair = CAR(args);
    return CDR(pair);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x473a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x7, (%rax)
jne 0x4742
movq %rbx, %rdi
callq 0x5b2b
movq %rax, %rdi
popq %rbx
jmp 0x5abc
movq %rbx, %rdi
callq 0x1a07
movq %rbx, %rdi
callq 0x1a40
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_set_car
struct value*
builtin_set_car(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("set-car!", args, 2);
    ASSERT_TYPE("set-car!", args, 0, VALUE_PAIR);

    struct value* pair = CAR(args);
    struct value* val = CADR(args);
    pair->as.pair.car = val;
    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x479e
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x7, (%rax)
jne 0x47a6
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
movq %rax, 0x10(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7071
movq %r14, %rdi
callq 0x1a96
movq %r14, %rdi
callq 0x1acc
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_set_cdr
struct value*
builtin_set_cdr(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("set-cdr!", args, 2);
    ASSERT_TYPE("set-cdr!", args, 0, VALUE_PAIR);

    struct value* pair = CAR(args);
    struct value* val = CADR(args);
    pair->as.pair.cdr = val;
    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x4802
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x7, (%rax)
jne 0x480a
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
movq %rax, 0x18(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7071
movq %r14, %rdi
callq 0x1b22
movq %r14, %rdi
callq 0x1b58
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_open_input_file
struct value*
builtin_open_input_file(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("open-input-file", args, 1);
    ASSERT_TYPE("open-input-file", args, 0, VALUE_STRING);

    struct value* path = CAR(args);

    FILE* port = fopen(path->as.string, "rb");
    if (port == NULL) {
        fprintf(stderr, "failed to open input file: %s\n", path->as.string);
        perror("reason");
        exit(EXIT_FAILURE);
    }

    return vm_make_input_port(vm, port);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4a4b
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x5, (%rax)
jne 0x4a53
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r14
movq 0x10(%rax), %rdi
leaq 0x38ac(%rip), %rsi      # 0x82db
callq 0x1190
testq %rax, %rax
je 0x4a5b
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7303
movq %r14, %rdi
callq 0x1d6e
movq %r14, %rdi
callq 0x1da7
addq $0x10, %r14
movq %r14, %rdi
callq 0x1dfd
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_open_output_file
struct value*
builtin_open_output_file(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("open-output-file", args, 1);
    ASSERT_TYPE("open-output-file", args, 0, VALUE_STRING);

    struct value* path = CAR(args);

    FILE* port = fopen(path->as.string, "wb");
    if (port == NULL) {
        fprintf(stderr, "failed to open output file: %s\n", path->as.string);
        perror("reason");
        exit(EXIT_FAILURE);
    }

    return vm_make_output_port(vm, port);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4ac0
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x5, (%rax)
jne 0x4ac8
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r14
movq 0x10(%rax), %rdi
leaq 0x3860(%rip), %rsi      # 0x8304
callq 0x1190
testq %rax, %rax
je 0x4ad0
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x733c
movq %r14, %rdi
callq 0x1e30
movq %r14, %rdi
callq 0x1e69
addq $0x10, %r14
movq %r14, %rdi
callq 0x1ebf
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_close_input_port
struct value*
builtin_close_input_port(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("close-input-port", args, 1);
    ASSERT_TYPE("close-input-port", args, 0, VALUE_INPUT_PORT);

    struct value* port = CAR(args);
    fclose(port->as.port);

    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4b23
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xa, (%rax)
jne 0x4b2b
movq %r14, %rdi
callq 0x5b2b
movq 0x10(%rax), %rdi
callq 0x1160
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7071
movq %r14, %rdi
callq 0x1ef2
movq %r14, %rdi
callq 0x1f2b
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_close_output_port
struct value*
builtin_close_output_port(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("close-output-port", args, 1);
    ASSERT_TYPE("close-output-port", args, 0, VALUE_OUTPUT_PORT);

    struct value* port = CAR(args);
    fclose(port->as.port);

    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4b7a
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xb, (%rax)
jne 0x4b82
movq %r14, %rdi
callq 0x5b2b
movq 0x10(%rax), %rdi
callq 0x1160
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7071
movq %r14, %rdi
callq 0x1f81
movq %r14, %rdi
callq 0x1fba
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_read
struct value*
builtin_read(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("read", args, 0, 1);

    long arity = list_length(args);
    if (arity == 1) {
        ASSERT_TYPE("read", args, 0, VALUE_INPUT_PORT);
    }

    struct value* port = NULL;
    if (arity == 1) {
        port = CAR(args);
    } else {
        port = vm_make_input_port(vm, stdin);
    }

    FILE* fp = port->as.port;
    return reader_read(vm, fp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
testq %rax, %rax
je 0x4baf
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4bfb
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4bd6
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xa, (%rax)
jne 0x4c03
movq %r14, %rdi
callq 0x5b2b
jmp 0x4be8
movq 0x93fb(%rip), %rax      # 0xdfd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7303
movq 0x10(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x675f
movq %r14, %rdi
callq 0x2010
movq %r14, %rdi
callq 0x204c
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_read_char
struct value*
builtin_read_char(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("read-char", args, 0, 1);

    long arity = list_length(args);
    if (arity == 1) {
        ASSERT_TYPE("read-char", args, 0, VALUE_INPUT_PORT);
    }

    struct value* port = NULL;
    if (arity == 1) {
        port = CAR(args);
    } else {
        port = vm_make_input_port(vm, stdin);
    }

    FILE* fp = port->as.port;

    int c = fgetc(fp);
    if (ferror(fp)) {
        perror("error reading from port");
        exit(EXIT_FAILURE);
    }

    if (c == EOF && feof(fp)) {
        return vm_make_eof(vm);
    }

    return vm_make_character(vm, c);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
testq %rax, %rax
je 0x4c34
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4cb7
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4c5b
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xa, (%rax)
jne 0x4cbf
movq %r14, %rdi
callq 0x5b2b
jmp 0x4c6d
movq 0x9376(%rip), %rax      # 0xdfd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7303
movq 0x10(%rax), %r14
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movq %r14, %rdi
callq 0x1250
testl %eax, %eax
jne 0x4cb2
cmpl $-0x1, %ebp
je 0x4c9a
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x70fa
movq %r14, %rdi
callq 0x1230
testl %eax, %eax
je 0x4c8c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x743d
callq 0x2134
movq %r14, %rdi
callq 0x20a2
movq %r14, %rdi
callq 0x20de
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_peek_char
struct value*
builtin_peek_char(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("peek-char", args, 0, 1);

    long arity = list_length(args);
    if (arity == 1) {
        ASSERT_TYPE("peek-char", args, 0, VALUE_INPUT_PORT);
    }

    struct value* port = NULL;
    if (arity == 1) {
        port = CAR(args);
    } else {
        port = vm_make_input_port(vm, stdin);
    }

    FILE* fp = port->as.port;

    int c = fgetc(fp);
    if (ferror(fp)) {
        perror("error reading from port");
        exit(EXIT_FAILURE);
    }

    if (c == EOF && feof(fp)) {
        return vm_make_eof(vm);
    }

    ungetc(c, fp);

    return vm_make_character(vm, c);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
testq %rax, %rax
je 0x4cf0
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4d7d
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4d17
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xa, (%rax)
jne 0x4d85
movq %r14, %rdi
callq 0x5b2b
jmp 0x4d29
movq 0x92ba(%rip), %rax      # 0xdfd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7303
movq 0x10(%rax), %r14
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movq %r14, %rdi
callq 0x1250
testl %eax, %eax
jne 0x4d78
cmpl $-0x1, %ebp
je 0x4d60
movl %ebp, %edi
movq %r14, %rsi
callq 0x1090
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x70fa
movq %r14, %rdi
callq 0x1230
testl %eax, %eax
je 0x4d48
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x743d
callq 0x21db
movq %r14, %rdi
callq 0x2149
movq %r14, %rdi
callq 0x2185
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_is_char_ready
struct value*
builtin_is_char_ready(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("char-ready?", args, 0, 1);

    long arity = list_length(args);
    if (arity == 1) {
        ASSERT_TYPE("char-ready?", args, 0, VALUE_INPUT_PORT);
    }

    struct value* port = NULL;
    if (arity == 1) {
        port = CAR(args);
    } else {
        port = vm_make_input_port(vm, stdin);
    }

    FILE* fp = port->as.port;

    int c = fgetc(fp);
    if (ferror(fp)) {
        perror("error reading from port");
        exit(EXIT_FAILURE);
    }

    if (c == EOF && feof(fp)) {
        return vm_make_boolean(vm, true);
    }

    ungetc(c, fp);

    return vm_make_boolean(vm, true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
testq %rax, %rax
je 0x4df3
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4e79
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x4e1a
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xa, (%rax)
jne 0x4e81
movq %r14, %rdi
callq 0x5b2b
jmp 0x4e2c
movq 0x91b7(%rip), %rax      # 0xdfd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7303
movq 0x10(%rax), %r14
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movq %r14, %rdi
callq 0x1250
testl %eax, %eax
jne 0x4e74
cmpl $-0x1, %ebp
je 0x4e57
movl %ebp, %edi
movq %r14, %rsi
callq 0x1090
jmp 0x4e63
movq %r14, %rdi
callq 0x1230
testl %eax, %eax
je 0x4e4b
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x70c3
callq 0x22bb
movq %r14, %rdi
callq 0x2229
movq %r14, %rdi
callq 0x2265
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_write
struct value*
builtin_write(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("write", args, 1, 2);

    long arity = list_length(args);
    if (arity == 2) {
        ASSERT_TYPE("write", args, 1, VALUE_OUTPUT_PORT);
    }

    struct value* obj = CAR(args);

    struct value* port = NULL;
    if (arity == 2) {
        port = CADR(args);
    } else {
        port = vm_make_output_port(vm, stdout);
    }

    value_print(port->as.port, obj);
    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
je 0x4eb0
movq %r14, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x4f23
movq %r14, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x4eed
movl $0x1, %esi
movq %r14, %rdi
callq 0x5acc
cmpl $0xb, (%rax)
jne 0x4f2b
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
jmp 0x4f0a
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq 0x90c1(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x733c
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x6a63
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7071
movq %r14, %rdi
callq 0x22d0
movq %r14, %rdi
callq 0x230d
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_display
struct value*
builtin_display(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("display", args, 1, 2);

    long arity = list_length(args);
    if (arity == 2) {
        ASSERT_TYPE("display", args, 1, VALUE_OUTPUT_PORT);
    }

    struct value* obj = CAR(args);

    struct value* port = NULL;
    if (arity == 2) {
        port = CADR(args);
    } else {
        port = vm_make_output_port(vm, stdout);
    }

    value_print(port->as.port, obj);
    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
je 0x4f5a
movq %r14, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x4fcd
movq %r14, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x4f97
movl $0x1, %esi
movq %r14, %rdi
callq 0x5acc
cmpl $0xb, (%rax)
jne 0x4fd5
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
jmp 0x4fb4
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq 0x9017(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x733c
movq 0x10(%rax), %rdi
movq %r15, %rsi
callq 0x6a63
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7071
movq %r14, %rdi
callq 0x2366
movq %r14, %rdi
callq 0x23a3
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_newline
struct value*
builtin_newline(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("newline", args, 0, 1);

    long arity = list_length(args);
    if (arity == 1) {
        ASSERT_TYPE("newline", args, 0, VALUE_OUTPUT_PORT);
    }

    struct value* port = NULL;
    if (arity == 1) {
        port = CAR(args);
    } else {
        port = vm_make_output_port(vm, stdout);
    }

    fputc('\n', port->as.port);
    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
testq %rax, %rax
je 0x5002
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x5058
movq %r14, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x5029
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xb, (%rax)
jne 0x5060
movq %r14, %rdi
callq 0x5b2b
jmp 0x503b
movq 0x8f90(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x733c
movq 0x10(%rax), %rsi
movl $0xa, %edi
callq 0x11c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7071
movq %r14, %rdi
callq 0x23fc
movq %r14, %rdi
callq 0x2438
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_write_char
struct value*
builtin_write_char(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_OR("write-char", args, 1, 2);
    ASSERT_TYPE("write-char", args, 0, VALUE_CHARACTER);

    long arity = list_length(args);
    if (arity == 2) {
        ASSERT_TYPE("write-char", args, 1, VALUE_OUTPUT_PORT);
    }

    struct value* obj = CAR(args);

    struct value* port = NULL;
    if (arity == 2) {
        port = CADR(args);
    } else {
        port = vm_make_output_port(vm, stdout);
    }

    fputc(obj->as.character, port->as.port);
    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
je 0x5093
movq %r14, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x511e
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x3, (%rax)
jne 0x5116
movq %r14, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x50df
movl $0x1, %esi
movq %r14, %rdi
callq 0x5acc
cmpl $0xb, (%rax)
jne 0x5126
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
jmp 0x50fc
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq 0x8ecf(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x733c
movl 0x10(%r15), %edi
movq 0x10(%rax), %rsi
callq 0x11c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7071
movq %r14, %rdi
callq 0x24cb
movq %r14, %rdi
callq 0x248e
movq %r14, %rdi
callq 0x2521
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_make_window
struct value*
builtin_make_window(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("make-window", args, 3);
    ASSERT_TYPE("make-window", args, 0, VALUE_STRING);
    ASSERT_TYPE("make-window", args, 1, VALUE_NUMBER);
    ASSERT_TYPE("make-window", args, 2, VALUE_NUMBER);

    struct value* title = list_nth(args, 0);
    struct value* width = list_nth(args, 1);
    struct value* height = list_nth(args, 2);

    return vm_make_window(vm, title->as.string, width->as.number, height->as.number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5a98
cmpq $0x3, %rax
jne 0x5204
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0x5, (%rax)
jne 0x520c
movl $0x1, %esi
movq %rbx, %rdi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x5214
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x521c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5acc
movq %rax, %r15
movl $0x1, %esi
movq %rbx, %rdi
callq 0x5acc
movq %rax, %r12
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5acc
movq 0x10(%r15), %rsi
movq 0x10(%r12), %rdx
movq 0x10(%rax), %rcx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7375
movq %rbx, %rdi
callq 0x25b3
movq %rbx, %rdi
callq 0x25e9
movq %rbx, %rdi
callq 0x263f
movq %rbx, %rdi
callq 0x2698
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_window_clear
struct value*
builtin_window_clear(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("window-clear!", args, 1);
    ASSERT_TYPE("window-clear!", args, 0, VALUE_WINDOW);

    struct value* window = CAR(args);

    SDL_SetRenderDrawColor(window->as.window.renderer, 0, 0, 0, 255);
    SDL_RenderClear(window->as.window.renderer);

    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x5283
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xc, (%rax)
jne 0x528b
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r14
movq 0x18(%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xff, %r8d
callq 0x1210
movq 0x18(%r14), %rdi
callq 0x1150
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7071
movq %r14, %rdi
callq 0x26f0
movq %r14, %rdi
callq 0x2729
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_window_draw_line
struct value*
builtin_window_draw_line(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("window-draw-line!", args, 5);
    ASSERT_TYPE("window-draw-line!", args, 0, VALUE_WINDOW);
    ASSERT_TYPE("window-draw-line!", args, 1, VALUE_NUMBER);
    ASSERT_TYPE("window-draw-line!", args, 2, VALUE_NUMBER);
    ASSERT_TYPE("window-draw-line!", args, 3, VALUE_NUMBER);
    ASSERT_TYPE("window-draw-line!", args, 4, VALUE_NUMBER);

    struct value* window = list_nth(args, 0);
    struct value* x1 = list_nth(args, 1);
    struct value* y1 = list_nth(args, 2);
    struct value* x2 = list_nth(args, 3);
    struct value* y2 = list_nth(args, 4);

    SDL_SetRenderDrawColor(window->as.window.renderer, 255, 255, 255, 255);
    SDL_RenderDrawLine(window->as.window.renderer,
        x1->as.number, y1->as.number,
        x2->as.number, y2->as.number);

    return vm_make_empty_list(vm);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x5, %rax
jne 0x53bb
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xc, (%rax)
jne 0x53c3
movl $0x1, %esi
movq %r14, %rdi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x53cb
movl $0x2, %esi
movq %r14, %rdi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x53d3
movl $0x3, %esi
movq %r14, %rdi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x53db
movl $0x4, %esi
movq %r14, %rdi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x53e3
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x5acc
movq %rax, %r12
movl $0x2, %esi
movq %r14, %rdi
callq 0x5acc
movq %rax, %r13
movl $0x3, %esi
movq %r14, %rdi
callq 0x5acc
movq %rax, %rbp
movl $0x4, %esi
movq %r14, %rdi
callq 0x5acc
movq %rax, %r14
movq 0x18(%r15), %rdi
movl $0xff, %esi
movl $0xff, %edx
movl $0xff, %ecx
movl $0xff, %r8d
callq 0x1210
movq 0x18(%r15), %rdi
movl 0x10(%r12), %esi
movl 0x10(%r13), %edx
movl 0x10(%rbp), %ecx
movl 0x10(%r14), %r8d
callq 0x10a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7071
movq %r14, %rdi
callq 0x277f
movq %r14, %rdi
callq 0x27b5
movq %r14, %rdi
callq 0x280b
movq %r14, %rdi
callq 0x2864
movq %r14, %rdi
callq 0x28bc
movq %r14, %rdi
callq 0x2914
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_window_present
struct value*
builtin_window_present(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("window-present!", args, 1);
    ASSERT_TYPE("window-present!", args, 0, VALUE_WINDOW);

    struct value* window = CAR(args);
    SDL_RenderPresent(window->as.window.renderer);

    return vm_make_empty_list(vm);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x5432
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xc, (%rax)
jne 0x543a
movq %r14, %rdi
callq 0x5b2b
movq 0x18(%rax), %rdi
callq 0x1080
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7071
movq %r14, %rdi
callq 0x296f
movq %r14, %rdi
callq 0x29a8
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_event_poll
struct value*
builtin_event_poll(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("event-poll", args, 1);
    ASSERT_TYPE("event-poll", args, 0, VALUE_WINDOW);

    SDL_Event* event = malloc(sizeof(SDL_Event));
    int rc = SDL_PollEvent(event);
    if (rc == 0) {
        free(event);
        return vm_make_empty_list(vm);
    } else {
        return vm_make_event(vm, event);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x54e8
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xc, (%rax)
jne 0x54f0
movl $0x38, %edi
callq 0x11d0
movq %rax, %r14
movq %rax, %rdi
callq 0x10e0
testl %eax, %eax
je 0x54d1
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7404
movq %r14, %rdi
callq 0x11a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7071
movq %r14, %rdi
callq 0x2a37
movq %r14, %rdi
callq 0x2a70
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_event_type
struct value*
builtin_event_type(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("event-type", args, 1);
    ASSERT_TYPE("event-type", args, 0, VALUE_EVENT);

    struct value* event = CAR(args);
    switch (event->as.event->type) {
        case SDL_KEYDOWN:
//        case SDL_KEYUP:
            return vm_make_symbol(vm, "event-keyboard");
        case SDL_MOUSEMOTION:
            return vm_make_symbol(vm, "event-mousemotion");
//        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:
            return vm_make_symbol(vm, "event-mousebutton");
        case SDL_QUIT:
            return vm_make_symbol(vm, "event-quit");
        case SDL_WINDOWEVENT:
            return vm_make_symbol(vm, "event-window");
        default:
            return vm_make_symbol(vm, "event-undefined");
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x55a2
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xd, (%rax)
jne 0x55aa
movq %r14, %rdi
callq 0x5b2b
movq 0x10(%rax), %rax
movl (%rax), %eax
cmpl $0x2ff, %eax            # imm = 0x2FF
jle 0x555a
cmpl $0x300, %eax            # imm = 0x300
je 0x5571
cmpl $0x402, %eax            # imm = 0x402
je 0x557a
cmpl $0x400, %eax            # imm = 0x400
jne 0x558c
leaq 0x2e3d(%rip), %rsi      # 0x8395
jmp 0x5593
cmpl $0x100, %eax            # imm = 0x100
je 0x5583
cmpl $0x200, %eax            # imm = 0x200
jne 0x558c
leaq 0x2e55(%rip), %rsi      # 0x83c4
jmp 0x5593
leaq 0x2e0e(%rip), %rsi      # 0x8386
jmp 0x5593
leaq 0x2e26(%rip), %rsi      # 0x83a7
jmp 0x5593
leaq 0x2e2f(%rip), %rsi      # 0x83b9
jmp 0x5593
leaq 0x2e3e(%rip), %rsi      # 0x83d1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x71ce
movq %r14, %rdi
callq 0x2ac6
movq %r14, %rdi
callq 0x2aff
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_event_key
struct value*
builtin_event_key(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("event-type", args, 1);
    ASSERT_TYPE("event-type", args, 0, VALUE_EVENT);

    struct value* event = CAR(args);
    switch (event->as.event->key.keysym.sym) {
        case SDLK_ESCAPE:
            return vm_make_symbol(vm, "key-escape");
        case SDLK_LEFT:
            return vm_make_symbol(vm, "key-left");
        case SDLK_RIGHT:
            return vm_make_symbol(vm, "key-right");
        default:
            return vm_make_symbol(vm, "key-undefined");
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x1, %rax
jne 0x562c
movq %r14, %rdi
xorl %esi, %esi
callq 0x5acc
cmpl $0xd, (%rax)
jne 0x5634
movq %r14, %rdi
callq 0x5b2b
movq 0x10(%rax), %rax
movl 0x14(%rax), %eax
cmpl $0x1b, %eax
je 0x560d
cmpl $0x4000004f, %eax       # imm = 0x4000004F
je 0x5604
cmpl $0x40000050, %eax       # imm = 0x40000050
jne 0x5616
leaq 0x2dea(%rip), %rsi      # 0x83ec
jmp 0x561d
leaq 0x2dea(%rip), %rsi      # 0x83f5
jmp 0x561d
leaq 0x2dcd(%rip), %rsi      # 0x83e1
jmp 0x561d
leaq 0x2de2(%rip), %rsi      # 0x83ff
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x71ce
movq %r14, %rdi
callq 0x2b55
movq %r14, %rdi
callq 0x2b8e
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/env.c
// Function: env_empty
struct value*
env_empty(struct vm* vm)
{
    return env_extend(vm,
        vm_make_empty_list(vm),
        vm_make_empty_list(vm),
        vm_make_empty_list(vm));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x7071
movq %rax, %r14
movq %rbx, %rdi
callq 0x7071
movq %rax, %r15
movq %rbx, %rdi
callq 0x7071
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x5675
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/env.c
// Function: env_extend
struct value*
env_extend(struct vm* vm, struct value* vars, struct value* vals, struct value* env)
{
    long vars_len = list_length(vars);
    long vals_len = list_length(vals);
    assert(vars_len == vals_len && "mismatched number of vars/vals supplied to env_extend");

    return vm_make_pair(vm, make_frame(vm, vars, vals), env);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5a98
movq %rax, %r13
movq %r15, %rdi
callq 0x5a98
cmpq %rax, %r13
jne 0x56c7
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7232
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7232
leaq 0x2d3f(%rip), %rdi      # 0x840d
leaq 0x2d88(%rip), %rsi      # 0x845d
leaq 0x2d8b(%rip), %rcx      # 0x8467
movl $0x43, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/env.c
// Function: env_lookup
struct value*
env_lookup(struct vm* vm, struct value* var, struct value* env)
{
    assert(value_is_symbol(var) && "non-symbol key passed to env_lookup");

    if (value_is_empty_list(env)) {
        fprintf(stderr, "unbound variable: %s\n", var->as.symbol);
        exit(EXIT_FAILURE);
    }

    struct value* frame = first_frame(env);
    struct value* val = frame_lookup(vm, var, frame_vars(frame), frame_vals(frame));
    if (val != NULL) return val;
    return env_lookup(vm, var, rest_frames(env));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x6, (%rsi)
jne 0x5740
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0x1, (%r14)
je 0x576b
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %rax, %rdi
callq 0x5b2b
movq %rax, %r12
movq %r15, %rdi
callq 0x5abc
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x5773
testq %rax, %rax
jne 0x575f
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x6, (%rbx)
je 0x56f9
leaq 0x2d76(%rip), %rdi      # 0x84bd
leaq 0x2d0f(%rip), %rsi      # 0x845d
leaq 0x2da6(%rip), %rcx      # 0x84fb
movl $0x4b, %edx
callq 0x10f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2be4
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/env.c
// Function: frame_lookup
static struct value*
frame_lookup(struct vm* vm, struct value* var, struct value* vars, struct value* vals)
{
    if (value_is_empty_list(vars) && value_is_empty_list(vals)) return NULL;
    assert(!value_is_empty_list(vars) && "env frame has mismatched vars and vals");
    assert(!value_is_empty_list(vals) && "env frame has mismatched vars and vals");

    if (value_is_equal(var, CAR(vars))) return CAR(vals);
    return frame_lookup(vm, var, CDR(vars), CDR(vals));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpl $0x1, (%rsi)
je 0x57be
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x1, (%rbx)
je 0x57d8
movq %r15, %rdi
callq 0x5b2b
movq %r14, %rdi
movq %rax, %rsi
callq 0x6cff
testb %al, %al
jne 0x57cb
movq %r15, %rdi
callq 0x5abc
movq %rax, %r15
movq %rbx, %rdi
callq 0x5abc
movq %rax, %rbx
cmpl $0x1, (%r15)
jne 0x5786
cmpl $0x1, (%rbx)
jne 0x57f7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5b2b
leaq 0x2f3f(%rip), %rdi      # 0x871e
leaq 0x2c77(%rip), %rsi      # 0x845d
leaq 0x2ed9(%rip), %rcx      # 0x86c6
movl $0x13, %edx
callq 0x10f0
leaq 0x2e81(%rip), %rdi      # 0x867f
leaq 0x2c58(%rip), %rsi      # 0x845d
leaq 0x2eba(%rip), %rcx      # 0x86c6
movl $0x12, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/env.c
// Function: env_update
struct value*
env_update(struct vm* vm, struct value* var, struct value* val, struct value* env)
{
    assert(value_is_symbol(var) && "non-symbol key passed to env_update");

    if (value_is_empty_list(env)) {
        fprintf(stderr, "unbound variable: %s\n", var->as.symbol);
        exit(EXIT_FAILURE);
    }

    struct value* frame = first_frame(env);
    struct value* existing_val = frame_lookup(vm, var, frame_vars(frame), frame_vals(frame));
    if (existing_val != NULL) return frame_update(vm, var, val, frame_vars(frame), frame_vals(frame));
    return env_update(vm, var, val, rest_frames(env));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x6, (%rsi)
jne 0x587e
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x1, (%r12)
je 0x58cf
movq %r12, %rdi
callq 0x5b2b
movq %rax, %r13
movq %rax, %rdi
callq 0x5b2b
movq %rax, %rbp
movq %r13, %rdi
callq 0x5abc
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x5773
testq %rax, %rax
jne 0x589d
movq %r12, %rdi
callq 0x5abc
movq %rax, %r12
cmpl $0x6, (%rbx)
je 0x5832
leaq 0x2cd2(%rip), %rdi      # 0x8557
leaq 0x2bd1(%rip), %rsi      # 0x845d
leaq 0x2d02(%rip), %rcx      # 0x8595
movl $0x5b, %edx
callq 0x10f0
movq %r13, %rdi
callq 0x5b2b
movq %rax, %r12
movq %r13, %rdi
callq 0x5abc
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x58d7
movq %rbx, %rdi
callq 0x2c0c
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/env.c
// Function: frame_update
static struct value*
frame_update(struct vm* vm, struct value* var, struct value* val, struct value* vars, struct value* vals)
{
    if (value_is_empty_list(vars) && value_is_empty_list(vals)) return NULL;
    assert(!value_is_empty_list(vars) && "env frame has mismatched vars and vals");
    assert(!value_is_empty_list(vals) && "env frame has mismatched vars and vals");

    if (value_is_equal(var, CAR(vars))) {
        vals->as.pair.car = val;
        return vm_make_empty_list(vm);
    }

    return frame_update(vm, var, val, CDR(vars), CDR(vals));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
cmpl $0x1, (%rcx)
je 0x592d
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpl $0x1, (%rbx)
je 0x5953
movq %r13, %rdi
callq 0x5b2b
movq %r12, %rdi
movq %rax, %rsi
callq 0x6cff
testb %al, %al
jne 0x593e
movq %r13, %rdi
callq 0x5abc
movq %rax, %r13
movq %rbx, %rdi
callq 0x5abc
movq %rax, %rbx
cmpl $0x1, (%r13)
jne 0x58f4
cmpl $0x1, (%rbx)
jne 0x5972
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, 0x10(%rbx)
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7071
leaq 0x2dc4(%rip), %rdi      # 0x871e
leaq 0x2afc(%rip), %rsi      # 0x845d
leaq 0x2dfd(%rip), %rcx      # 0x8765
movl $0x1e, %edx
callq 0x10f0
leaq 0x2d06(%rip), %rdi      # 0x867f
leaq 0x2add(%rip), %rsi      # 0x845d
leaq 0x2dde(%rip), %rcx      # 0x8765
movl $0x1d, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/env.c
// Function: env_define
struct value*
env_define(struct vm* vm, struct value* var, struct value* val, struct value* env)
{
    assert(value_is_symbol(var) && "non-symbol key passed to env_define");

    struct value* frame = first_frame(env);
    struct value* existing_val = frame_lookup(vm, var, frame_vars(frame), frame_vals(frame));
    if (existing_val != NULL) return frame_update(vm, var, val, frame_vars(frame), frame_vals(frame));
    return frame_add_binding(vm, var, val, frame);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x6, (%rsi)
jne 0x5a57
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x5b2b
movq %rax, %r15
movq %rax, %rdi
callq 0x5b2b
movq %rax, %r13
movq %r15, %rdi
callq 0x5abc
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5773
testq %rax, %rax
je 0x5a0d
movq %r15, %rdi
callq 0x5b2b
movq %rax, %r13
movq %r15, %rdi
callq 0x5abc
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %rax, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x58d7
testq %r15, %r15
je 0x5a76
movq %r15, %rdi
callq 0x5b2b
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7232
movq %rax, 0x10(%r15)
movq %r15, %rdi
callq 0x5abc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7232
movq %rax, 0x18(%r15)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7071
leaq 0x2b8d(%rip), %rdi      # 0x85eb
leaq 0x29f8(%rip), %rsi      # 0x845d
leaq 0x2bbd(%rip), %rcx      # 0x8629
movl $0x6b, %edx
callq 0x10f0
leaq 0x2d50(%rip), %rdi      # 0x87cd
leaq 0x29d9(%rip), %rsi      # 0x845d
leaq 0x2d50(%rip), %rcx      # 0x87db
movl $0x2b, %edx
callq 0x10f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/list.c
// Function: list_length
long
list_length(const struct value* list)
{
    long count = 0;

    const struct value* iter = list;
    while (!value_is_empty_list(iter)) {
        count++;
        iter = CDR(iter);
    }

    return count;
}

// Assembly:
pushq %rbx
cmpl $0x1, (%rdi)
jne 0x5aa2
xorl %ebx, %ebx
jmp 0x5ab7
movq %rdi, %rax
xorl %ebx, %ebx
incq %rbx
movq %rax, %rdi
callq 0x5abc
cmpl $0x1, (%rax)
jne 0x5aa7
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/list.c
// Function: list_nth
struct value*
list_nth(const struct value* list, long n)
{
    if (n < 0 || n >= list_length(list)) {
        fprintf(stderr, "list: invalid index: %ld\n", n);
        exit(EXIT_FAILURE);
    }

    const struct value* iter = list;
    for (long i = 0; i < n; i++) {
        iter = CDR(iter);
    }

    return CAR(iter);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
js 0x5b23
movq %rdi, %r14
cmpl $0x1, (%rdi)
jne 0x5ae6
xorl %r15d, %r15d
jmp 0x5afc
xorl %r15d, %r15d
movq %r14, %rax
incq %r15
movq %rax, %rdi
callq 0x5abc
cmpl $0x1, (%rax)
jne 0x5aec
cmpq %rbx, %r15
jle 0x5b23
testq %rbx, %rbx
je 0x5b16
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
decq %rbx
jne 0x5b06
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5b2b
movq %rbx, %rdi
callq 0x2c59
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/mce.c
// Function: mce_apply
struct value*
mce_apply(struct vm* vm, struct value* proc, struct value* args)
{
    if (is_primitive_proc(proc)) {
        return proc->as.builtin(vm, args);
    } else if (is_compound_proc(proc)) {
        return eval_sequence(vm,
            proc->as.lambda.body,
            env_extend(vm, proc->as.lambda.params, args, proc->as.lambda.env));
    } else {
        fprintf(stderr, "runtime error (invalid proc) at: TODO\n");
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x9, %eax
je 0x61e1
cmpl $0x8, %eax
jne 0x6249
movq 0x10(%rsi), %rax
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %r15
movq 0x20(%rsi), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5675
movq %rax, %r14
movq %r15, %rdi
callq 0x5abc
cmpl $0x1, (%rax)
je 0x622e
movq %r15, %rdi
callq 0x5b2b
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x5b3c
movq %r15, %rdi
callq 0x5abc
movq %rax, %r15
movq %rax, %rdi
jmp 0x61fe
movq %r15, %rdi
callq 0x5b2b
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x5b3c
callq 0x2e31
nop
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: read_character
struct value*
read_character(struct vm* vm, FILE* fp)
{
    int c = advance(fp);
    switch (c) {
        case EOF:
            fprintf(stderr, "reader: incomplete character literal\n");
            exit(EXIT_FAILURE);
        case 's':
            if (peek(fp) == 'p') {
                eat_string(fp, "pace");
                peek_expect_delimiter(fp);
                return vm_make_character(vm, ' ');
            }
            break;
        case 'n':
            if (peek(fp) == 'e') {
                eat_string(fp, "ewline");
                peek_expect_delimiter(fp);
                return vm_make_character(vm, '\n');
            }
            break;
    }

    if (c < '!' || c > '~') {
        fprintf(stderr, "reader: non-printable character literal\n");
        exit(EXIT_FAILURE);
    }

    peek_expect_delimiter(fp);
    return vm_make_character(vm, c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1240
movl %eax, %ebp
cmpl $0x6e, %eax
je 0x62b2
cmpl $0x73, %ebp
je 0x6289
cmpl $-0x1, %ebp
je 0x62fd
movl %ebp, %eax
addl $-0x7f, %eax
cmpl $-0x5f, %eax
ja 0x62e1
callq 0x2e7b
movq %r14, %rdi
callq 0x1240
movl %eax, %r15d
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x70, %r15d
jne 0x62e1
movl $0x20, %ebp
leaq 0x2adf(%rip), %rsi      # 0x8d8f
jmp 0x62d9
movq %r14, %rdi
callq 0x1240
movl %eax, %r15d
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x65, %r15d
jne 0x62e1
movl $0xa, %ebp
leaq 0x2abe(%rip), %rsi      # 0x8d97
movq %r14, %rdi
callq 0x6302
movq %r14, %rdi
callq 0x633c
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70fa
callq 0x2e56
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: eat_string
static void
eat_string(FILE* fp, const char* s)
{
    // ensure that an expected string comes next in the file
    while (*s != '\0') {
        int c = advance(fp);
        if (c != *s) {
            fprintf(stderr, "reader: incomplete character literal\n");
            exit(EXIT_FAILURE);
        }
        s++;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rsi)
je 0x632f
movq %rsi, %r14
movq %rdi, %rbx
incq %r14
movq %rbx, %rdi
callq 0x1240
movsbl -0x1(%r14), %ecx
cmpl %ecx, %eax
jne 0x6337
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x6314
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2ea0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: peek_expect_delimiter
static void
peek_expect_delimiter(FILE* fp)
{
    // expect a delimiter to follow some token otherwise raise an error
    if (!is_delimiter(peek(fp))) {
        fprintf(stderr, "reader: token not followed by delimiter\n");
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1240
movl %eax, %ebp
movl %eax, %edi
movq %rbx, %rsi
callq 0x1090
movsbl %bpl, %ebx
leaq 0x28c7(%rip), %rdi      # 0x8c25
movl $0x7, %edx
movl %ebx, %esi
callq 0x1170
cmpb $-0x1, %bl
je 0x638c
testq %rax, %rax
jne 0x638c
leaq 0x28a5(%rip), %rdi      # 0x8c20
movl $0x5, %edx
movl %ebx, %esi
callq 0x1170
testq %rax, %rax
je 0x6393
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2ec5
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: read_number
struct value*
read_number(struct vm* vm, FILE* fp)
{
    // temp buffer to hold the number's contents
    char buf[MAX_NUMBER_SIZE] = { 0 };
    long i = 0;

    // read characters into the buffer until:
    // EOF is reached, non-numeric char is read, or buffer is filled
    int c;
    while ((c = advance(fp)) != EOF) {
        if (!is_digit(c)) break;

        // "- 2" here to account for terminator
        if (i >= MAX_NUMBER_SIZE - 2) {
            fprintf(stderr, "reader: numeric literal larger than %d characters\n", MAX_NUMBER_SIZE);
            exit(EXIT_FAILURE);
        }

        buf[i++] = c;
    }

    // put the last non-numeric char back
    rollback(fp, c);
    peek_expect_delimiter(fp);

    long number = strtol(buf, NULL, 10);
    return vm_make_number(vm, number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x1240
cmpl $-0x1, %eax
je 0x6406
xorl %r15d, %r15d
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x640b
cmpq $0x7e, %r15
je 0x6443
movb %al, (%rsp,%r15)
incq %r15
movq %r14, %rdi
callq 0x1240
cmpl $-0x1, %eax
jne 0x63e4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
movq %r14, %rdi
callq 0x633c
movq %rsp, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1200
movq %rbx, %rdi
movq %rax, %rsi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7131
callq 0x2eea
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: read_string
struct value*
read_string(struct vm* vm, FILE* fp)
{
    // temp buffer to hold the string's contents
    char buf[MAX_STRING_SIZE] = { 0 };
    long i = 0;

    // skip leading quote
    advance(fp);

    // read characters into the buffer until:
    // EOF is reached, closing quote, or buffer is filled
    int c;
    while ((c = advance(fp)) != EOF) {
        if (c == '"') break;

        // "- 2" here to account for terminator
        if (i >= MAX_STRING_SIZE - 2) {
            fprintf(stderr, "reader: string literal larger than %d characters\n", MAX_STRING_SIZE);
            exit(EXIT_FAILURE);
        }

        buf[i++] = c;
    }

    // unterminated string literal is an error
    if (c == EOF) {
        fprintf(stderr, "reader: incomplete string literal\n");
        exit(EXIT_FAILURE);
    }

    peek_expect_delimiter(fp);
    return vm_make_string(vm, buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
xorl %r15d, %r15d
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x10d0
movq %r14, %rdi
callq 0x1240
movq %r14, %rdi
callq 0x1240
cmpl $0x22, %eax
je 0x6498
cmpl $-0x1, %eax
je 0x64b8
cmpq $0xfe, %r15
je 0x64bd
movb %al, (%rsp,%r15)
incq %r15
jmp 0x6474
movq %r14, %rdi
callq 0x633c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x716a
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
callq 0x2f10
callq 0x2f35