LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/scheme.c
// Function: file_load
void file_load(vm_t *vm, env_t *env, const char *path) {
#if DEBUG
    fprintf(stdout, "DEBUG: Loading script %s!\n", path);
#endif  // DEBUG
    char *source = file_read(path);
    if (source == NULL) {
        fprintf(stderr, "ERROR: Could not find script %s!\n", path);
        exit(66);  // EX_NOINPUT
    }
    value_t val = read_source(vm, source);
    eval(vm, env, val);

    free(source);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5f00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5ec1
movq 0x8157(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x491a(%rip), %rsi      # 0xa7ca
movb $0x0, %al
callq 0x1120
movl $0x42, %edi
callq 0x1190
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4da0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
callq 0x85b0
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/scheme.c
// Function: file_read
static char *file_read(const char *filename) {
    FILE *f = fopen(filename, "rb");
    if (f == NULL) return NULL;

    fseek(f, 0, SEEK_END);
    size_t fsize = ftell(f);
    rewind(f);

    char *buffer = (char *) malloc(fsize + 1);
    if (buffer == NULL) {
        fprintf(stderr, "ERROR: Could not read file %s (buffer alloc fail)!\n",
                filename);
        exit(74);  // EX_IOERR
    }

    size_t read = fread(buffer, sizeof(char), fsize, f);
    if (read < fsize) {
        fprintf(stderr, "ERROR: Could not read file %s (whole not read)!\n",
                filename);
        exit(74);  // EX_IOERR
    }

    buffer[read] = '\0';

    fclose(f);
    return buffer;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x49cc(%rip), %rsi      # 0xa8e1
callq 0x1180
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x5f35
movq $0x0, 0x30(%rsp)
jmp 0x6016
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1160
movq 0x20(%rsp), %rdi
callq 0x1130
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10b0
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
callq 0x1150
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5fa3
movq 0x8075(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x4952(%rip), %rsi      # 0xa8e4
movb $0x0, %al
callq 0x1120
movl $0x4a, %edi
callq 0x1190
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0x1060
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x5ff4
movq 0x8024(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
leaq 0x4935(%rip), %rsi      # 0xa918
movb $0x0, %al
callq 0x1120
movl $0x4a, %edi
callq 0x1190
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rdi
callq 0x10a0
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/scheme.c
// Function: file_run
void file_run(const char *filename) {
    char *source = file_read(filename);
    if (source == NULL) {
        fprintf(stderr, "ERROR: Could not find file %s!\n", filename);
        exit(66);  // EX_NOINPUT
    }

    vm_t *vm = vm_init();
    env_t *env = scm_env_default(vm);

    value_t val = read_source(vm, source);
    eval(vm, env, val);

    vm_free(vm);
    free(source);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5f00
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x6067
movq 0x7fb1(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x4796(%rip), %rsi      # 0xa7ec
movb $0x0, %al
callq 0x1120
movl $0x42, %edi
callq 0x1190
callq 0x6300
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1350
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4da0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x85b0
movq 0x10(%rsp), %rdi
callq 0x7650
movq 0x18(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/scheme.c
// Function: repl_run
void repl_run() {
    vm_t *vm = vm_init();
    env_t *env = scm_env_default(vm);

    fprintf(stdout, " _  __     \n"
                    "(_ /  |\\/|\n"
                    "__)\\__|  |\n"
                    "  v%s  \n\n"
                    "Welcome to the REPL!\n"
                    "Ctrl+D to exit!\n\n",
            SCM_VERSION_STRING);

    char line[1024];

    while (true) {
        fprintf(stdout, ">> ");

        if (!fgets(line, 1024, stdin)) {
            fprintf(stdout, "\n");
            break;
        }

        value_t val = read_source(vm, line);
        value_t result = eval(vm, env, val);

        if (!IS_VOID(result)) {
            display(stdout, result);
            fprintf(stdout, "\n");
        }
    }

    fprintf(stdout, "Quitting!\n");
    vm_free(vm);
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
callq 0x6300
movq %rax, 0x420(%rsp)
movq 0x420(%rsp), %rdi
callq 0x1350
movq %rax, 0x418(%rsp)
movq 0x7ee0(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x4712(%rip), %rsi      # 0xa80c
leaq 0x475d(%rip), %rdx      # 0xa85e
movb $0x0, %al
callq 0x1120
movq 0x7ec1(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x474b(%rip), %rsi      # 0xa864
movb $0x0, %al
callq 0x1120
leaq 0x10(%rsp), %rdi
movq 0x7eac(%rip), %rax      # 0xdfd8
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1100
cmpq $0x0, %rax
jne 0x6159
movq 0x7e8a(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x470c(%rip), %rsi      # 0xa85c
movb $0x0, %al
callq 0x1120
jmp 0x61ce
movq 0x420(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4da0
movq %rax, 0x8(%rsp)
movq 0x420(%rsp), %rdi
movq 0x418(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x85b0
movq %rax, (%rsp)
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
cmpq %rax, (%rsp)
je 0x61c9
movq 0x7e2b(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
movq (%rsp), %rsi
callq 0x9600
movq 0x7e18(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x469a(%rip), %rsi      # 0xa85c
movb $0x0, %al
callq 0x1120
jmp 0x6108
movq 0x7dfb(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x4689(%rip), %rsi      # 0xa868
movb $0x0, %al
callq 0x1120
movq 0x420(%rsp), %rdi
callq 0x7650
addq $0x428, %rsp            # imm = 0x428
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/scheme.c
// Function: main
int main(int argc, char *argv[]) {
    // TODO: Add support for cmdline arguments for scripts
    if (argc == 2) {
        if (strcmp(argv[1], "--help") == 0) {
            fprintf(stdout, "Usage: scheme.out [file]\n");
            fprintf(stdout, "  --help    : Show this help\n");
            fprintf(stdout, "  --version : Show version\n");
            return 0;
        } else if (strcmp(argv[1], "--version") == 0) {
            fprintf(stdout, "SCM v%s\n", SCM_VERSION_STRING);
            return 0;
        }
    }

    if (argc == 1) {
        repl_run();
    } else {
        file_run(argv[1]);
    }

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jne 0x62d3
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x4643(%rip), %rsi      # 0xa873
callq 0x1110
cmpl $0x0, %eax
jne 0x628c
movq 0x7d8f(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x462f(%rip), %rsi      # 0xa87a
movb $0x0, %al
callq 0x1120
movq 0x7d77(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x4631(%rip), %rsi      # 0xa894
movb $0x0, %al
callq 0x1120
movq 0x7d5f(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x4637(%rip), %rsi      # 0xa8b2
movb $0x0, %al
callq 0x1120
movl $0x0, 0x14(%rsp)
jmp 0x62f7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x4632(%rip), %rsi      # 0xa8ce
callq 0x1110
cmpl $0x0, %eax
jne 0x62cf
movq 0x7d23(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x4621(%rip), %rsi      # 0xa8d8
leaq 0x45a0(%rip), %rdx      # 0xa85e
movb $0x0, %al
callq 0x1120
movl $0x0, 0x14(%rsp)
jmp 0x62f7
jmp 0x62d1
jmp 0x62d3
cmpl $0x1, 0x10(%rsp)
jne 0x62e1
callq 0x60c0
jmp 0x62ef
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x6020
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/scheme.c
// Function: vm_init
static vm_t *vm_init() {
    scm_config_t config;
    scm_config_default(&config);

    config.error_fn = error_report;
    config.load_fn = file_load;

    // 64 MB
    config.heap_size_initial = 1024 * 1024 * 64;

    vm_t *vm = vm_new(&config);

    return vm;
}

// Assembly:
subq $0x38, %rsp
leaq 0x8(%rsp), %rdi
callq 0x74a0
leaq 0x3b(%rip), %rax        # 0x6350
movq %rax, 0x10(%rsp)
leaq -0x4b1(%rip), %rax      # 0x5e70
movq %rax, 0x18(%rsp)
movq $0x4000000, 0x20(%rsp)  # imm = 0x4000000
leaq 0x8(%rsp), %rdi
callq 0x7550
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/scheme.c
// Function: error_report
static void error_report(vm_t *vm, int line, int column, const char *message) {
    if (line > 0) {
        fprintf(stderr, "ERROR @ [%d:%d]: %s\n", line, column, message);
    } else if (line == -1) {
        fprintf(stderr, "ERROR @ runtime: %s\n", message);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x6392
movq 0x7c85(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movq (%rsp), %r8
leaq 0x45c0(%rip), %rsi      # 0xa949
movb $0x0, %al
callq 0x1120
jmp 0x63b7
cmpl $-0x1, 0xc(%rsp)
jne 0x63b5
movq 0x7c58(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x45b0(%rip), %rsi      # 0xa95e
movb $0x0, %al
callq 0x1120
jmp 0x63b7
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: hash_ptr
static uint32_t hash_ptr(ptrvalue_t *ptr) {
    if (ptr->type == T_STRING) {
        // all strings are hashed when created!
        return ((string_t *) ptr)->hash;
    } else if (ptr->type == T_SYMBOL) {
        symbol_t *sym = (symbol_t *) ptr;
        return hash_string_like(sym->name, sym->len);
    } else {
        return 0;  // TODO: log error - mutable
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x6681
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x66b6
movq 0x8(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x66ae
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x20, %rdi
movq (%rsp), %rax
movl 0x10(%rax), %esi
callq 0x7340
movl %eax, 0x14(%rsp)
jmp 0x66b6
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: hash_number
static inline uint32_t hash_number(uint64_t num) {
    // TODO: is this really ideal for a double?
    const uint8_t *ptr = (const uint8_t *) &num;
    uint32_t hash = HASH_SEED;

    for (int i = 0; i < 8; i++) {  // I really hope the compiler can inline this
        hash ^= *ptr++;
        hash *= HASH_PRIME;
    }

    return hash;
}

// Assembly:
movq %rdi, -0x8(%rsp)
leaq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movl $0x811c9dc5, -0x14(%rsp) # imm = 0x811C9DC5
movl $0x0, -0x18(%rsp)
cmpl $0x8, -0x18(%rsp)
jge 0x671b
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movzbl (%rax), %eax
xorl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
imull $0x1000193, -0x14(%rsp), %eax # imm = 0x1000193
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x66df
movl -0x14(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: cons_new
cons_t *cons_new(vm_t *vm) {
    cons_t *cons = (cons_t *) vm_realloc(vm, NULL, 0, sizeof(cons_t));

    ptr_init(vm, &cons->p, T_CONS);

    cons->car = NIL_VAL;
    cons->cdr = NIL_VAL;

    return cons;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x76b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x6790
movq 0x8(%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: ptr_init
static void ptr_init(vm_t *vm, ptrvalue_t *ptr, ptrvalue_type_t type) {
    ptr->type = type;
    ptr->gcmark = false;
    ptr->next = vm->head;
    vm->head = ptr;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: string_new
string_t *string_new(vm_t *vm, const char *text, size_t len) {
    string_t *str = (string_t *) vm_realloc(
        vm, NULL, 0, sizeof(string_t) + sizeof(char) * (len + 1));

    ptr_init(vm, &str->p, T_STRING);

    str->len = (uint32_t) len;
    str->value[len] = '\0';

    if (len > 0 && text != NULL) {
        memcpy(str->value, text, len);
    }

    hash_string(str);

    return str;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rcx
addq $0x1, %rcx
shlq $0x0, %rcx
addq $0x18, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x76b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x6790
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, 0x18(%rax,%rcx)
cmpq $0x0, 0x10(%rsp)
jbe 0x6874
cmpq $0x0, 0x18(%rsp)
je 0x6874
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1140
movq 0x8(%rsp), %rdi
callq 0x6890
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: symbol_new
symbol_t *symbol_new(vm_t *vm, const char *name, size_t len) {
    if (len == 0 || name == NULL) {
        error_runtime(vm, "NULL or 0-length symbols are not allowed!");
        return NULL;
    }

    symbol_t *sym = (symbol_t *) vm_realloc(
        vm, NULL, 0, sizeof(symbol_t) + sizeof(char) * (len + 1));

    ptr_init(vm, &sym->p, T_SYMBOL);

    sym->len = (uint32_t) len;
    sym->name[len] = '\0';
    sym->next = NULL;

    memcpy(sym->name, name, len);

    return sym;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x68e3
cmpq $0x0, 0x10(%rsp)
jne 0x6904
movq 0x18(%rsp), %rdi
leaq 0x408d(%rip), %rsi      # 0xa97c
movb $0x0, %al
callq 0x73a0
movq $0x0, 0x20(%rsp)
jmp 0x6985
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
shlq $0x0, %rcx
addq $0x20, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x76b0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movl $0x2, %edx
callq 0x6790
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x20(%rax,%rcx)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1140
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: primitive_new
primitive_t *primitive_new(vm_t *vm, primitive_fn fn) {
    primitive_t *prim =
        (primitive_t *) vm_realloc(vm, NULL, 0, sizeof(primitive_t));

    ptr_init(vm, &prim->p, T_PRIMITIVE);

    prim->name = NULL;
    prim->fn = fn;

    return prim;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x76b0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl $0x3, %edx
callq 0x6790
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: function_new
function_t *function_new(vm_t *vm, env_t *env, value_t params, value_t body) {
    function_t *fn = (function_t *) vm_realloc(vm, NULL, 0, sizeof(function_t));

    ptr_init(vm, &fn->p, T_FUNCTION);

    fn->name = NULL;

    fn->env = env;
    fn->params = params;
    fn->body = body;

    return fn;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x30, %ecx
movq %rdx, %rsi
callq 0x76b0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movl $0x4, %edx
callq 0x6790
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: vector_new
vector_t *vector_new(vm_t *vm, uint32_t count) {
    value_t *data = NULL;
    if (count > 0) {
        data = (value_t *) vm_realloc(vm, NULL, 0, sizeof(value_t) * count);
    }

    vector_t *vec = (vector_t *) vm_realloc(vm, NULL, 0, sizeof(vector_t));

    ptr_init(vm, &vec->p, T_VECTOR);

    vec->capacity = count;
    vec->count = count;
    vec->data = data;

    return vec;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jbe 0x6b4d
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %ecx
shlq $0x3, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x76b0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x76b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x6, %edx
callq 0x6790
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: env_new
env_t *env_new(vm_t *vm, value_t variables, env_t *up) {
    env_t *env = (env_t *) vm_realloc(vm, NULL, 0, sizeof(env_t));

    ptr_init(vm, &env->p, T_ENV);

    env->variables = variables;
    env->up = up;

    vm->env = env;

    return env;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x76b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x7, %edx
callq 0x6790
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: symbol_intern
symbol_t *symbol_intern(vm_t *vm, const char *name, size_t len) {
    for (symbol_t *s = vm->symbol_table; s != NULL; s = s->next) {
        if (s->len == len && memcmp(s->name, name, len * sizeof(char)) == 0) {
            return s;
        }
    }

    symbol_t *sym = symbol_new(vm, name, len);

    sym->next = vm->symbol_table;
    vm->symbol_table = sym;

    return sym;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x6ca7
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
cmpq 0x18(%rsp), %rax
jne 0x6c95
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
shlq $0x0, %rdx
callq 0x10f0
cmpl $0x0, %eax
jne 0x6c95
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x6cea
jmp 0x6c97
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x6c51
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x68c0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: cons_fn
value_t cons_fn(vm_t *vm, value_t a, value_t b) {
    cons_t *result = cons_new(vm);
    result->car = a;
    result->cdr = b;
    return PTR_VAL(result);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x6720
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdi
callq 0x6d50
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: cons_len
int32_t cons_len(value_t val) {
    int32_t len = 0;

    // Uses Floyd's cycle finding algorithm
    value_t fast, slow;
    fast = slow = val;

    while (true) {
        if (IS_NIL(fast)) {
            return len;
        }
        if (IS_CONS(fast) && !IS_NIL(AS_CONS(fast)->cdr) &&
            !IS_CONS(AS_CONS(fast)->cdr)) {
            return -2 - len;
        }
        fast = AS_CONS(fast)->cdr;
        ++len;
        if (IS_NIL(fast)) {
            return len;
        }
        if (IS_CONS(fast) && !IS_NIL(AS_CONS(fast)->cdr) &&
            !IS_CONS(AS_CONS(fast)->cdr)) {
            return -2 - len;
        }
        fast = AS_CONS(fast)->cdr;
        slow = AS_CONS(slow)->cdr;
        ++len;
        if (IS_EQ(fast, slow)) {
            return -1;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x8(%rsp)
jne 0x6dad
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x6f09
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x6f20
testb $0x1, %al
jne 0x6dbf
jmp 0x6e0e
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x18(%rax)
je 0x6e0e
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
callq 0x6f20
testb $0x1, %al
jne 0x6e0e
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
subl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x6f09
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x8(%rsp)
jne 0x6e4f
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x6f09
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x6f20
testb $0x1, %al
jne 0x6e61
jmp 0x6ead
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
cmpq %rcx, 0x18(%rax)
je 0x6ead
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
callq 0x6f20
testb $0x1, %al
jne 0x6ead
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
subl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x6f09
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x6f70
testb $0x1, %al
jne 0x6efa
jmp 0x6f04
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x6f09
jmp 0x6d8f
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: vector_push
void vector_push(vm_t *vm, vector_t *vec, value_t val) {
    if (vec->count + 1 > vec->capacity) {
        uint32_t capacity = vec->capacity ? vec->capacity << 1 : 2;
        vec->data = (value_t *) vm_realloc(vm, vec->data,
                                           vec->capacity * sizeof(value_t),
                                           capacity * sizeof(value_t));
        vec->capacity = capacity;
    }
    vec->data[vec->count++] = val;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
addl $0x1, %eax
movq 0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jbe 0x7029
movq 0x18(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x6fd3
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
shll %eax
movl %eax, 0x8(%rsp)
jmp 0x6fde
movl $0x2, %eax
movl %eax, 0x8(%rsp)
jmp 0x6fde
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
movl 0xc(%rsp), %eax
movl %eax, %ecx
shlq $0x3, %rcx
callq 0x76b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rsi
movl 0x14(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x14(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/value.c
// Function: hash_string_like
static uint32_t hash_string_like(const char *s, uint32_t len) {
    uint32_t hash = HASH_SEED;

    for (uint32_t i = 0; i < len; i++) {
        hash ^= s[i];
        hash *= HASH_PRIME;
    }

    return hash;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x811c9dc5, -0x10(%rsp) # imm = 0x811C9DC5
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jae 0x7391
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movsbl (%rax,%rcx), %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
imull $0x1000193, -0x10(%rsp), %eax # imm = 0x1000193
movl %eax, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x7359
movl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: error_runtime
void error_runtime(vm_t *vm, const char *format, ...) {
    vm->has_error = true;
    if (vm->config.error_fn == NULL) {
        return;
    }

    char message[256];

    va_list contents;
    va_start(contents, format);

    vsnprintf(message, 256, format, contents);

    va_end(contents);

    vm->config.error_fn(vm, -1, -1, message);
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
testb %al, %al
je 0x73dc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movb $0x1, 0x880(%rax)
movq 0x1e0(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x7420
jmp 0x7497
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x1f0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0xd0(%rsp), %rdi
movq 0x1d8(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x1080
leaq 0xb0(%rsp), %rax
movq 0x1e0(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x1e0(%rsp), %rdi
leaq 0xd0(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, %esi
callq *%rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: scm_config_default
void scm_config_default(scm_config_t *config) {
    config->realloc_fn = scm_realloc_default;
    config->error_fn = NULL;
    config->load_fn = NULL;

    // TODO: tweak the initial and min heap sizes
    config->heap_size_initial = 512 * 1024;  // 512 kB
    config->heap_size_min = 64 * 1024;       //  64 kB
    config->heap_growth = 0.5;               //  50%
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
leaq 0x4f(%rip), %rcx        # 0x7500
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x80000, 0x18(%rax)    # imm = 0x80000
movq -0x8(%rsp), %rax
movq $0x10000, 0x20(%rax)    # imm = 0x10000
movq -0x8(%rsp), %rax
movsd 0x34d3(%rip), %xmm0     # 0xa9c8
movsd %xmm0, 0x28(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: scm_realloc_default
static void *scm_realloc_default(void *ptr, size_t new_size) {
    if (new_size == 0) {
        free(ptr);
        return NULL;
    }

    return realloc(ptr, new_size);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x7529
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x10(%rsp)
jmp 0x753c
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1170
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: vm_new
vm_t *vm_new(scm_config_t *config) {
    scm_realloc_fn reallocate = scm_realloc_default;
    if (config != NULL) reallocate = config->realloc_fn;

    vm_t *vm = (vm_t *) reallocate(NULL, sizeof(vm_t));

    memset(vm, 0, sizeof(vm_t));

    if (config != NULL) {
        memcpy(&vm->config, config, sizeof(scm_config_t));
    } else {
        scm_config_default(&vm->config);
    }

    vm->allocated = 0;
    vm->gc_threshold = vm->config.heap_size_initial;

    vm->symbol_table = NULL;

    vm->env = NULL;
    vm->reader = NULL;

    vm->top_env = NULL;

    vm->curval = NIL_VAL;
    vm->gensym_count = 0;

    vm->has_error = false;

    return vm;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq -0x60(%rip), %rax       # 0x7500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x757a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x888, %esi            # imm = 0x888
callq *0x8(%rsp)
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x888, %edx            # imm = 0x888
callq 0x10d0
cmpq $0x0, 0x10(%rsp)
je 0x75bc
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
movl $0x30, %edx
callq 0x1140
jmp 0x75c9
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x74a0
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq 0x38(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x68(%rax)
movq (%rsp), %rax
movl $0x0, 0x70(%rax)
movq (%rsp), %rax
movb $0x0, 0x880(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: vm_free
void vm_free(vm_t *vm) {
    ptrvalue_t *ptr = vm->head;
    while (ptr != NULL) {
        ptrvalue_t *next = ptr->next;
        ptr_free(vm, ptr);
        ptr = next;
    }

    vm_realloc(vm, vm, 0, 0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7695
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x63c0
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x7666
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x76b0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: vm_realloc
void *vm_realloc(vm_t *vm, void *ptr, size_t old_size, size_t new_size) {
    vm->allocated += new_size - old_size;

    if (new_size > 0 && vm->allocated > vm->gc_threshold) {
        vm_gc(vm);
    }
#if !NOGC
    if (vm->allocated > MAX_ALLOCATED) {
        error_runtime(
            vm,
            "Can't allocate - already allocated more than %d (MAX_ALLOCATED)!",
            MAX_ALLOCATED);
        vm->allocated -= new_size;
        return NULL;
    }
#endif  // !NOGC
    return vm->config.realloc_fn(ptr, new_size);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq (%rsp), %rcx
subq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, (%rsp)
jbe 0x7702
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x7702
movq 0x18(%rsp), %rdi
callq 0x7770
movq 0x18(%rsp), %rax
cmpq $0x2000000, 0x8(%rax)   # imm = 0x2000000
jbe 0x7748
movq 0x18(%rsp), %rdi
leaq 0x32e3(%rip), %rsi      # 0xaa00
movl $0x2000000, %edx        # imm = 0x2000000
movb $0x0, %al
callq 0x73a0
movq (%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x7761
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: vm_gc
void vm_gc(vm_t *vm) {
#if NOGC
    return;
#endif  // NOGC
#if DEBUG
    fprintf(stdout, "GC started\n");
    size_t allocated_prev = vm->allocated;
    double time_start = (double) clock() / CLOCKS_PER_SEC;
#endif  // DEBUG
    vm->allocated = 0;
    markall(vm);
    ptrvalue_t **head = &vm->head;
    while (*head != NULL) {
        if (!((*head)->gcmark)) {
            ptrvalue_t *not_found = *head;
            *head = not_found->next;
            ptr_free(vm, not_found);
        } else {
            (*head)->gcmark = false;
            vm->allocated += vm_size(vm, PTR_VAL(*head));
            head = &(*head)->next;
        }
    }
    vm->gc_threshold = vm->allocated * (1 + vm->config.heap_growth);
    if (vm->gc_threshold < vm->config.heap_size_min) {
        vm->gc_threshold = vm->config.heap_size_min;
    }
#if DEBUG
    double time_delta = ((double) clock() / CLOCKS_PER_SEC) - time_start;
    fprintf(stdout, "GC finished: %zuB previously, %zuB now (%zuB gc'd), "
                    "new threshold at %zuB! Time delta: %.3lfs.\n",
            allocated_prev, vm->allocated, (allocated_prev - vm->allocated),
            vm->gc_threshold, time_delta);
#endif  // DEBUG
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x20(%rsp), %rdi
callq 0x79a0
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x783c
movq 0x18(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x4(%rax)
jne 0x77e6
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x63c0
jmp 0x7837
movq 0x18(%rsp), %rax
movq (%rax), %rax
movb $0x0, 0x4(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x7c50
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7a70
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x779a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %xmm0
movaps 0x3193(%rip), %xmm1     # 0xa9e0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x3197(%rip), %xmm1     # 0xa9f0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x48(%rax), %xmm1
movsd 0x315b(%rip), %xmm2     # 0xa9d0
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x3144(%rip), %xmm1     # 0xa9d8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x78d2
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: vm_push_temp
void vm_push_temp(vm_t *vm, ptrvalue_t *ptr) {
    if (ptr == NULL) {
        error_runtime(vm, "Cannot have a NULL as a temporary root!");
    }
    if (vm->num_temp >= MAX_NUM_TEMP) {
        error_runtime(
            vm, "Trying to add a temporary root that is over limit (%d is max)",
            MAX_NUM_TEMP);
    }
    vm->temp[vm->num_temp++] = ptr;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7909
movq 0x10(%rsp), %rdi
leaq 0x313f(%rip), %rsi      # 0xaa41
movb $0x0, %al
callq 0x73a0
movq 0x10(%rsp), %rax
cmpq $0x100, 0x78(%rax)      # imm = 0x100
jb 0x7930
movq 0x10(%rsp), %rdi
leaq 0x3145(%rip), %rsi      # 0xaa69
movl $0x100, %edx            # imm = 0x100
movb $0x0, %al
callq 0x73a0
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rsi
movq 0x78(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x78(%rsi)
movq %rdx, 0x80(%rax,%rcx,8)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: markall
static void markall(vm_t *vm) {
    env_t *env = vm->env;
    mark(vm, PTR_VAL(env));

    if (vm->reader != NULL) {
        mark(vm, vm->reader->tokval);
    }

    for (size_t i = 0; i < vm->num_temp; i++) {
        mark(vm, PTR_VAL(vm->temp[i]));
    }

    mark(vm, vm->curval);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7c50
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8a40
movq 0x20(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x79fb
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x28(%rax), %rsi
callq 0x8a40
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x7a50
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x80(%rax,%rcx,8), %rdi
callq 0x7c50
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x8a40
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x7a04
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rsi
callq 0x8a40
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: vm_size
static size_t vm_size(vm_t *vm, value_t val) {
    if (IS_VAL(val)) {
        return 0;
    } else if (IS_CONS(val)) {
        return sizeof(cons_t);
    } else if (IS_STRING(val)) {
        string_t *str = AS_STRING(val);
        return sizeof(string_t) + sizeof(char) * (str->len + 1);
    } else if (IS_SYMBOL(val)) {
        symbol_t *sym = AS_SYMBOL(val);
        return sizeof(symbol_t) + sizeof(char) * (sym->len + 1);
    } else if (IS_PRIMITIVE(val)) {
        return sizeof(primitive_t);
    } else if (IS_FUNCTION(val) || IS_MACRO(val)) {
        return sizeof(function_t);
    } else if (IS_VECTOR(val)) {
        vector_t *vec = AS_VECTOR(val);
        return sizeof(vector_t) + sizeof(value_t) * (vec->capacity);
    } else if (IS_ENV(val)) {
        return sizeof(env_t);
    }
    // This should be an assert
    error_runtime(vm, "Cannot calculate the size of this value!");
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x20(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
je 0x7aaa
movq $0x0, 0x30(%rsp)
jmp 0x7c3d
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7abc
jmp 0x7aca
movq $0x20, 0x30(%rsp)
jmp 0x7c3d
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7adf
jmp 0x7b12
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x0, %rax
addq $0x18, %rax
movq %rax, 0x30(%rsp)
jmp 0x7c3d
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7b27
jmp 0x7b5a
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x0, %rax
addq $0x20, %rax
movq %rax, 0x30(%rsp)
jmp 0x7c3d
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7b6f
jmp 0x7b7d
movq $0x20, 0x30(%rsp)
jmp 0x7c3d
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7ba5
movq 0x20(%rsp), %rdi
movl $0x5, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7ba5
jmp 0x7bb3
movq $0x30, 0x30(%rsp)
jmp 0x7c3d
movq 0x20(%rsp), %rdi
movl $0x6, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7bc8
jmp 0x7bf3
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
shlq $0x3, %rax
addq $0x20, %rax
movq %rax, 0x30(%rsp)
jmp 0x7c3d
movq 0x20(%rsp), %rdi
movl $0x7, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7c08
jmp 0x7c13
movq $0x20, 0x30(%rsp)
jmp 0x7c3d
jmp 0x7c15
jmp 0x7c17
jmp 0x7c19
jmp 0x7c1b
jmp 0x7c1d
jmp 0x7c1f
jmp 0x7c21
movq 0x28(%rsp), %rdi
leaq 0x3002(%rip), %rsi      # 0xac2f
movb $0x0, %al
callq 0x73a0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: env_push
env_t *env_push(vm_t *vm, env_t *env, value_t vars, value_t vals) {
    value_t alist = NIL_VAL;
    value_t vars_iter, vals_iter;

    // TODO: should we create a macro - like SCM_ASSOC_FOREACH?
    for (vars_iter = vars, vals_iter = vals; IS_CONS(vars_iter);
         vars_iter = AS_CONS(vars_iter)->cdr,
        vals_iter = AS_CONS(vals_iter)->cdr) {
        if (!IS_CONS(vals_iter)) {
            // TODO: Add proper function arity?
            error_runtime(vm, "Number of arguments doesn't match!");
        }

        value_t par = AS_CONS(vars_iter)->car;
        value_t arg = AS_CONS(vals_iter)->car;

        value_t pair = cons_fn(vm, par, arg);
        value_t temp = cons_fn(vm, pair, alist);

        alist = temp;
    }
    if (!IS_NIL(vars_iter)) {
        value_t pair = cons_fn(vm, vars_iter, vals_iter);
        value_t temp = cons_fn(vm, pair, alist);

        alist = temp;
    }
    env_t *new_env = env_new(vm, alist, env);
    return new_env;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7d40
jmp 0x7e04
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x7e80
testb $0x1, %al
jne 0x7d63
movq 0x70(%rsp), %rdi
leaq 0x2d6f(%rip), %rsi      # 0xaacb
movb $0x0, %al
callq 0x73a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x6d00
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x6d00
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x48(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x7d2b
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x48(%rsp)
je 0x7e51
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x6d00
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x6d00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x6bb0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/vm.c
// Function: primitive_add
void primitive_add(vm_t *vm, env_t *env, const char *name, size_t len,
                   primitive_fn fn) {
    symbol_t *sym = symbol_intern(vm, name, len);

    primitive_t *prim = primitive_new(vm, fn);

    prim->name = sym;

    variable_add(vm, env, sym, PTR_VAL(prim));
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x6c30
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x6990
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7c50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
callq 0x7c70
addq $0x58, %rsp
retq
nopl (%rax)