LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x5ab0
cmpq $0x1, %rax
jne 0x5298
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ae4
cmpl $0xc, (%rax)
jne 0x52a0
movq %r14, %rdi
callq 0x5b51
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 0x7044
movq %r14, %rdi
callq 0x26f0
movq %r14, %rdi
callq 0x2729
// File: /workspace/github_c_makefile_star2_O1/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 0x5ab0
cmpq $0x5, %rax
jne 0x53d0
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ae4
cmpl $0xc, (%rax)
jne 0x53d8
movl $0x1, %esi
movq %r14, %rdi
callq 0x5ae4
cmpl $0x4, (%rax)
jne 0x53e0
movl $0x2, %esi
movq %r14, %rdi
callq 0x5ae4
cmpl $0x4, (%rax)
jne 0x53e8
movl $0x3, %esi
movq %r14, %rdi
callq 0x5ae4
cmpl $0x4, (%rax)
jne 0x53f0
movl $0x4, %esi
movq %r14, %rdi
callq 0x5ae4
cmpl $0x4, (%rax)
jne 0x53f8
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ae4
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x5ae4
movq %rax, %r12
movl $0x2, %esi
movq %r14, %rdi
callq 0x5ae4
movq %rax, %r13
movl $0x3, %esi
movq %r14, %rdi
callq 0x5ae4
movq %rax, %rbp
movl $0x4, %esi
movq %r14, %rdi
callq 0x5ae4
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 0x7044
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_O1/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 0x5ab0
cmpq $0x1, %rax
jne 0x5447
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ae4
cmpl $0xc, (%rax)
jne 0x544f
movq %r14, %rdi
callq 0x5b51
movq 0x18(%rax), %rdi
callq 0x1080
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7044
movq %r14, %rdi
callq 0x296f
movq %r14, %rdi
callq 0x29a8
// File: /workspace/github_c_makefile_star2_O1/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 0x5ab0
cmpq $0x1, %rax
jne 0x54fd
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ae4
cmpl $0xc, (%rax)
jne 0x5505
movl $0x38, %edi
callq 0x11d0
movq %rax, %r14
movq %rax, %rdi
callq 0x10e0
testl %eax, %eax
je 0x54e6
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x73d7
movq %r14, %rdi
callq 0x11a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7044
movq %r14, %rdi
callq 0x2a37
movq %r14, %rdi
callq 0x2a70
// File: /workspace/github_c_makefile_star2_O1/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 0x5ab0
cmpq $0x1, %rax
jne 0x55b7
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ae4
cmpl $0xd, (%rax)
jne 0x55bf
movq %r14, %rdi
callq 0x5b51
movq 0x10(%rax), %rax
movl (%rax), %eax
cmpl $0x2ff, %eax            # imm = 0x2FF
jle 0x556f
cmpl $0x300, %eax            # imm = 0x300
je 0x5586
cmpl $0x402, %eax            # imm = 0x402
je 0x558f
cmpl $0x400, %eax            # imm = 0x400
jne 0x55a1
leaq 0x2e28(%rip), %rsi      # 0x8395
jmp 0x55a8
cmpl $0x100, %eax            # imm = 0x100
je 0x5598
cmpl $0x200, %eax            # imm = 0x200
jne 0x55a1
leaq 0x2e40(%rip), %rsi      # 0x83c4
jmp 0x55a8
leaq 0x2df9(%rip), %rsi      # 0x8386
jmp 0x55a8
leaq 0x2e11(%rip), %rsi      # 0x83a7
jmp 0x55a8
leaq 0x2e1a(%rip), %rsi      # 0x83b9
jmp 0x55a8
leaq 0x2e29(%rip), %rsi      # 0x83d1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x71a1
movq %r14, %rdi
callq 0x2ac6
movq %r14, %rdi
callq 0x2aff
// File: /workspace/github_c_makefile_star2_O1/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 0x5ab0
cmpq $0x1, %rax
jne 0x5641
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ae4
cmpl $0xd, (%rax)
jne 0x5649
movq %r14, %rdi
callq 0x5b51
movq 0x10(%rax), %rax
movl 0x14(%rax), %eax
cmpl $0x1b, %eax
je 0x5622
cmpl $0x4000004f, %eax       # imm = 0x4000004F
je 0x5619
cmpl $0x40000050, %eax       # imm = 0x40000050
jne 0x562b
leaq 0x2dd5(%rip), %rsi      # 0x83ec
jmp 0x5632
leaq 0x2dd5(%rip), %rsi      # 0x83f5
jmp 0x5632
leaq 0x2db8(%rip), %rsi      # 0x83e1
jmp 0x5632
leaq 0x2dcd(%rip), %rsi      # 0x83ff
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x71a1
movq %r14, %rdi
callq 0x2b55
movq %r14, %rdi
callq 0x2b8e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x7044
movq %rax, %r14
movq %rbx, %rdi
callq 0x7044
movq %rax, %r15
movq %rbx, %rdi
callq 0x7044
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x568d
// File: /workspace/github_c_makefile_star2_O1/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 0x5ab0
movq %rax, %r13
movq %r15, %rdi
callq 0x5ab0
cmpq %rax, %r13
jne 0x56df
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7205
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7205
leaq 0x2d27(%rip), %rdi      # 0x840d
leaq 0x2d70(%rip), %rsi      # 0x845d
leaq 0x2d73(%rip), %rcx      # 0x8467
movl $0x43, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0x6, (%rbx)
jne 0x5769
cmpl $0x1, (%r14)
je 0x5761
movq %r14, %rdi
callq 0x5b51
movq %rax, %r15
movq %rax, %rdi
callq 0x5b51
movq %rax, %r12
movq %r15, %rdi
callq 0x5ad4
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x5788
testq %rax, %rax
jne 0x5755
movq %r14, %rdi
callq 0x5ad4
movq %rax, %r14
jmp 0x570c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x2be4
leaq 0x2d4d(%rip), %rdi      # 0x84bd
leaq 0x2ce6(%rip), %rsi      # 0x845d
leaq 0x2d7d(%rip), %rcx      # 0x84fb
movl $0x4b, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %r15
movq %rdi, %r14
movl (%r15), %eax
cmpl $0x1, %eax
jne 0x57a8
cmpl $0x1, (%rbx)
je 0x57e9
cmpl $0x1, %eax
je 0x5810
cmpl $0x1, (%rbx)
je 0x57f1
movq %r15, %rdi
callq 0x5b51
movq %r14, %rdi
movq %rax, %rsi
callq 0x6d47
testb %al, %al
jne 0x57dc
movq %r15, %rdi
callq 0x5ad4
movq %rax, %r15
movq %rbx, %rdi
callq 0x5ad4
movq %rax, %rbx
jmp 0x5796
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5b51
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2f26(%rip), %rdi      # 0x871e
leaq 0x2c5e(%rip), %rsi      # 0x845d
leaq 0x2ec0(%rip), %rcx      # 0x86c6
movl $0x13, %edx
callq 0x10f0
leaq 0x2e68(%rip), %rdi      # 0x867f
leaq 0x2c3f(%rip), %rsi      # 0x845d
leaq 0x2ea1(%rip), %rcx      # 0x86c6
movl $0x12, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x6, (%rbx)
jne 0x58ca
cmpl $0x1, (%r12)
je 0x58c2
movq %r12, %rdi
callq 0x5b51
movq %rax, %r13
movq %rax, %rdi
callq 0x5b51
movq %rax, %rbp
movq %r13, %rdi
callq 0x5ad4
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x5788
testq %rax, %rax
jne 0x5890
movq %r12, %rdi
callq 0x5ad4
movq %rax, %r12
jmp 0x5846
movq %r13, %rdi
callq 0x5b51
movq %rax, %r12
movq %r13, %rdi
callq 0x5ad4
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 0x58e9
movq %rbx, %rdi
callq 0x2c0c
leaq 0x2c86(%rip), %rdi      # 0x8557
leaq 0x2b85(%rip), %rsi      # 0x845d
leaq 0x2cb6(%rip), %rcx      # 0x8595
movl $0x5b, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl (%r13), %eax
cmpl $0x1, %eax
jne 0x5915
cmpl $0x1, (%r14)
je 0x595f
cmpl $0x1, %eax
je 0x598a
cmpl $0x1, (%r14)
je 0x596b
movq %r13, %rdi
callq 0x5b51
movq %r12, %rdi
movq %rax, %rsi
callq 0x6d47
testb %al, %al
jne 0x594a
movq %r13, %rdi
callq 0x5ad4
movq %rax, %r13
movq %r14, %rdi
callq 0x5ad4
movq %rax, %r14
jmp 0x5901
movq %rbx, 0x10(%r14)
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7044
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2dac(%rip), %rdi      # 0x871e
leaq 0x2ae4(%rip), %rsi      # 0x845d
leaq 0x2de5(%rip), %rcx      # 0x8765
movl $0x1e, %edx
callq 0x10f0
leaq 0x2cee(%rip), %rdi      # 0x867f
leaq 0x2ac5(%rip), %rsi      # 0x845d
leaq 0x2dc6(%rip), %rcx      # 0x8765
movl $0x1d, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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 0x5a6f
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x5b51
movq %rax, %r15
movq %rax, %rdi
callq 0x5b51
movq %rax, %r13
movq %r15, %rdi
callq 0x5ad4
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5788
testq %rax, %rax
je 0x5a25
movq %r15, %rdi
callq 0x5b51
movq %rax, %r13
movq %r15, %rdi
callq 0x5ad4
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 0x58e9
testq %r15, %r15
je 0x5a8e
movq %r15, %rdi
callq 0x5b51
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7205
movq %rax, 0x10(%r15)
movq %r15, %rdi
callq 0x5ad4
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7205
movq %rax, 0x18(%r15)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7044
leaq 0x2b75(%rip), %rdi      # 0x85eb
leaq 0x29e0(%rip), %rsi      # 0x845d
leaq 0x2ba5(%rip), %rcx      # 0x8629
movl $0x6b, %edx
callq 0x10f0
leaq 0x2d38(%rip), %rdi      # 0x87cd
leaq 0x29c1(%rip), %rsi      # 0x845d
leaq 0x2d38(%rip), %rcx      # 0x87db
movl $0x2b, %edx
callq 0x10f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x5aba
xorl %ebx, %ebx
jmp 0x5acf
movq %rdi, %rax
xorl %ebx, %ebx
incq %rbx
movq %rax, %rdi
callq 0x5ad4
cmpl $0x1, (%rax)
jne 0x5abf
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
testq %rsi, %rsi
js 0x5b49
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x5afe
xorl %r15d, %r15d
jmp 0x5b14
xorl %r15d, %r15d
movq %rbx, %rax
incq %r15
movq %rax, %rdi
callq 0x5ad4
cmpl $0x1, (%rax)
jne 0x5b04
cmpq %r14, %r15
jle 0x5b49
testq %r14, %r14
je 0x5b3c
cmpq $0x2, %r14
movl $0x1, %r15d
cmovgeq %r14, %r15
movq %rbx, %rdi
callq 0x5ad4
movq %rax, %rbx
decq %r15
jne 0x5b2c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5b51
movq %r14, %rdi
callq 0x2c59
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x9, %eax
je 0x6229
cmpl $0x8, %eax
jne 0x6252
movq 0x10(%rsi), %rax
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x568d
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6257
callq 0x2e31
// File: /workspace/github_c_makefile_star2_O1/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 0x62f8
cmpl $0x73, %ebp
je 0x62cf
cmpl $-0x1, %ebp
jne 0x6329
callq 0x2e56
movq %r14, %rdi
callq 0x1240
movl %eax, %r15d
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x70, %r15d
jne 0x6329
movl $0x20, %ebp
leaq 0x2a99(%rip), %rsi      # 0x8d8f
jmp 0x631f
movq %r14, %rdi
callq 0x1240
movl %eax, %r15d
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x65, %r15d
jne 0x6329
movl $0xa, %ebp
leaq 0x2a78(%rip), %rsi      # 0x8d97
movq %r14, %rdi
callq 0x6354
jmp 0x6333
movl %ebp, %eax
addl $-0x7f, %eax
cmpl $-0x5f, %eax
jbe 0x634f
movq %r14, %rdi
callq 0x638e
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70cd
callq 0x2e7b
// File: /workspace/github_c_makefile_star2_O1/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 0x6381
movq %rsi, %r14
movq %rdi, %rbx
incq %r14
movq %rbx, %rdi
callq 0x1240
movsbl -0x1(%r14), %ecx
cmpl %ecx, %eax
jne 0x6389
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x6366
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2ea0
// File: /workspace/github_c_makefile_star2_O1/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 0x2875(%rip), %rdi      # 0x8c25
movl $0x7, %edx
movl %ebx, %esi
callq 0x1170
cmpb $-0x1, %bl
je 0x63de
testq %rax, %rax
jne 0x63de
leaq 0x2853(%rip), %rdi      # 0x8c20
movl $0x5, %edx
movl %ebx, %esi
callq 0x1170
testq %rax, %rax
je 0x63e5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2ec5
// File: /workspace/github_c_makefile_star2_O1/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 0x6458
xorl %r15d, %r15d
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x6458
cmpq $0x7e, %r15
je 0x6490
movb %al, (%rsp,%r15)
incq %r15
movq %r14, %rdi
callq 0x1240
cmpl $-0x1, %eax
jne 0x6436
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
movq %r14, %rdi
callq 0x638e
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 0x7104
callq 0x2eea
// File: /workspace/github_c_makefile_star2_O1/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 0x64e5
cmpl $-0x1, %eax
je 0x6505
cmpq $0xfe, %r15
je 0x650a
movb %al, (%rsp,%r15)
incq %r15
jmp 0x64c1
movq %r14, %rdi
callq 0x638e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x713d
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
callq 0x2f10
callq 0x2f35
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/reader.c
// Function: read_symbol
struct value*
read_symbol(struct vm* vm, FILE* fp)
{
    // temp buffer to hold the symbol's contents
    char buf[MAX_STRING_SIZE] = { 0 };
    long i = 0;

    // grab the first character
    int c = advance(fp);
    buf[i++] = c;

    // check for peculiar identifier
    if (is_peculiar_identifier(c)) {
        if (c == '+' || c == '-') {
            peek_expect_delimiter(fp);
            return vm_make_symbol(vm, buf);
        }

        // only other peculiar identifier left at this point is "..."
        buf[i++] = advance(fp);
        buf[i++] = advance(fp);
        if (strcmp(buf, "...") == 0) {
            peek_expect_delimiter(fp);
            return vm_make_symbol(vm, buf);
        }

        fprintf(stderr, "reader: invalid symbol: %s\n", buf);
        exit(EXIT_FAILURE);
    }

    // at this point, the first char in buf must be an 'initial'

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

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

        buf[i++] = c;
    }

    // put non-symbol char back and ensure it was a delimiter
    rollback(fp, c);
    peek_expect_delimiter(fp);
    return vm_make_symbol(vm, buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x10d0
movq %r14, %rdi
callq 0x1240
movb %al, (%r15)
cmpb $0x2e, %al
ja 0x6599
movzbl %al, %ecx
movabsq $0x680000000000, %rdx   # imm = 0x680000000000
btq %rcx, %rdx
jae 0x6599
cmpl $0x2b, %eax
je 0x6625
cmpl $0x2d, %eax
je 0x6625
movq %r14, %rdi
callq 0x1240
movb %al, 0x1(%rsp)
movq %r14, %rdi
callq 0x1240
movb %al, 0x2(%rsp)
cmpl $0x2e2e2e, (%rsp)       # imm = 0x2E2E2E
je 0x6625
movq %rsp, %rdi
callq 0x2f5b
movq %r14, %rdi
callq 0x1240
movl %eax, %r15d
cmpl $-0x1, %eax
je 0x661a
movl $0x1, %r13d
leaq 0x267b(%rip), %r12      # 0x8c31
movl %r15d, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x1a, %al
jb 0x65fa
movsbl %r15b, %ebp
movl $0xf, %edx
movq %r12, %rdi
movl %ebp, %esi
callq 0x1170
leal -0x30(%r15), %ecx
cmpb $0xa, %cl
jb 0x65fa
testq %rax, %rax
jne 0x65fa
movl $0x5, %edx
leaq 0x263e(%rip), %rdi      # 0x8c2c
movl %ebp, %esi
callq 0x1170
testq %rax, %rax
je 0x661a
cmpq $0xfe, %r13
je 0x664a
movb %r15b, (%rsp,%r13)
incq %r13
movq %r14, %rdi
callq 0x1240
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0x65b6
movl %r15d, %edi
movq %r14, %rsi
callq 0x1090
movq %r14, %rdi
callq 0x638e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x71a1
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2f7f
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/reader.c
// Function: read_pair
struct value*
read_pair(struct vm* vm, FILE* fp)
{
    eat_whitespace(fp);

    // return the empty list upon finding a closing paren
    if (peek(fp) == ')') {
        advance(fp);
        return vm_make_empty_list(vm);
    }

    // read the first half of the pair
    struct value* car = reader_read(vm, fp);
    eat_whitespace(fp);

    // check for an "improper" list
    if (peek(fp) == '.') {
        advance(fp);
        peek_expect_delimiter(fp);

        // read the last expr
        struct value* cdr = reader_read(vm, fp);
        eat_whitespace(fp);

        // ensure a closing paren comes next
        if (peek(fp) != ')') {
            fprintf(stderr, "reader: expected closing paren after last expr in improper list\n");
            exit(EXIT_FAILURE);
        }

        // consume the closing paren
        advance(fp);
        return vm_make_pair(vm, car, cdr);
    }

    // read the next expr in a "normal" list
    struct value* cdr = read_pair(vm, fp);
    return vm_make_pair(vm, car, cdr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x673d
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x29, %ebp
jne 0x6696
movq %r14, %rdi
callq 0x1240
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7044
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67a6
movq %rax, %r15
movq %r14, %rdi
callq 0x673d
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x2e, %ebp
jne 0x6717
movq %r14, %rdi
callq 0x1240
movq %r14, %rdi
callq 0x638e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67a6
movq %rax, %r12
movq %r14, %rdi
callq 0x673d
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x29, %ebp
jne 0x6738
movq %r14, %rdi
callq 0x1240
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x672b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x664f
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7205
callq 0x2fa5
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/reader.c
// Function: eat_whitespace
static void
eat_whitespace(FILE* fp)
{
    int c;
    while ((c = advance(fp)) != EOF) {
        // if whitespace, eat and advance
        if (is_whitespace(c)) continue;

        // if comment found, eat til end of line
        if (c == ';') {
            while (((c = advance(fp)) != EOF) && (c != '\n'));
            continue;
        }

        // found a non-whitespace char at this point (put it back and break)
        rollback(fp, c);
        break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1240
cmpl $-0x1, %eax
je 0x6793
movl %eax, %ebp
leaq 0x24ce(%rip), %r14      # 0x8c25
movsbl %bpl, %esi
movl $0x7, %edx
movq %r14, %rdi
callq 0x1170
testq %rax, %rax
jne 0x6784
cmpl $0x3b, %ebp
jne 0x6798
movq %rbx, %rdi
callq 0x1240
cmpl $0xa, %eax
je 0x6784
cmpl $-0x1, %eax
jne 0x6772
movq %rbx, %rdi
callq 0x1240
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x6757
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/value.c
// Function: value_is_equal
bool
value_is_equal(const struct value* a, const struct value* b)
{
    if (a->type != b->type) return false;

    switch (a->type) {
        case VALUE_EMPTY_LIST:
            // all instances of the empty list are the same
            return true;
        case VALUE_BOOLEAN:
            return a->as.boolean == b->as.boolean;
        case VALUE_CHARACTER:
            return a->as.character == b->as.character;
        case VALUE_NUMBER:
            return a->as.number == b->as.number;
        case VALUE_STRING:
            return strcmp(a->as.string, b->as.string) == 0;
        case VALUE_SYMBOL:
            return strcmp(a->as.symbol, b->as.symbol) == 0;
        case VALUE_PAIR:
            return value_is_equal(a->as.pair.car, b->as.pair.car) &&
                   value_is_equal(a->as.pair.cdr, b->as.pair.cdr);
        case VALUE_BUILTIN:
            // direct pointer compare
            return a->as.builtin == b->as.builtin;
        case VALUE_LAMBDA:
            return value_is_equal(a->as.lambda.params, b->as.lambda.params) &&
                   value_is_equal(a->as.lambda.body, b->as.lambda.body) &&
                   value_is_equal(a->as.lambda.env, b->as.lambda.env);
        case VALUE_INPUT_PORT:
        case VALUE_OUTPUT_PORT:
            // direct pointer compare
            return a->as.port == b->as.port;
        case VALUE_WINDOW:
            // direct pointer compare
            return a->as.window.window == b->as.window.window &&
                   a->as.window.renderer == b->as.window.renderer;
        case VALUE_EVENT:
            // two events are never equal?
            return false;
        case VALUE_EOF:
            // all instances of EOF are the same
            return true;
    }

    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1f1f(%rip), %r15      # 0x8c78
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0x6dfa
decl %eax
cmpl $0xd, %eax
ja 0x6dfa
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x6d47
testb %al, %al
je 0x6dfa
movq 0x18(%r14), %r14
movq 0x18(%rbx), %rbx
jmp 0x6d59
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x6d47
testb %al, %al
je 0x6dfa
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
callq 0x6d47
testb %al, %al
je 0x6dfa
movq 0x20(%r14), %r14
movq 0x20(%rbx), %rbx
jmp 0x6d59
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
jmp 0x6e06
movb $0x1, %al
jmp 0x6e09
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x11f0
testl %eax, %eax
jmp 0x6e06
movb 0x10(%r14), %al
cmpb 0x10(%rbx), %al
jmp 0x6e06
movl 0x10(%r14), %eax
cmpl 0x10(%rbx), %eax
jmp 0x6e06
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
je 0x6dfe
xorl %eax, %eax
jmp 0x6e09
movq 0x18(%r14), %rax
cmpq 0x18(%rbx), %rax
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_init
void
vm_init(struct vm* vm)
{
    assert(vm != NULL);

    vm->capacity = 1024 * 1024;
    vm->heap = calloc(vm->capacity, sizeof(struct value));

    // init the allocation free list
    vm->free = &vm->heap[0];
    for (long i = 0; i < vm->capacity - 1; i++) {
        vm->heap[i].next = &vm->heap[i + 1];
    }
    vm->heap[vm->capacity - 1].next = NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x6e5d
movq %rdi, %rbx
movq $0x100000, (%rdi)       # imm = 0x100000
movl $0x100000, %edi         # imm = 0x100000
movl $0x28, %esi
callq 0x1100
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, %rcx
addq $0x28, %rcx
movl $0xfffff, %edx          # imm = 0xFFFFF
movq %rcx, -0x20(%rcx)
addq $0x28, %rcx
decq %rdx
jne 0x6e43
movq $0x0, 0x27fffe0(%rax)
popq %rbx
retq
leaq 0x2058(%rip), %rdi      # 0x8ebc
leaq 0x205c(%rip), %rsi      # 0x8ec7
leaq 0x205e(%rip), %rcx      # 0x8ed0
movl $0x30, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_free
void
vm_free(struct vm* vm)
{
    assert(vm != NULL);

    vm_gc(vm, NULL);
    free(vm->heap);

    vm->capacity = 0;
    vm->heap = NULL;
    vm->free = NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x6ea5
movq %rdi, %rbx
xorl %esi, %esi
callq 0x6ec4
movq 0x8(%rbx), %rdi
callq 0x11a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
leaq 0x2010(%rip), %rdi      # 0x8ebc
leaq 0x2014(%rip), %rsi      # 0x8ec7
leaq 0x2030(%rip), %rcx      # 0x8eea
movl $0x40, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: gc_mark
static void
gc_mark(struct vm* vm, struct value* root)
{
    if (root == NULL) return;
    if (root->gc_mark == GC_MARKED) return;

    // mark everything reachable from a given root node
    root->gc_mark = GC_MARKED;

    // recursively mark the contents of a lambda
    if (value_is_lambda(root)) {
        gc_mark(vm, root->as.lambda.params);
        gc_mark(vm, root->as.lambda.body);
        gc_mark(vm, root->as.lambda.env);
    }

    // recursively mark pairs / lists
    if (value_is_pair(root)) {
        gc_mark(vm, root->as.pair.car);
        gc_mark(vm, root->as.pair.cdr);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x7042
cmpl $0x1, 0x4(%rbx)
je 0x7042
movl $0x1, 0x4(%rbx)
cmpl $0x9, (%rbx)
jne 0x702e
movq 0x10(%rbx), %rdi
callq 0x6ff8
movq 0x18(%rbx), %rdi
callq 0x6ff8
movq 0x20(%rbx), %rdi
callq 0x6ff8
cmpl $0x7, (%rbx)
jne 0x7042
movq 0x10(%rbx), %rdi
callq 0x6ff8
movq 0x18(%rbx), %rbx
jmp 0x6ffc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_empty_list
struct value*
vm_make_empty_list(struct vm* vm)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_EMPTY_LIST;
    return value;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7057
callq 0x7076
movl $0x1, (%rax)
popq %rcx
retq
leaq 0x1e5e(%rip), %rdi      # 0x8ebc
leaq 0x1e62(%rip), %rsi      # 0x8ec7
leaq 0x1ec0(%rip), %rcx      # 0x8f2c
movl $0x90, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_boolean
struct value*
vm_make_boolean(struct vm* vm, bool boolean)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_BOOLEAN;
    value->as.boolean = boolean;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x70ae
movl %esi, %ebx
callq 0x7076
movl $0x2, (%rax)
movb %bl, 0x10(%rax)
popq %rbx
retq
leaq 0x1e07(%rip), %rdi      # 0x8ebc
leaq 0x1e0b(%rip), %rsi      # 0x8ec7
leaq 0x1e97(%rip), %rcx      # 0x8f5a
movl $0x9a, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_character
struct value*
vm_make_character(struct vm* vm, int character)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_CHARACTER;
    value->as.character = character;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x70e5
movl %esi, %ebx
callq 0x7076
movl $0x3, (%rax)
movl %ebx, 0x10(%rax)
popq %rbx
retq
leaq 0x1dd0(%rip), %rdi      # 0x8ebc
leaq 0x1dd4(%rip), %rsi      # 0x8ec7
leaq 0x1e92(%rip), %rcx      # 0x8f8c
movl $0xa5, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_number
struct value*
vm_make_number(struct vm* vm, long number)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_NUMBER;
    value->as.number = number;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x711e
movq %rsi, %rbx
callq 0x7076
movl $0x4, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1d97(%rip), %rdi      # 0x8ebc
leaq 0x1d9b(%rip), %rsi      # 0x8ec7
leaq 0x1e8b(%rip), %rcx      # 0x8fbe
movl $0xb0, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_string
struct value*
vm_make_string(struct vm* vm, const char* string)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_STRING;
    value->as.string = malloc(strlen(string) + 1);
    strcpy(value->as.string, string);
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7182
movq %rsi, %rbx
callq 0x7076
movq %rax, %r14
movl $0x5, (%rax)
movq %rbx, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11d0
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d33(%rip), %rdi      # 0x8ebc
leaq 0x1d37(%rip), %rsi      # 0x8ec7
leaq 0x1e57(%rip), %rcx      # 0x8fee
movl $0xbb, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_symbol
struct value*
vm_make_symbol(struct vm* vm, const char* symbol)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_SYMBOL;
    value->as.symbol = malloc(strlen(symbol) + 1);
    strcpy(value->as.symbol, symbol);
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x71e6
movq %rsi, %rbx
callq 0x7076
movq %rax, %r14
movl $0x6, (%rax)
movq %rbx, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11d0
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ccf(%rip), %rdi      # 0x8ebc
leaq 0x1cd3(%rip), %rsi      # 0x8ec7
leaq 0x1e2b(%rip), %rcx      # 0x9026
movl $0xc7, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_pair
struct value*
vm_make_pair(struct vm* vm, struct value* car, struct value* cdr)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_PAIR;
    value->as.pair.car = car;
    value->as.pair.cdr = cdr;
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x722f
movq %rdx, %rbx
movq %rsi, %r14
callq 0x7076
movl $0x7, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c86(%rip), %rdi      # 0x8ebc
leaq 0x1c8a(%rip), %rsi      # 0x8ec7
leaq 0x1e1a(%rip), %rcx      # 0x905e
movl $0xd3, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_builtin
struct value*
vm_make_builtin(struct vm* vm, builtin_func builtin)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_BUILTIN;
    value->as.builtin = builtin;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7268
movq %rsi, %rbx
callq 0x7076
movl $0x8, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1c4d(%rip), %rdi      # 0x8ebc
leaq 0x1c51(%rip), %rsi      # 0x8ec7
leaq 0x1e29(%rip), %rcx      # 0x90a6
movl $0xdf, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_lambda
struct value*
vm_make_lambda(struct vm* vm, struct value* params, struct value* body, struct value* env)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_LAMBDA;
    value->as.lambda.params = params;
    value->as.lambda.body = body;
    value->as.lambda.env = env;
    return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x72b7
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x7076
movl $0x9, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1bfe(%rip), %rdi      # 0x8ebc
leaq 0x1c02(%rip), %rsi      # 0x8ec7
leaq 0x1e13(%rip), %rcx      # 0x90df
movl $0xea, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_input_port
struct value*
vm_make_input_port(struct vm* vm, FILE* port)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_INPUT_PORT;
    value->as.port = port;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x72f0
movq %rsi, %rbx
callq 0x7076
movl $0xa, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1bc5(%rip), %rdi      # 0x8ebc
leaq 0x1bc9(%rip), %rsi      # 0x8ec7
leaq 0x1e34(%rip), %rcx      # 0x9139
movl $0xf7, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_output_port
struct value*
vm_make_output_port(struct vm* vm, FILE* port)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_OUTPUT_PORT;
    value->as.port = port;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7329
movq %rsi, %rbx
callq 0x7076
movl $0xb, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1b8c(%rip), %rdi      # 0x8ebc
leaq 0x1b90(%rip), %rsi      # 0x8ec7
leaq 0x1e31(%rip), %rcx      # 0x916f
movl $0x102, %edx            # imm = 0x102
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_window
struct value*
vm_make_window(struct vm* vm, const char* title, long width, long height)
{
    assert(vm != NULL);

    SDL_Window* window = SDL_CreateWindow(
        title,
        SDL_WINDOWPOS_UNDEFINED,
        SDL_WINDOWPOS_UNDEFINED,
        width,
        height,
        0);
    if (window == NULL) {
        fprintf(stderr, "failed to create SDL2 window: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        fprintf(stderr, "failed to create SDL2 renderer: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    struct value* value = next_available_value(vm);
    value->type = VALUE_WINDOW;
    value->as.window.window = window;
    value->as.window.renderer = renderer;
    return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x73ae
movq %rcx, %r8
movq %rdx, %rcx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
xorl %r9d, %r9d
callq 0x1060
testq %rax, %rax
je 0x73cd
movq %rax, %r14
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x1040
testq %rax, %rax
je 0x73d2
movq %rax, %r15
movq %rbx, %rdi
callq 0x7076
movl $0xc, (%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b07(%rip), %rdi      # 0x8ebc
leaq 0x1b0b(%rip), %rsi      # 0x8ec7
leaq 0x1de3(%rip), %rcx      # 0x91a6
movl $0x10d, %edx            # imm = 0x10D
callq 0x10f0
callq 0x3065
callq 0x3039
// File: /workspace/github_c_makefile_star2_O1/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_event
struct value*
vm_make_event(struct vm* vm, SDL_Event* event)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_EVENT;
    value->as.event = event;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x73f1
movq %rsi, %rbx
callq 0x7076
movl $0xd, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1ac4(%rip), %rdi      # 0x8ebc
leaq 0x1ac8(%rip), %rsi      # 0x8ec7
leaq 0x1e2a(%rip), %rcx      # 0x9230
movl $0x12b, %edx            # imm = 0x12B
callq 0x10f0