LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x7275
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x72e7
movq -0x18(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x72c5
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
callq 0x5e70
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x7300
movq %rax, -0x8(%rbp)
jmp 0x72e7
movq 0x6d14(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x370c(%rip), %rsi      # 0xa9e2
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/mce.c
// Function: eval_sequence
static struct value*
eval_sequence(struct vm* vm, struct value* exp, struct value* env)
{
    if (is_last_exp(exp)) {
        return mce_eval(vm, first_exp(exp), env);
    } else {
        mce_eval(vm, first_exp(exp), env);
        return eval_sequence(vm, rest_exps(exp), env);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6620
cmpl $0x1, (%rax)
jne 0x7349
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6710
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x6760
movq %rax, -0x8(%rbp)
jmp 0x738f
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6710
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x6760
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6620
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x7300
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x74d0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $-0x1, %eax
je 0x73e0
jmp 0x73c9
movl -0x20(%rbp), %eax
subl $0x6e, %eax
je 0x7442
jmp 0x73d3
movl -0x20(%rbp), %eax
subl $0x73, %eax
je 0x7402
jmp 0x747f
movq 0x6bf9(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x36c1(%rip), %rsi      # 0xaab2
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x18(%rbp), %rdi
callq 0x74f0
cmpl $0x70, %eax
jne 0x7440
movq -0x18(%rbp), %rdi
leaq 0x3a3c(%rip), %rsi      # 0xae57
callq 0x7520
movq -0x18(%rbp), %rdi
callq 0x7590
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x8f00
movq %rax, -0x8(%rbp)
jmp 0x74c6
jmp 0x747f
movq -0x18(%rbp), %rdi
callq 0x74f0
cmpl $0x65, %eax
jne 0x747d
movq -0x18(%rbp), %rdi
leaq 0x3a04(%rip), %rsi      # 0xae5f
callq 0x7520
movq -0x18(%rbp), %rdi
callq 0x7590
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x8f00
movq %rax, -0x8(%rbp)
jmp 0x74c6
jmp 0x747f
cmpl $0x21, -0x1c(%rbp)
jl 0x748b
cmpl $0x7e, -0x1c(%rbp)
jle 0x74ad
movq 0x6b4e(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x363c(%rip), %rsi      # 0xaad8
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x18(%rbp), %rdi
callq 0x7590
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8f00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7586
movq -0x8(%rbp), %rdi
callq 0x74d0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x7578
movq 0x6a83(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x354b(%rip), %rsi      # 0xaab2
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7530
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x10e0
movq $0x0, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74d0
movl %eax, -0x9c(%rbp)
cmpl $-0x1, %eax
je 0x7690
movl -0x9c(%rbp), %eax
movsbl %al, %edi
callq 0x76e0
testb $0x1, %al
jne 0x7639
jmp 0x7690
cmpq $0x7e, -0x98(%rbp)
jl 0x766a
movq 0x6996(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x34ad(%rip), %rsi      # 0xab01
movl $0x80, %edx
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movl -0x9c(%rbp), %eax
movb %al, %cl
movq -0x98(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movb %cl, -0x90(%rbp,%rax)
jmp 0x7611
movq -0x10(%rbp), %rdi
movl -0x9c(%rbp), %esi
callq 0x7710
movq -0x10(%rbp), %rdi
callq 0x7590
leaq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x11e0
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x8f70
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq $0x0, -0x118(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74d0
movq -0x10(%rbp), %rdi
callq 0x74d0
movl %eax, -0x11c(%rbp)
cmpl $-0x1, %eax
je 0x77f3
cmpl $0x22, -0x11c(%rbp)
jne 0x7799
jmp 0x77f3
cmpq $0xfe, -0x118(%rbp)
jl 0x77cd
movq 0x6833(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x337d(%rip), %rsi      # 0xab34
movl $0x100, %edx            # imm = 0x100
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movl -0x11c(%rbp), %eax
movb %al, %cl
movq -0x118(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x118(%rbp)
movb %cl, -0x110(%rbp,%rax)
jmp 0x777a
cmpl $-0x1, -0x11c(%rbp)
jne 0x781e
movq 0x67dd(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x3359(%rip), %rsi      # 0xab66
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x10(%rbp), %rdi
callq 0x7590
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x8fe0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7c10
movq -0x18(%rbp), %rdi
callq 0x74f0
cmpl $0x29, %eax
jne 0x7b32
movq -0x18(%rbp), %rdi
callq 0x74d0
movq -0x10(%rbp), %rdi
callq 0x8dc0
movq %rax, -0x8(%rbp)
jmp 0x7bfc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7c10
movq -0x18(%rbp), %rdi
callq 0x74f0
cmpl $0x2e, %eax
jne 0x7bd6
movq -0x18(%rbp), %rdi
callq 0x74d0
movq -0x18(%rbp), %rdi
callq 0x7590
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c90
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7c10
movq -0x18(%rbp), %rdi
callq 0x74f0
cmpl $0x29, %eax
je 0x7bb6
movq 0x6445(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x302e(%rip), %rsi      # 0xabd3
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x18(%rbp), %rdi
callq 0x74d0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9100
movq %rax, -0x8(%rbp)
jmp 0x7bfc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7af0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9100
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x74d0
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x7c83
movl -0xc(%rbp), %eax
movsbl %al, %edi
callq 0x8130
testb $0x1, %al
jne 0x7c3e
jmp 0x7c40
jmp 0x7c1c
cmpl $0x3b, -0xc(%rbp)
jne 0x7c77
jmp 0x7c48
movq -0x8(%rbp), %rdi
callq 0x74d0
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0xd(%rbp)
je 0x7c6a
cmpl $0xa, -0xc(%rbp)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x7c73
jmp 0x7c75
jmp 0x7c48
jmp 0x7c1c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7710
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/value.c
// Function: value_type_name
const char*
value_type_name(int type)
{
    switch (type) {
        case VALUE_EMPTY_LIST: return "Empty List";
        case VALUE_BOOLEAN: return "Boolean";
        case VALUE_CHARACTER: return "Character";
        case VALUE_NUMBER: return "Number";
        case VALUE_STRING: return "String";
        case VALUE_SYMBOL: return "Symbol";
        case VALUE_PAIR: return "Pair";
        case VALUE_BUILTIN: return "Builtin";
        case VALUE_LAMBDA: return "Lambda";
        case VALUE_INPUT_PORT: return "Input Port";
        case VALUE_OUTPUT_PORT: return "Output Port";
        case VALUE_WINDOW: return "Window";
        case VALUE_EVENT: return "Event";
        case VALUE_EOF: return "EOF";
        default: return "Undefined";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xd, %eax
ja 0x87c4
movq -0x18(%rbp), %rax
leaq 0x264a(%rip), %rcx      # 0xad40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x27e5(%rip), %rax      # 0xaeeb
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27e0(%rip), %rax      # 0xaef6
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27d8(%rip), %rax      # 0xaefe
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27d2(%rip), %rax      # 0xaf08
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27c9(%rip), %rax      # 0xaf0f
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27c0(%rip), %rax      # 0xaf16
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27ba(%rip), %rax      # 0xaf1d
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27b2(%rip), %rax      # 0xaf22
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27ad(%rip), %rax      # 0xaf2a
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27a7(%rip), %rax      # 0xaf31
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27a5(%rip), %rax      # 0xaf3c
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x27a4(%rip), %rax      # 0xaf48
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x279e(%rip), %rax      # 0xaf4f
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x2797(%rip), %rax      # 0xaf55
movq %rax, -0x8(%rbp)
jmp 0x87cf
leaq 0x278e(%rip), %rax      # 0xaf59
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8a95
jmp 0x8ab4
leaq 0x24ec(%rip), %rdi      # 0xaf88
leaq 0x24f0(%rip), %rsi      # 0xaf93
movl $0x30, %edx
leaq 0x24ed(%rip), %rcx      # 0xaf9c
callq 0x1100
movq -0x8(%rbp), %rax
movq $0x100000, (%rax)       # imm = 0x100000
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x28, %esi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x8b40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq $0x1, %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x28, -0x10(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8af3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8b85
jmp 0x8ba4
leaq 0x23fc(%rip), %rdi      # 0xaf88
leaq 0x2400(%rip), %rsi      # 0xaf93
movl $0x40, %edx
leaq 0x2417(%rip), %rcx      # 0xafb6
callq 0x1100
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8bf0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1190
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8c69
jmp 0x8ce7
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8c75
jmp 0x8ce7
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x8cbc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x8c50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x8c50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x8c50
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x8ce7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x8c50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x8c50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/vm.c
// Function: gc_sweep
static void
gc_sweep(struct vm* vm)
{
    // sweep anything that isn't marked
    for (long i = 0; i < vm->capacity; i++) {
        if (vm->heap[i].gc_mark == GC_UNMARKED) {
            // free the value's dynamic contents
            value_free(&vm->heap[i]);
            vm->heap[i].type = VALUE_UNDEFINED;

            // put freed values back into the free list
            vm->heap[i].next = vm->free;
            vm->free = &vm->heap[i];
        }

        // every value goes back to unmarked after GC
        vm->heap[i].gc_mark = GC_UNMARKED;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x8db2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jne 0x8d8a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
imulq $0x28, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x9560
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x28, -0x10(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
imulq $0x28, -0x10(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8d04
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8dd5
jmp 0x8df4
leaq 0x21ac(%rip), %rdi      # 0xaf88
leaq 0x21b0(%rip), %rsi      # 0xaf93
movl $0x90, %edx
leaq 0x2209(%rip), %rcx      # 0xaff8
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/vm.c
// Function: next_available_value
static struct value*
next_available_value(struct vm* vm)
{
    struct value* value = vm->free;
    if (value == NULL) {
        fprintf(stderr, "vm: out of memory\n");
        exit(EXIT_FAILURE);
    }

    // pull the free value out of the free list
    vm->free = value->next;
    value->next = NULL;
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e61
movq 0x519a(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
leaq 0x2537(%rip), %rsi      # 0xb387
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8ead
jmp 0x8ecc
leaq 0x20d4(%rip), %rdi      # 0xaf88
leaq 0x20d8(%rip), %rsi      # 0xaf93
movl $0x9a, %edx
leaq 0x215f(%rip), %rcx      # 0xb026
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8f18
jmp 0x8f37
leaq 0x2069(%rip), %rdi      # 0xaf88
leaq 0x206d(%rip), %rsi      # 0xaf93
movl $0xa5, %edx
leaq 0x2126(%rip), %rcx      # 0xb058
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8f89
jmp 0x8fa8
leaq 0x1ff8(%rip), %rdi      # 0xaf88
leaq 0x1ffc(%rip), %rsi      # 0xaf93
movl $0xb0, %edx
leaq 0x20e7(%rip), %rcx      # 0xb08a
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8ff9
jmp 0x9018
leaq 0x1f88(%rip), %rdi      # 0xaf88
leaq 0x1f8c(%rip), %rsi      # 0xaf93
movl $0xbb, %edx
leaq 0x20a7(%rip), %rcx      # 0xb0ba
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x11c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1150
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9089
jmp 0x90a8
leaq 0x1ef8(%rip), %rdi      # 0xaf88
leaq 0x1efc(%rip), %rsi      # 0xaf93
movl $0xc7, %edx
leaq 0x204f(%rip), %rcx      # 0xb0f2
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x11c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1150
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x911d
jmp 0x913c
leaq 0x1e64(%rip), %rdi      # 0xaf88
leaq 0x1e68(%rip), %rsi      # 0xaf93
movl $0xd3, %edx
leaq 0x1ff3(%rip), %rcx      # 0xb12a
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x7, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9199
jmp 0x91b8
leaq 0x1de8(%rip), %rdi      # 0xaf88
leaq 0x1dec(%rip), %rsi      # 0xaf93
movl $0xdf, %edx
leaq 0x1fbf(%rip), %rcx      # 0xb172
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9211
jmp 0x9230
leaq 0x1d70(%rip), %rdi      # 0xaf88
leaq 0x1d74(%rip), %rsi      # 0xaf93
movl $0xea, %edx
leaq 0x1f80(%rip), %rcx      # 0xb1ab
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x9, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9299
jmp 0x92b8
leaq 0x1ce8(%rip), %rdi      # 0xaf88
leaq 0x1cec(%rip), %rsi      # 0xaf93
movl $0xf7, %edx
leaq 0x1f52(%rip), %rcx      # 0xb205
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xa, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9309
jmp 0x9328
leaq 0x1c78(%rip), %rdi      # 0xaf88
leaq 0x1c7c(%rip), %rsi      # 0xaf93
movl $0x102, %edx            # imm = 0x102
leaq 0x1f18(%rip), %rcx      # 0xb23b
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xb, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9381
jmp 0x93a0
leaq 0x1c00(%rip), %rdi      # 0xaf88
leaq 0x1c04(%rip), %rsi      # 0xaf93
movl $0x10d, %edx            # imm = 0x10D
leaq 0x1ed7(%rip), %rcx      # 0xb272
callq 0x1100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %eax, %r8d
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
xorl %r9d, %r9d
movl %edx, %esi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x93fd
movq 0x4c0e(%rip), %rax      # 0xdfe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x1120
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x1eca(%rip), %rsi      # 0xb2b6
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x28(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x1040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x944d
movq 0x4bbe(%rip), %rax      # 0xdfe0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
callq 0x1120
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x1e9c(%rip), %rsi      # 0xb2d8
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0xc, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x94a9
jmp 0x94c8
leaq 0x1ad8(%rip), %rdi      # 0xaf88
leaq 0x1adc(%rip), %rsi      # 0xaf93
movl $0x12b, %edx            # imm = 0x12B
leaq 0x1e39(%rip), %rcx      # 0xb2fc
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xd, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_eof
struct value*
vm_make_eof(struct vm* vm)
{
    assert(vm != NULL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9515
jmp 0x9534
leaq 0x1a6c(%rip), %rdi      # 0xaf88
leaq 0x1a70(%rip), %rsi      # 0xaf93
movl $0x136, %edx            # imm = 0x136
leaq 0x1e03(%rip), %rcx      # 0xb332
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x8e20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xe, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/vm.c
// Function: value_free
static void
value_free(struct value* value)
{
    assert(value != NULL);

    switch (value->type) {
        case VALUE_STRING:
            free(value->as.string);
            break;
        case VALUE_SYMBOL:
            free(value->as.symbol);
            break;
        case VALUE_INPUT_PORT:
            if (value->as.port == stdin) break;
            fclose(value->as.port);
            break;
        case VALUE_OUTPUT_PORT:
            if (value->as.port == stdout) break;
            fclose(value->as.port);
            break;
        case VALUE_WINDOW:
            SDL_DestroyRenderer(value->as.window.renderer);
            SDL_DestroyWindow(value->as.window.window);
            break;
        case VALUE_EVENT:
            free(value->as.event);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9575
jmp 0x9594
leaq 0x1ddd(%rip), %rdi      # 0xb359
leaq 0x1a10(%rip), %rsi      # 0xaf93
movl $0x10, %edx
leaq 0x1dd8(%rip), %rcx      # 0xb367
callq 0x1100
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x8, %eax
ja 0x9656
movq -0x10(%rbp), %rax
leaq 0x19ad(%rip), %rcx      # 0xaf64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1190
jmp 0x9658
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1190
jmp 0x9658
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x49e8(%rip), %rcx      # 0xdfd8
cmpq (%rcx), %rax
jne 0x95f7
jmp 0x9658
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1170
jmp 0x9658
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x49ab(%rip), %rcx      # 0xdfc0
cmpq (%rcx), %rax
jne 0x961c
jmp 0x9658
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1170
jmp 0x9658
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
jmp 0x9658
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1190
jmp 0x9658
jmp 0x9658
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_threads.c
// Function: testThread
void *
testThread(void * args)
{
  int j ;
  int id = *(int*)args ;
  vl_tic() ;
  for (j = 0 ; j < 10 ; ++j) {
    printf("Thread %5d: %d\n",
      id, vl_rand_int31(vl_get_rand())) ;
    fflush(stdout) ;
  }
  printf("Thread %5d: elapsed time: %.2f s\n", id, vl_toc()) ;
  return NULL ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
callq 0x1030
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0x123d
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x10b0
movq %rax, %rdi
callq 0x1270
movl 0x4(%rsp), %esi
movl %eax, %edx
leaq 0xdea(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
movq 0x2db8(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11f1
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
callq 0x1050
movl (%rsp), %esi
leaq 0xdc1(%rip), %rdi       # 0x2014
movb $0x1, %al
callq 0x1070
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_threads.c
// Function: main
int
main(int argc VL_UNUSED, char** argv VL_UNUSED)
{
#ifndef VL_DISABLE_THREADS
#if defined(VL_THREADS_POSIX)
  vl_uindex i ;
  pthread_t threads [5] ;
  int threadIds [5] ;
  for (i = 0 ; i < sizeof(threads) / sizeof(threads[0]) ; ++i) {
    threadIds [i] = i ;
    pthread_create (threads + i, NULL, testThread, threadIds + i) ;
  }
  for (i = 0 ; i < sizeof(threads) / sizeof(threads[0]) ; ++i) {
    pthread_join (threads[i], NULL) ;
  }
#elif defined(VL_THREADS_WIN)
  int i ;
  DWORD threadIds [5] ;
  HANDLE threadHandles [5] ;
  for (i = 0 ; i < sizeof(threadHandles) / sizeof(threadHandles[0]) ; ++i) {
    threadHandles [i] = CreateThread (
      NULL, 0,
      testThread, threadIds + i,
      0, threadIds + i) ;
  }
  for (i = 0 ; i < sizeof(threadHandles) / sizeof(threadHandles[0]) ; ++i) {
    WaitForSingleObject (threadHandles[i], INFINITE);
  }
#endif
/* VL_DISABLE_THREADS */
#else
  printf("VLFeat was compiled without threading support\n") ;
#endif
  {
    char * string = vl_configuration_to_string_copy() ;
    printf("%s", string) ;
    vl_free(string) ;
  }
  return 0 ;
}

// Assembly:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
movl %edi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
cmpq $0x5, 0x60(%rsp)
jae 0x1308
movq 0x60(%rsp), %rax
movl %eax, %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x10(%rsp,%rax,4)
leaq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq 0x10(%rsp), %rcx
movq 0x60(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x123(%rip), %rdx      # 0x11d0
callq 0x10a0
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x12ae
movq $0x0, 0x60(%rsp)
cmpq $0x5, 0x60(%rsp)
jae 0x133c
movq 0x60(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x1311
callq 0x1040
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0xce4(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1070
movq 0x8(%rsp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Keith-S-Thompson[P]kst-time-utils/jd.c
// Function: main
int main(int argc, char **argv) {
    int modified = 0; /* use Modified Julian Date */
    for (int i = 1; i < argc; i ++) {
        if (strcmp(argv[i], "-m") == 0) {
            modified = 1;
        }
        else {
            usage_error(argv[0]);
        }
    }
    struct timeval tp;
    if (gettimeofday(&tp, NULL) != 0) {
        perror("gettimeofday");
        exit(EXIT_FAILURE);
    }
    const long double unix_time = tp.tv_sec + tp.tv_usec/1000000.0;
    const long double jd = unix_time / 86400.0 + (modified ? 40587.0 : 2440587.5);
    printf("%.9Lf\n", jd);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11eb
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xe69(%rip), %rsi       # 0x2028
callq 0x1050
cmpl $0x0, %eax
jne 0x11d2
movl $0x1, -0x14(%rbp)
jmp 0x11de
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1280
jmp 0x11e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11a4
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
cmpl $0x0, %eax
je 0x1213
leaq 0xe27(%rip), %rdi       # 0x202b
callq 0x1060
movl $0x1, %edi
callq 0x1070
cvtsi2sdq -0x28(%rbp), %xmm0
cvtsi2sdq -0x20(%rbp), %xmm1
movsd 0xde1(%rip), %xmm2      # 0x2008
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
fldl -0x58(%rbp)
fstpt -0x40(%rbp)
fldt -0x40(%rbp)
flds 0xdcd(%rip)             # 0x2010
fdivrp %st, %st(1)
movl -0x14(%rbp), %eax
testl %eax, %eax
setne %al
movzbl %al, %eax
movl %eax, %ecx
leaq 0xdbf(%rip), %rax       # 0x2018
fldl (%rax,%rcx,8)
faddp %st, %st(1)
fstpt -0x50(%rbp)
fldt -0x50(%rbp)
movq %rsp, %rax
fstpt (%rax)
leaq 0xdc8(%rip), %rdi       # 0x2038
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Keith-S-Thompson[P]kst-time-utils/jd.c
// Function: usage_error
static void usage_error(char *program_name) {
    printf("Usage: %s [-m]\n", program_name);
    printf("Without options, print Julian Date\n");
    printf("With \"-m\", print Modified Julian Date\n");
    printf("http://en.wikipedia.org/wiki/Julian_day#Alternatives\n");
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xda8(%rip), %rdi       # 0x203f
movb $0x0, %al
callq 0x1030
leaq 0xdaa(%rip), %rdi       # 0x204f
movb $0x0, %al
callq 0x1030
leaq 0xdc0(%rip), %rdi       # 0x2073
movb $0x0, %al
callq 0x1030
leaq 0xdd9(%rip), %rdi       # 0x209a
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/collect64.c
// Function: main
int
main(void)
{
    int i;

    shmem_init();
    npes = shmem_n_pes();
    me = shmem_my_pe();

    for (i = 0; i < DST_SIZE; i++) {
        dst[i] = -1;
    }

    for (i = 0; i < SHMEM_COLLECT_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_barrier_all();

    shmem_collect64(dst, src, me + 1, 0, 0, npes, pSync);

    shmem_barrier_all();

    show_dst("AFTER");

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1090
callq 0x1040
movl %eax, 0x2ed4(%rip)      # 0x4090
callq 0x1070
movl %eax, 0x2ecd(%rip)      # 0x4094
movl $0x0, 0x10(%rsp)
cmpl $0x14, 0x10(%rsp)
jge 0x11f7
movslq 0x10(%rsp), %rcx
leaq 0x2ebe(%rip), %rax      # 0x40a0
movq $-0x1, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11cf
movl $0x0, 0x10(%rsp)
cmpl $0x3, 0x10(%rsp)
jge 0x1227
movslq 0x10(%rsp), %rcx
leaq 0x2f2e(%rip), %rax      # 0x4140
movq $-0x1, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11ff
callq 0x1080
movl 0x2e62(%rip), %eax      # 0x4094
addl $0x1, %eax
movslq %eax, %rdx
movl 0x2e51(%rip), %r9d      # 0x4090
leaq 0x2e5a(%rip), %rdi      # 0x40a0
leaq 0x2e13(%rip), %rsi      # 0x4060
xorl %r8d, %r8d
leaq 0x2ee9(%rip), %rax      # 0x4140
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x1050
callq 0x1080
leaq 0xd95(%rip), %rdi       # 0x2004
callq 0x1280
callq 0x1060
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/collect64.c
// Function: show_dst
static void
show_dst(char *tag)
{
    int i;
    printf("%8s: dst[%d/%d] =", tag, me, npes);
    for (i = 0; i < DST_SIZE; i += 1) {
        printf(" %ld", dst[i]);
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movl 0x2e00(%rip), %edx      # 0x4094
movl 0x2df6(%rip), %ecx      # 0x4090
leaq 0xd69(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1030
movl $0x0, 0xc(%rsp)
cmpl $0x14, 0xc(%rsp)
jge 0x12e2
movslq 0xc(%rsp), %rcx
leaq 0x2ddd(%rip), %rax      # 0x40a0
movq (%rax,%rcx,8), %rsi
leaq 0xd4e(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12b0
leaq 0xd38(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1030
addq $0x18, %rsp
retq