LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_read
static value_t builtin_read(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "read", args, 0, false);
    char line[1024];
    if (!fgets(line, 1024, stdin)) {
        return EOF_VAL;
    }
    return read_source(vm, line);
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
leaq 0x3855(%rip), %rsi      # 0x614d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12cc
movq 0x76cf(%rip), %rax      # 0x9fd8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1110
testq %rax, %rax
je 0x292b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x33e8
jmp 0x2935
movabsq $0x7ffc000000000006, %rax # imm = 0x7FFC000000000006
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_load
static value_t builtin_load(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "load", eargs, 1, false);
    value_t arg = AS_CONS(eargs)->car;
    if (!IS_STRING(arg)) {
        error_runtime(vm, "load: argument must be a string!");
        return UNDEFINED_VAL;
    }
    string_t *str = AS_STRING(arg);
    vm->config.load_fn(vm, env, str->value);
    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x7ffc000000000004, %rbx # imm = 0x7FFC000000000004
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
callq 0x4cbf
movq %rax, %r12
leaq 0x37e2(%rip), %rsi      # 0x6152
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
andq %r13, %r12
movq 0x10(%r12), %rdx
movq %rdx, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x29b2
andq %r13, %rdx
cmpl $0x1, (%rdx)
jne 0x29b2
addq $0x18, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x30(%r14)
incq %rbx
jmp 0x29c3
leaq 0x3abb(%rip), %rsi      # 0x6474
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_or
static value_t builtin_or(vm_t *vm, env_t *env, value_t args) {
    if (IS_NIL(args)) {
        return FALSE_VAL;
    }
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(args), iter) {
        value_t earg = eval(vm, env, arg);
        if (!IS_BOOL(earg)) {
            error_runtime(vm, "or: argument is not a bool!");
            return UNDEFINED_VAL;
        }

        if (IS_TRUE(earg)) {
            return TRUE_VAL;
        }
    }
    return FALSE_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x7ffc000000000002, %r13 # imm = 0x7FFC000000000002
leaq -0x1(%r13), %rbp
leaq 0x1(%r13), %rax
cmpq %rbp, %rdx
je 0x2a62
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rax, (%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %r15
movabsq $0x3ffffffffffff, %rbx  # imm = 0x3FFFFFFFFFFFF
cmpq %rbp, %r15
je 0x2a44
andq %rbx, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ebe
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %r13, %rcx
jne 0x2a4a
cmpq %r13, %rax
je 0x2a5f
movq 0x18(%r15), %r15
jmp 0x2a16
movq (%rsp), %rax
jmp 0x2a62
leaq 0x3a44(%rip), %rsi      # 0x6495
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $0x2, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_and
static value_t builtin_and(vm_t *vm, env_t *env, value_t args) {
    if (IS_NIL(args)) {
        return TRUE_VAL;
    }
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(args), iter) {
        value_t earg = eval(vm, env, arg);
        if (!IS_BOOL(earg)) {
            error_runtime(vm, "and: argument is not a bool!");
            return UNDEFINED_VAL;
        }

        if (IS_FALSE(earg)) {
            return FALSE_VAL;
        }
    }
    return TRUE_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x7ffc000000000002, %rbx # imm = 0x7FFC000000000002
leaq -0x1(%rbx), %r13
cmpq %r13, %rdx
je 0x2afb
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %r15
leaq 0x1(%rbx), %rbp
cmpq %r13, %r15
je 0x2afb
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ebe
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %rbx, %rcx
jne 0x2ae1
cmpq %rbp, %rax
je 0x2af8
movq 0x18(%r15), %r15
jmp 0x2aa9
leaq 0x39c9(%rip), %rsi      # 0x64b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $0x2, %rbx
jmp 0x2afb
movq %rbp, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: define_macro
static value_t define_macro(vm_t *vm, env_t *env, value_t args) {
    // (define-macro (<name> <params...>) <body...>)
    cons_t *rest = AS_CONS(args);
    if (!IS_CONS(rest->car)) {
        error_runtime(vm, "define-macro: first argument has to be a list!");
        return NIL_VAL;
    }

    symbol_t *sym = AS_SYMBOL(AS_CONS(rest->car)->car);
    value_t params = AS_CONS(rest->car)->cdr;
    cons_t *body = AS_CONS(rest->cdr);

    function_t *macro = macro_new(vm, env, params, PTR_VAL(body));
    macro->name = sym;

    variable_add(vm, env, sym, PTR_VAL(macro));

    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movabsq $-0x4000000000000, %r12 # imm = 0xFFFC000000000000
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %rdx
movq 0x10(%rdx), %rax
leaq -0x1(%r12), %rcx
cmpq %rcx, %rax
jbe 0x2b50
andq %r13, %rax
cmpl $0x0, (%rax)
je 0x2b6e
leaq 0x3977(%rip), %rsi      # 0x64ce
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r15
andq 0x10(%rax), %r13
movq 0x18(%rax), %rax
movq 0x18(%rdx), %rcx
orq %r12, %rcx
movq %r14, %rdi
movq %rax, %rdx
callq 0x41f3
movq %r13, 0x10(%rax)
orq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x4a76
addq $0x4, %rbx
jmp 0x2b61
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_eval
static value_t builtin_eval(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "eval", eargs, 1, true);
    value_t first = AS_CONS(eargs)->car;
    if (cons_len(eargs) == 2) {
        value_t second = AS_CONS(AS_CONS(eargs)->cdr)->car;
        return eval(vm, (env_t *) AS_PTR(second), first);
    } else {
        return eval(vm, env, first);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
callq 0x4cbf
movq %rax, %r12
leaq 0x3591(%rip), %rsi      # 0x6164
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
movl %ecx, %r8d
callq 0x12cc
movq %r12, %rbp
andq %r13, %rbp
movq 0x10(%rbp), %r15
movq %r12, %rdi
callq 0x4378
cmpl $0x2, %eax
jne 0x2c09
movq 0x18(%rbp), %rax
andq %r13, %rax
andq 0x10(%rax), %r13
movq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ebe
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_apply
static value_t builtin_apply(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "apply", args, 2, false);
    value_t eargs = eval_list(vm, env, args);
    value_t fn = AS_CONS(eargs)->car;
    value_t fn_args = AS_CONS(AS_CONS(eargs)->cdr)->car;
    return apply(vm, env, fn, fn_args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x352f(%rip), %rsi      # 0x6169
pushq $0x2
popq %rcx
xorl %r8d, %r8d
callq 0x12cc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4cbf
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
movq 0x10(%rax), %rdx
andq 0x18(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4bdf
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_gensym
static value_t builtin_gensym(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "gensym", args, 0, false);
    char buffer[16];
    snprintf(buffer, sizeof(buffer), "g%u", vm->gensym_count++);
    return PTR_VAL(symbol_new(vm, buffer, 16));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x34a6(%rip), %rsi      # 0x6176
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12cc
movl 0x70(%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x70(%rbx)
leaq 0x3813(%rip), %rdx      # 0x64fd
movq %rsp, %r14
pushq $0x10
popq %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10c0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x40d7
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_cons
static value_t builtin_cons(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "cons", args, 2, false);

    value_t car = eval(vm, env, AS_CONS(args)->car);
    value_t cdr = eval(vm, env, AS_CONS(AS_CONS(args)->cdr)->car);

    value_t cons = cons_fn(vm, car, cdr);
    return cons;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x341e(%rip), %rsi      # 0x6183
pushq $0x2
popq %rcx
xorl %r8d, %r8d
callq 0x12cc
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %r14
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4ebe
movq %rax, %r12
andq 0x18(%r14), %r13
movq 0x10(%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4ebe
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x434c
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_car
static value_t builtin_car(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "car", eargs, 1, false);
    value_t a = AS_CONS(eargs)->car;
    if (!IS_CONS(a)) {
        error_runtime(vm, "car: argument is not a cons cell!");
    }
    return AS_CONS(a)->car;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4cbf
movq %rax, %r14
leaq 0x33b9(%rip), %rsi      # 0x6188
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r14
movq 0x10(%r14), %r14
movq %r14, %rcx
shrq $0x32, %rcx
andq %rax, %r14
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x2e09
cmpl $0x0, (%r14)
je 0x2e1a
leaq 0x36f1(%rip), %rsi      # 0x6501
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45ec
movq 0x10(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_cdr
static value_t builtin_cdr(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "cdr", eargs, 1, false);
    value_t a = AS_CONS(eargs)->car;
    if (!IS_CONS(a)) {
        error_runtime(vm, "cdr: argument is not a cons cell!");
    }
    return AS_CONS(a)->cdr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4cbf
movq %rax, %r14
leaq 0x3350(%rip), %rsi      # 0x618c
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r14
movq 0x10(%r14), %r14
movq %r14, %rcx
shrq $0x32, %rcx
andq %rax, %r14
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x2e76
cmpl $0x0, (%r14)
je 0x2e87
leaq 0x36a6(%rip), %rsi      # 0x6523
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45ec
movq 0x18(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_vec_length
static value_t builtin_vec_length(vm_t *vm, env_t *env, value_t args) {
    // (vector-length <vec>)
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "vector-length", eargs, 1, false);
    value_t arg = AS_CONS(eargs)->car;
    if (!IS_VECTOR(arg)) {
        error_runtime(vm, "vector-length: argument must be a vector");
        return UNDEFINED_VAL;
    }
    return NUM_VAL(AS_VECTOR(arg)->count);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x3ffffffffffff, %r15  # imm = 0x3FFFFFFFFFFFF
callq 0x4cbf
movq %rax, %r14
leaq 0x329d(%rip), %rsi      # 0x619f
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
andq %r15, %r14
movq 0x10(%r14), %rax
movq %rax, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x2f40
andq %r15, %rax
cmpl $0x6, (%rax)
jne 0x2f40
movl 0x14(%rax), %eax
cvtsi2sd %rax, %xmm0
movq %xmm0, %rax
jmp 0x2f5b
leaq 0x35fe(%rip), %rsi      # 0x6545
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45ec
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_vec_ref
static value_t builtin_vec_ref(vm_t *vm, env_t *env, value_t args) {
    // (vector-ref! <vec> <k>)
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "vector-ref", eargs, 2, false);
    value_t first = AS_CONS(eargs)->car;
    value_t second = AS_CONS(AS_CONS(eargs)->cdr)->car;
    if (!IS_VECTOR(first)) {
        error_runtime(vm, "vector-ref: first argument must be a vector");
        return UNDEFINED_VAL;
    }
    vector_t *vec = AS_VECTOR(first);
    if (!IS_INT(second) ||
        !(AS_INT(second) >= 0 && AS_INT(second) < vec->count)) {
        error_runtime(
            vm, "vector-ref: second argument must be a valid integer in range");
        return UNDEFINED_VAL;
    }
    return vec->data[AS_INT(second)];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
callq 0x4cbf
movq %rax, %r15
leaq 0x3219(%rip), %rsi      # 0x61ad
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
andq %r13, %r15
movq 0x10(%r15), %r12
movq %r12, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x3010
andq %r13, %r12
cmpl $0x6, (%r12)
jne 0x3010
andq 0x18(%r15), %r13
movq 0x10(%r13), %rax
movq %rax, %rcx
notq %rcx
testq %rcx, %rbx
je 0x3019
movq %rax, %xmm0
movq %xmm0, 0x8(%rsp)
callq 0x1050
ucomisd 0x8(%rsp), %xmm0
jne 0x3019
jp 0x3019
cvttsd2si %xmm0, %rax
testq %rax, %rax
js 0x3019
movl 0x14(%r12), %ecx
cmpq %rcx, %rax
jae 0x3019
movq 0x18(%r12), %rcx
movq (%rcx,%rax,8), %rbx
jmp 0x302e
leaq 0x3557(%rip), %rsi      # 0x656e
jmp 0x3020
leaq 0x357a(%rip), %rsi      # 0x659a
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $0x4, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_vec_set
static value_t builtin_vec_set(vm_t *vm, env_t *env, value_t args) {
    // (vector-set! <vec> <k> <obj>)
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "vector-set!", eargs, 3, false);
    value_t first = AS_CONS(eargs)->car;
    value_t second = AS_CONS(AS_CONS(eargs)->cdr)->car;
    value_t third = AS_CONS(AS_CONS(AS_CONS(eargs)->cdr)->cdr)->car;
    if (!IS_VECTOR(first)) {
        error_runtime(vm, "vector-set!: first argument must be a vector");
        return UNDEFINED_VAL;
    }
    vector_t *vec = AS_VECTOR(first);
    if (!IS_INT(second) ||
        !(AS_INT(second) >= 0 && AS_INT(second) < vec->count)) {
        error_runtime(
            vm,
            "vector-set!: second argument must be a valid integer in range");
        return UNDEFINED_VAL;
    }
    vec->data[AS_INT(second)] = third;
    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
callq 0x4cbf
movq %rax, %r15
leaq 0x3146(%rip), %rsi      # 0x61b8
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
andq %r13, %r15
movq 0x10(%r15), %r12
movq %r12, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x30fd
andq %r13, %r12
cmpl $0x6, (%r12)
jne 0x30fd
movq 0x18(%r15), %rax
andq %r13, %rax
movq 0x10(%rax), %rcx
movq %rcx, %rdx
notq %rdx
testq %rdx, %rbx
je 0x3106
andq 0x18(%rax), %r13
movq 0x10(%r13), %r15
movq %rcx, %xmm0
movq %xmm0, 0x8(%rsp)
callq 0x1050
ucomisd 0x8(%rsp), %xmm0
jne 0x3106
jp 0x3106
cvttsd2si %xmm0, %rax
testq %rax, %rax
js 0x3106
movl 0x14(%r12), %ecx
cmpq %rcx, %rax
jae 0x3106
movq 0x18(%r12), %rcx
movq %r15, (%rcx,%rax,8)
addq $0x5, %rbx
jmp 0x311b
leaq 0x34d3(%rip), %rsi      # 0x65d7
jmp 0x310d
leaq 0x34f7(%rip), %rsi      # 0x6604
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $0x4, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_vec_make
static value_t builtin_vec_make(vm_t *vm, env_t *env, value_t args) {
    // (make-vector <k> <fill>)
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "make-vector", eargs, 2, false);
    value_t first = AS_CONS(eargs)->car;
    value_t second = AS_CONS(AS_CONS(eargs)->cdr)->car;
    if (!IS_INT(first) || AS_INT(first) < 0) {
        error_runtime(
            vm, "make-vector: first argument must be a positive integer!");
        return UNDEFINED_VAL;
    }
    uint32_t count = AS_INT(first);
    vector_t *vec = vector_new(vm, count);
    for (uint32_t i = 0; i < count; i++) {
        vec->data[i] = second;
    }
    return PTR_VAL(vec);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
callq 0x4cbf
movq %rax, %r15
leaq 0x3074(%rip), %rsi      # 0x61c4
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r15
movq 0x10(%r15), %rcx
movq %rcx, %rdx
notq %rdx
testq %rbx, %rdx
je 0x31cc
andq 0x18(%r15), %rax
movq 0x10(%rax), %r12
movq %rcx, %xmm0
movq %xmm0, (%rsp)
callq 0x1050
ucomisd (%rsp), %xmm0
jne 0x31cc
jp 0x31cc
cvttsd2si %xmm0, %r15
testq %r15, %r15
js 0x31cc
movq %r14, %rdi
movl %r15d, %esi
callq 0x4246
movq %rax, %rbx
movl %r15d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x31f0
movq 0x18(%rbx), %rdx
movq %r12, (%rdx,%rcx,8)
incq %rcx
jmp 0x31ba
leaq 0x346f(%rip), %rsi      # 0x6642
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $0x4, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rbx
jmp 0x31e1
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_error
static value_t builtin_error(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "error", eargs, 1, false);
    value_t arg = AS_CONS(eargs)->car;
    if (!IS_STRING(arg)) {
        error_runtime(vm, "error: argument must be a string");
        return UNDEFINED_VAL;
    }
    error_runtime(vm, AS_STRING(arg)->value);
    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movabsq $0x7ffc000000000004, %rbx # imm = 0x7FFC000000000004
movabsq $0x3ffffffffffff, %r12  # imm = 0x3FFFFFFFFFFFF
callq 0x4cbf
movq %rax, %r15
leaq 0x2fa3(%rip), %rsi      # 0x61d0
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
andq %r12, %r15
movq 0x10(%r15), %rax
movq %rax, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x3273
andq %r12, %rax
leaq 0x18(%rax), %rcx
leaq 0x1(%rbx), %rdx
cmpl $0x1, (%rax)
leaq 0x3411(%rip), %rsi      # 0x667a
cmoveq %rcx, %rsi
cmoveq %rdx, %rbx
jmp 0x327a
leaq 0x3400(%rip), %rsi      # 0x667a
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_exit
static value_t builtin_exit(vm_t *vm, env_t *env, value_t args) {
    // (exit <status>)
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "exit", eargs, 1, false);
    value_t arg = AS_CONS(eargs)->car;
    if (!IS_INT(arg)) {
        error_runtime(vm, "exit: argument must be an integer");
        return UNDEFINED_VAL;
    }
    int exit_status = AS_INT(arg);
    vm_free(vm);
    exit(exit_status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
callq 0x4cbf
movq %rax, %r15
leaq 0x2f00(%rip), %rsi      # 0x61e3
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %r15, %rax
movq 0x10(%rax), %rax
movq %rax, %rcx
notq %rcx
testq %rbx, %rcx
je 0x332a
movq %rax, %xmm0
movq %xmm0, 0x8(%rsp)
callq 0x1050
ucomisd 0x8(%rsp), %xmm0
jne 0x332a
jnp 0x334c
leaq 0x336a(%rip), %rsi      # 0x669b
movq %r14, %rdi
xorl %eax, %eax
callq 0x45ec
addq $0x4, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cvttsd2si %xmm0, %rbx
movq %r14, %rdi
callq 0x47c3
movl %ebx, %edi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/core.c
// Function: builtin_hash
static value_t builtin_hash(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "hash", eargs, 1, false);

    value_t arg = AS_CONS(eargs)->car;
    if (IS_VAL(arg) || IS_STRING(arg) || IS_SYMBOL(arg)) {
        return NUM_VAL(hash_value(arg));
    }
    error_runtime(vm, "hash: cannot hash non-immutable type");
    return UNDEFINED_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x3ffffffffffff, %r15  # imm = 0x3FFFFFFFFFFFF
callq 0x4cbf
movq %rax, %r14
leaq 0x2e67(%rip), %rsi      # 0x61e8
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0x12cc
andq %r15, %r14
movq 0x10(%r14), %rdi
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x33b4
andq %rdi, %r15
movl (%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x33c7
callq 0x3fc0
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movq %xmm0, %rax
jmp 0x33e2
leaq 0x32ef(%rip), %rsi      # 0x66bd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x45ec
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/read.c
// Function: read_source
value_t read_source(vm_t *vm, const char *source) {
    reader_t reader;

    reader.vm = vm;
    reader.source = source;
    reader.tokstart = source;
    reader.cur = source;
    reader.column = 1;
    reader.line = 1;
    reader.tokval = VOID_VAL;
    reader.toktype = TOK_NONE;

    vm->reader = &reader;
    vm->has_error = false;

    /* new here */
    next_token(&reader);

    if (reader.toktype == TOK_EOF) {
        vm->curval = EOF_VAL;
        reader.tokval = EOF_VAL;
    } else {
        read1(&reader);
    }

    if (vm->has_error) {
        // We have encountered an error, everything is surely borked.
        vm->curval = UNDEFINED_VAL;
        reader.tokval = UNDEFINED_VAL;
    }

    vm->curval = reader.tokval;
    return reader.tokval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movabsq $0x7ffc000000000004, %r14 # imm = 0x7FFC000000000004
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
movq %rsi, 0x18(%r15)
movq %rsi, 0x10(%r15)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x20(%r15)
leaq 0x1(%r14), %rax
movq %rax, 0x28(%r15)
movl $0x1, 0x30(%r15)
movq %r15, 0x58(%rdi)
movb $0x0, 0x880(%rdi)
movq %r15, %rdi
callq 0x347e
cmpl $0x0, 0x30(%r15)
je 0x3456
leaq 0x8(%rsp), %rdi
callq 0x354f
jmp 0x345f
leaq 0x2(%r14), %rax
movq %rax, 0x30(%rsp)
cmpb $0x0, 0x880(%rbx)
jne 0x346d
movq 0x30(%rsp), %r14
movq %r14, 0x68(%rbx)
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/read.c
// Function: next_token
static void next_token(reader_t *reader) {
    eat_whitespace(reader);

    if ((*reader->cur) == '(') {
        reader->toktype = TOK_LPAREN;
        reader->tokstart = reader->cur;
    } else if ((*reader->cur) == ')') {
        reader->toktype = TOK_RPAREN;
        reader->tokstart = reader->cur;
    } else if ((*reader->cur) == '#') {
        reader->toktype = TOK_HASH;
        reader->tokstart = reader->cur;
    } else if ((*reader->cur) == '.') {
        reader->toktype = TOK_DOT;
        reader->tokstart = reader->cur;
    } else if ((*reader->cur) == '\'') {
        reader->toktype = TOK_QUOTE;
        reader->tokstart = reader->cur;
    } else if ((*reader->cur) == '\"') {
        reader->toktype = TOK_STRING;
        reader->tokstart = reader->cur;
    } else if (is_digit(*reader->cur)) {
        reader->toktype = TOK_NUMBER;
        reader->tokstart = reader->cur;
    } else if (((*reader->cur) == '-') && is_digit(peek_next_char(reader))) {
        reader->toktype = TOK_NUMBER;
        reader->tokstart = reader->cur;
    } else if (((*reader->cur) == '+') && is_digit(peek_next_char(reader))) {
        reader->toktype = TOK_NUMBER;
        reader->tokstart = reader->cur;
    } else if ((*reader->cur) == '\0') {
        reader->toktype = TOK_EOF;
        reader->tokstart = reader->cur;
    } else if (is_symbol(*reader->cur)) {
        reader->toktype = TOK_SYMBOL;
        reader->tokstart = reader->cur;
    } else {
        error_print(reader, "Unknown token (starts with '%c')",
                    *reader->tokstart);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x399f
movq 0x10(%rbx), %r14
movzbl (%r14), %eax
leal -0x22(%rax), %ecx
cmpl $0xc, %ecx
ja 0x34c5
leaq 0x3243(%rip), %rdx      # 0x66e4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x6, 0x30(%rbx)
jmp 0x34ef
movl $0x5, 0x30(%rbx)
jmp 0x34ef
movl $0x4, 0x30(%rbx)
jmp 0x34ef
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x34fb
movl $0x9, 0x30(%rbx)
jmp 0x34ef
movl $0x8, 0x30(%rbx)
jmp 0x34ef
movl $0x2, 0x30(%rbx)
jmp 0x34ef
movl $0x3, 0x30(%rbx)
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testl %eax, %eax
je 0x352a
cmpl $0x2b, %eax
je 0x3509
cmpl $0x2d, %eax
jne 0x3515
movb 0x1(%r14), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
jbe 0x34cd
movsbl %al, %edi
callq 0x3a0d
testb %al, %al
je 0x3530
movl $0x7, 0x30(%rbx)
jmp 0x34ef
andl $0x0, 0x30(%rbx)
jmp 0x34ef
movq 0x18(%rbx), %rax
movsbl (%rax), %edx
leaq 0x3202(%rip), %rsi      # 0x6740
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a49
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/read.c
// Function: eat_whitespace
static void eat_whitespace(reader_t *reader) {
    while (is_space(*reader->cur) && (*reader->cur) != '\0') {
        next_char(reader);
    }
    if ((*reader->cur) == ';') {
        while (*reader->cur != '\n' && *reader->cur != '\0') {
            next_char(reader);
        }
        next_char(reader);
    }

    if ((*reader->cur) == '\0') {
        reader->toktype = TOK_EOF;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100002600, %r14      # imm = 0x100002600
movq 0x10(%rbx), %rax
movzbl (%rax), %eax
cmpq $0x3b, %rax
ja 0x39fd
btq %rax, %r14
jae 0x39cd
movq %rbx, %rdi
callq 0x3b10
jmp 0x39b0
cmpq $0x3b, %rax
jne 0x39fd
testb %al, %al
je 0x39ef
movzbl %al, %eax
cmpl $0xa, %eax
je 0x39ef
movq %rbx, %rdi
callq 0x3b10
movq 0x10(%rbx), %rax
movb (%rax), %al
jmp 0x39d3
movq %rbx, %rdi
callq 0x3b10
movq 0x10(%rbx), %rax
movb (%rax), %al
testb %al, %al
jne 0x3a05
andl $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/read.c
// Function: is_symbol
inline static bool is_symbol(char c) {
    return is_digit(c) || is_letter(c) || (c == '!') || (c == '$') ||
           (c == '%') || (c == '&') || (c == '*') || (c == '+') || (c == '-') ||
           (c == ':') || (c == '<') || (c == '=') || (c == '>') || (c == '?') ||
           (c == '^') || (c == '_') || (c == '~') || (c == '/');
}

// Assembly:
leal -0x30(%rdi), %ecx
movb $0x1, %al
cmpb $0xa, %cl
jb 0x3a40
movl %edi, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x3a40
movsbl %dil, %ecx
leal -0x21(%rcx), %edx
cmpl $0x3e, %edx
ja 0x3a41
movabsq $0x600000007a005639, %rsi # imm = 0x600000007A005639
btq %rdx, %rsi
jae 0x3a41
retq
cmpl $0x7e, %ecx
je 0x3a40
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/read.c
// Function: next_char
static char next_char(reader_t *reader) {
    char c = *reader->cur;
    // fprintf(stdout, "Note: %c -> %c\n", *reader->cur, *(reader->cur + 1));
    reader->cur++;
    reader->column++;
    if (c == '\n') {
        reader->line++;
        reader->column = 1;
    }
    return c;
}

// Assembly:
movq 0x10(%rdi), %rax
movb (%rax), %cl
incq %rax
movq %rax, 0x10(%rdi)
incl 0x24(%rdi)
cmpb $0xa, %cl
jne 0x3b2f
incl 0x20(%rdi)
movl $0x1, 0x24(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x3ba0
testq %rax, %rax
je 0x3b7d
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x33e8
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4ebe
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
movq 0x6474(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2c92(%rip), %rsi      # 0x6820
movq %r14, %rdx
xorl %eax, %eax
callq 0x1130
pushq $0x42
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d85(%rip), %rsi      # 0x6937
callq 0x11a0
testq %rax, %rax
je 0x3c16
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1180
movq %r14, %rdi
callq 0x1140
movq %rax, %r12
movq %r14, %rdi
callq 0x10b0
leaq 0x1(%r12), %rdi
callq 0x1160
testq %rax, %rax
je 0x3c28
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1060
cmpq %r12, %rax
jb 0x3c3b
movb $0x0, (%r15,%rax)
movq %r14, %rdi
callq 0x10a0
jmp 0x3c19
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x63c9(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2d01(%rip), %rsi      # 0x693a
jmp 0x3c4c
movq 0x63b6(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2d22(%rip), %rsi      # 0x696e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1130
pushq $0x4a
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x3ba0
testq %rax, %rax
je 0x3cb4
movq %rax, %rbx
callq 0x3e8a
movq %rax, %r14
movq %rax, %rdi
callq 0x1329
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33e8
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4ebe
movq %r14, %rdi
callq 0x47c3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
movq 0x633d(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2b7d(%rip), %rsi      # 0x6842
movq %r14, %rdx
xorl %eax, %eax
callq 0x1130
pushq $0x42
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
callq 0x3e8a
movq %rax, %rbx
movq %rax, %rdi
callq 0x1329
movq %rax, %r14
movq 0x62ce(%rip), %r15      # 0x9fd0
movq (%r15), %rdi
leaq 0x2b56(%rip), %rsi      # 0x6862
leaq 0x2ba1(%rip), %rdx      # 0x68b4
xorl %eax, %eax
callq 0x1130
movq 0x62b7(%rip), %r12      # 0x9fd8
movq %rsp, %rbp
movabsq $0x7ffc000000000005, %r13 # imm = 0x7FFC000000000005
movq (%r15), %rcx
leaq 0x2b82(%rip), %rdi      # 0x68ba
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
callq 0x11c0
movq (%r12), %rdx
movq %rbp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1110
testq %rax, %rax
je 0x3d8f
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x33e8
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4ebe
cmpq %r13, %rax
je 0x3d2e
movq (%r15), %rdi
movq %rax, %rsi
callq 0x5642
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
jmp 0x3d2e
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
movq (%r15), %rcx
leaq 0x2b1a(%rip), %rdi      # 0x68be
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x11c0
movq %rbx, %rdi
callq 0x47c3
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0x3e22
cmpl $0x2, %edi
jne 0x3e29
movq 0x8(%rsi), %rbx
leaq 0x2ae7(%rip), %rsi      # 0x68c9
movq %rbx, %rdi
callq 0x1120
testl %eax, %eax
je 0x3e37
leaq 0x2b2f(%rip), %rsi      # 0x6924
movq %rbx, %rdi
callq 0x1120
testl %eax, %eax
jne 0x3e2d
movq 0x61c8(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
leaq 0x2b1c(%rip), %rsi      # 0x692e
leaq 0x2a9b(%rip), %rdx      # 0x68b4
xorl %eax, %eax
callq 0x1130
jmp 0x3e80
callq 0x3cd7
jmp 0x3e80
movq 0x8(%rsi), %rbx
movq %rbx, %rdi
callq 0x3c5e
jmp 0x3e80
movq 0x6192(%rip), %r14      # 0x9fd0
movq (%r14), %rcx
leaq 0x2a88(%rip), %rdi      # 0x68d0
pushq $0x19
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x11c0
movq (%r14), %rcx
leaq 0x2a8a(%rip), %rdi      # 0x68ea
pushq $0x1d
popq %rsi
movq %rbx, %rdx
callq 0x11c0
movq (%r14), %rcx
leaq 0x2a93(%rip), %rdi      # 0x6908
pushq $0x1b
popq %rsi
movq %rbx, %rdx
callq 0x11c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x46af
leaq 0x25(%rip), %rax        # 0x3ec6
movq %rax, 0x8(%rbx)
leaq -0x37c(%rip), %rax      # 0x3b30
movq %rax, 0x10(%rbx)
movq $0x4000000, 0x18(%rbx)  # imm = 0x4000000
movq %rbx, %rdi
callq 0x46f2
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rcx, %r8
movl %edx, %ecx
movl %esi, %edx
testl %esi, %esi
jg 0x3ed7
cmpl $-0x1, %edx
je 0x3eef
retq
movq 0x611a(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2ab7(%rip), %rsi      # 0x699f
xorl %eax, %eax
jmp 0x1130
movq 0x6102(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2ab4(%rip), %rsi      # 0x69b4
movq %r8, %rdx
xorl %eax, %eax
jmp 0x1130
nop
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: ptr_free
void ptr_free(vm_t *vm, ptrvalue_t *ptr) {
    if (ptr->type == T_STRING) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_CONS) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_SYMBOL) {
        symbol_t *ptr_sym = (symbol_t *) ptr;
        symbol_t *prev = NULL;
        symbol_t *s = vm->symbol_table;
        while (s != NULL) {
            if (s->len == ptr_sym->len &&
                memcmp(s->name, ptr_sym->name, s->len * sizeof(char)) == 0) {
                if (prev != NULL) {
                    prev->next = s->next;
                    vm->symbol_table = prev;
                } else {
                    vm->symbol_table = s->next;
                }
                break;
            }
            prev = s;
            s = s->next;
        }
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_PRIMITIVE) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_FUNCTION || ptr->type == T_MACRO) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_VECTOR) {
        vector_t *vec = (vector_t *) ptr;

        vm_realloc(vm, vec->data, 0, 0);

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

        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_ENV) {
        vm_realloc(vm, ptr, 0, 0);
    }
}

// Assembly:
movl (%rsi), %eax
cmpl $0x7, %eax
ja 0x3fa4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xbb, %ecx
btl %eax, %ecx
jae 0x3f4f
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x47f9
cmpl $0x2, %eax
jne 0x3f8b
leaq 0x18(%r14), %r12
leaq 0x20(%rbx), %r15
xorl %r13d, %r13d
movq %r12, %rax
movq (%rax), %rbp
testq %rbp, %rbp
je 0x3f32
movl 0x10(%rbp), %edx
cmpl 0x10(%rbx), %edx
jne 0x3f82
leaq 0x20(%rbp), %rdi
movq %r15, %rsi
callq 0x1170
testl %eax, %eax
je 0x3fa5
leaq 0x18(%rbp), %rax
movq %rbp, %r13
jmp 0x3f62
movq 0x18(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x47f9
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0x3f32
retq
movq 0x18(%rbp), %rax
testq %r13, %r13
je 0x3fb4
movq %rax, 0x18(%r13)
jmp 0x3fb7
movq %rax, %r13
movq %r13, (%r12)
jmp 0x3f32
// File: /workspace/github_c_makefile_star2_O2/jiribenes[P]scheme/src/value.c
// Function: hash_value
uint32_t hash_value(value_t val) {
#if NANTAG
    if (IS_PTR(val)) {
        return hash_ptr(AS_PTR(val));
    } else {
        value_conv_t data;
        data.bits = val;
        return hash_number(data.bits);
    }
#else   // ! NANTAG
    switch (val.type) {
        case V_NIL:
            return 0;
        case V_TRUE:
            return 1;
        case V_FALSE:
            return 2;
        case V_UNDEFINED:
            return 3;
        case V_NUM:
            return hash_number(AS_NUM(val));
        case V_PTR:
            return hash_ptr(AS_PTR(val));
        default:
            return 0;
    }
#endif  // NANTAG
}

// Assembly:
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x3fed
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rdi
movl (%rdi), %ecx
cmpl $0x2, %ecx
je 0x4010
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x3fec
movl 0x14(%rdi), %eax
retq
movq %rdi, -0x8(%rsp)
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %ecx, %ecx
cmpl $0x8, %ecx
je 0x3fec
movzbl -0x8(%rsp,%rcx), %edx
xorl %edx, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
incq %rcx
jmp 0x3ff9
movl 0x10(%rdi), %esi
addq $0x20, %rdi
jmp 0x45cc
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
andl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x19(%rdx), %rcx
xorl %r13d, %r13d
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
movq %rax, %r14
movl $0x1, (%rax)
movb %r13b, 0x4(%rax)
movq (%r12), %rax
movq %rax, 0x8(%r14)
movq %r14, (%r12)
movl %ebx, 0x10(%r14)
movb %r13b, 0x18(%r14,%rbx)
movq %r14, %r12
addq $0x18, %r12
testq %rbx, %rbx
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x40ba
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1150
movl 0x10(%r14), %esi
movq %r12, %rdi
callq 0x45cc
movl %eax, 0x14(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r12
testq %rdx, %rdx
setne %al
testq %rsi, %rsi
setne %cl
testb %al, %cl
jne 0x4109
leaq 0x28f6(%rip), %rsi      # 0x69f0
xorl %r15d, %r15d
movq %r12, %rdi
xorl %eax, %eax
callq 0x45ec
jmp 0x4158
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x21(%rdx), %rcx
xorl %r13d, %r13d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
movq %rax, %r15
movl $0x2, (%rax)
movb %r13b, 0x4(%rax)
movq (%r12), %rax
movq %rax, 0x8(%r15)
movq %r15, (%r12)
movl %ebx, 0x10(%r15)
leaq 0x20(%r15), %rdi
movb %r13b, 0x20(%r15,%rbx)
andq $0x0, 0x18(%r15)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1150
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
movl $0x3, (%rax)
movb $0x0, 0x4(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
andq $0x0, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x30
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
movl $0x4, (%rax)
movb $0x0, 0x4(%rax)
movq (%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r12)
andq $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x426b
movl %ebx, %ecx
shlq $0x3, %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
movq %rax, %r15
jmp 0x426e
xorl %r15d, %r15d
pushq $0x20
popq %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x47f9
movl $0x6, (%rax)
movb $0x0, 0x4(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
movl %ebx, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq