LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/core.c
// Function: builtin_set
static value_t builtin_set(vm_t *vm, env_t *env, value_t args) {
    // (set! <sym> <expr>)
    arity_check(vm, "set!", args, 2, false);
    value_t arg = AS_CONS(args)->car;
    if (!IS_SYMBOL(arg)) {
        error_runtime(vm, "set!: first argument must be a symbol!");
        return NIL_VAL;
    }

    symbol_t *sym = AS_SYMBOL(arg);

    arg = AS_CONS(AS_CONS(args)->cdr)->car;
    value_t val = eval(vm, env, arg);
    value_t result = find_replace(env, sym, val);

    if (IS_UNDEFINED(result)) {
        error_runtime(vm, "set!: assignment not allowed - %s is undefined!",
                      sym->name);
    }

    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x4bae
cmpl $0x2, %eax
je 0x277b
leaq 0x48e6(%rip), %rsi      # 0x7048
leaq 0x4a8e(%rip), %rdx      # 0x71f7
movq %rbx, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000005, %r14 # imm = 0x7FFC000000000005
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r12
movq 0x10(%r12), %r13
movq %r13, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x27f5
andq %rax, %r13
cmpl $0x2, (%r13)
jne 0x27f5
andq 0x18(%r12), %rax
movq 0x10(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5781
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x56df
leaq -0x1(%r14), %rcx
cmpq %rcx, %rax
jne 0x280a
addq $0x20, %r13
leaq 0x4c0a(%rip), %rsi      # 0x73f0
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4e18
jmp 0x280a
leaq 0x4bcd(%rip), %rsi      # 0x73c9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
addq $-0x4, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/core.c
// Function: builtin_write
static value_t builtin_write(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "write", eargs, 1, false);
    write(stdout, AS_CONS(eargs)->car);
    return VOID_VAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5568
movq %rax, %rbx
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x2aad
leaq 0x45b4(%rip), %rsi      # 0x7048
leaq 0x46d4(%rip), %rdx      # 0x716f
movq %r14, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movq 0x851c(%rip), %rax      # 0xafd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rbx
movq 0x10(%rbx), %rsi
callq 0x5b9c
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/core.c
// Function: builtin_display
static value_t builtin_display(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "display", eargs, 1, false);
    display(stdout, AS_CONS(eargs)->car);
    return VOID_VAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5568
movq %rax, %rbx
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x2b1b
leaq 0x4546(%rip), %rsi      # 0x7048
leaq 0x466c(%rip), %rdx      # 0x7175
movq %r14, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movq 0x84ae(%rip), %rax      # 0xafd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rbx
movq 0x10(%rbx), %rsi
callq 0x600a
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdx, %rdi
callq 0x4bae
testl %eax, %eax
je 0x2bce
leaq 0x4490(%rip), %rsi      # 0x7048
leaq 0x45c6(%rip), %rdx      # 0x7185
movq %rbx, %rdi
xorl %ecx, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movq 0x8403(%rip), %rax      # 0xafd8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1110
testq %rax, %rax
je 0x2bf7
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3900
jmp 0x2c01
movabsq $0x7ffc000000000006, %rax # imm = 0x7FFC000000000006
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5568
movq %rax, %r12
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x2c4d
leaq 0x4414(%rip), %rsi      # 0x7048
leaq 0x454f(%rip), %rdx      # 0x718a
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000004, %r15 # imm = 0x7FFC000000000004
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r12
movq 0x10(%r12), %rdx
movq %rdx, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x2c92
andq %rax, %rdx
cmpl $0x1, (%rdx)
jne 0x2c92
addq $0x18, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rbx)
incq %r15
jmp 0x2ca3
leaq 0x4813(%rip), %rsi      # 0x74ac
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movabsq $0x7ffc000000000002, %rbp # imm = 0x7FFC000000000002
leaq -0x1(%rbp), %rbx
leaq 0x1(%rbp), %rax
cmpq %rbx, %rdx
je 0x2d56
movq %rdx, %r14
movq %rdi, %r12
movq %rax, (%rsp)
leaq 0x2(%rbp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r14
movq 0x10(%r14), %rdx
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x5781
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %rbp, %rcx
jne 0x2d26
cmpq %rbp, %rax
setne %r15b
cmoveq %rbp, %r13
jmp 0x2d3f
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x479a(%rip), %rsi      # 0x74cd
xorl %eax, %eax
callq 0x4e18
movq 0x8(%rsp), %r13
testb %r15b, %r15b
je 0x2d53
movq 0x18(%r14), %r14
cmpq %rbx, %r14
jne 0x2cef
movq (%rsp), %rax
jmp 0x2d56
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movabsq $0x7ffc000000000002, %r15 # imm = 0x7FFC000000000002
leaq -0x1(%r15), %rbp
cmpq %rbp, %rdx
je 0x2e09
movq %rdx, %r14
movq %rdi, %r12
leaq 0x1(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x2(%r15), %rax
movq %rax, (%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r14
movq 0x10(%r14), %rdx
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x5781
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %r15, %rcx
jne 0x2dde
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
setne %r13b
cmoveq %rcx, %rbx
jmp 0x2df6
xorl %r13d, %r13d
movq %r12, %rdi
leaq 0x46fe(%rip), %rsi      # 0x74e9
xorl %eax, %eax
callq 0x4e18
movq (%rsp), %rbx
testb %r13b, %r13b
je 0x2e06
movq 0x18(%r14), %r14
cmpq %rbp, %r14
jne 0x2da2
jmp 0x2e09
movq %rbx, %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e5e
andq %r13, %rax
cmpl $0x0, (%rax)
je 0x2e7c
leaq 0x46a1(%rip), %rsi      # 0x7506
movq %r14, %rdi
xorl %eax, %eax
callq 0x4e18
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 0x49fd
movq %r13, 0x10(%rax)
orq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x529e
addq $0x4, %rbx
jmp 0x2e6f
// File: /workspace/github_c_makefile_star2_O1/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
callq 0x5568
movq %rax, %r15
movq %rax, %r12
movq %rax, %rdi
callq 0x4bae
testl %eax, %eax
jg 0x2eff
leaq 0x418e(%rip), %rsi      # 0x7074
leaq 0x42af(%rip), %rdx      # 0x719c
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
andq %rbp, %r15
movq 0x10(%r15), %r13
movq %r12, %rdi
callq 0x4bae
cmpl $0x2, %eax
jne 0x2f2b
movq 0x18(%r15), %rax
andq %rbp, %rax
andq 0x10(%rax), %rbp
movq %rbp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5781
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4bae
cmpl $0x2, %eax
je 0x2f82
leaq 0x40df(%rip), %rsi      # 0x7048
leaq 0x4231(%rip), %rdx      # 0x71a1
movq %r14, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5568
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
movq 0x10(%rax), %rdx
andq 0x18(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x542e
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x4bae
testl %eax, %eax
je 0x3048
leaq 0x4016(%rip), %rsi      # 0x7048
leaq 0x4175(%rip), %rdx      # 0x71ae
movq %rbx, %rdi
xorl %ecx, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movl 0x70(%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x70(%rbx)
leaq 0x44dd(%rip), %rdx      # 0x7535
movq %rsp, %r14
movl $0x10, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10c0
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48d4
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x4bae
cmpl $0x2, %eax
je 0x311e
leaq 0x3f43(%rip), %rsi      # 0x7048
leaq 0x40af(%rip), %rdx      # 0x71bb
movq %rbx, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %r15
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5781
movq %rax, %r12
andq 0x18(%r15), %r13
movq 0x10(%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5781
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4b63
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5568
movq %rax, %r14
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x31a4
leaq 0x3ebd(%rip), %rsi      # 0x7048
leaq 0x402e(%rip), %rdx      # 0x71c0
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x3ffffffffffff, %r15  # imm = 0x3FFFFFFFFFFFF
andq %r15, %r14
movq 0x10(%r14), %r14
movq %r14, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x31ce
movq %r14, %rax
andq %r15, %rax
cmpl $0x0, (%rax)
je 0x31df
leaq 0x4364(%rip), %rsi      # 0x7539
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
andq %r15, %r14
movq 0x10(%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5568
movq %rax, %r14
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x3229
leaq 0x3e38(%rip), %rsi      # 0x7048
leaq 0x3fad(%rip), %rdx      # 0x71c4
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x3ffffffffffff, %r15  # imm = 0x3FFFFFFFFFFFF
andq %r15, %r14
movq 0x10(%r14), %r14
movq %r14, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x3253
movq %r14, %rax
andq %r15, %rax
cmpl $0x0, (%rax)
je 0x3264
leaq 0x4301(%rip), %rsi      # 0x755b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
andq %r15, %r14
movq 0x18(%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5568
movq %rax, %r14
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x3310
leaq 0x3d51(%rip), %rsi      # 0x7048
leaq 0x3ed9(%rip), %rdx      # 0x71d7
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %r14
movq 0x10(%r14), %rax
movq %rax, %rdx
shrq $0x32, %rdx
cmpl $0x3fff, %edx           # imm = 0x3FFF
jb 0x3347
andq %rcx, %rax
cmpl $0x6, (%rax)
jne 0x3347
movl 0x14(%rax), %eax
cvtsi2sd %rax, %xmm0
movq %xmm0, %rax
jmp 0x3362
leaq 0x422f(%rip), %rsi      # 0x757d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5568
movq %rax, %r15
movq %rax, %rdi
callq 0x4bae
cmpl $0x2, %eax
je 0x33aa
leaq 0x3cb7(%rip), %rsi      # 0x7048
leaq 0x3e4d(%rip), %rdx      # 0x71e5
movq %rbx, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000000, %r14 # imm = 0x7FFC000000000000
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r15
movq 0x10(%r15), %r12
movq %r12, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x3428
andq %rax, %r12
cmpl $0x6, (%r12)
jne 0x3428
andq 0x18(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, %rcx
notq %rcx
testq %rcx, %r14
je 0x3431
movq %rax, %xmm0
movq %xmm0, (%rsp)
callq 0x1050
ucomisd (%rsp), %xmm0
jne 0x3431
jp 0x3431
cvttsd2si %xmm0, %rax
testq %rax, %rax
js 0x3431
movl 0x14(%r12), %ecx
cmpq %rcx, %rax
jge 0x3431
movq 0x18(%r12), %rcx
movq (%rcx,%rax,8), %r14
jmp 0x3446
leaq 0x4177(%rip), %rsi      # 0x75a6
jmp 0x3438
leaq 0x419a(%rip), %rsi      # 0x75d2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
addq $0x4, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5568
movq %rax, %r15
movq %rax, %rdi
callq 0x4bae
cmpl $0x3, %eax
je 0x3495
leaq 0x3bcc(%rip), %rsi      # 0x7048
leaq 0x3d6d(%rip), %rdx      # 0x71f0
movq %rbx, %rdi
movl $0x3, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000000, %r14 # imm = 0x7FFC000000000000
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r15
movq 0x10(%r15), %r12
movq %r12, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x3522
andq %rax, %r12
cmpl $0x6, (%r12)
jne 0x3522
movq 0x18(%r15), %rcx
andq %rax, %rcx
movq 0x10(%rcx), %rdx
movq %rdx, %rsi
notq %rsi
testq %rsi, %r14
je 0x352b
andq 0x18(%rcx), %rax
movq 0x10(%rax), %r15
movq %rdx, %xmm0
movq %xmm0, (%rsp)
callq 0x1050
ucomisd (%rsp), %xmm0
jne 0x352b
jp 0x352b
cvttsd2si %xmm0, %rax
testq %rax, %rax
js 0x352b
movl 0x14(%r12), %ecx
cmpq %rcx, %rax
jge 0x352b
movq 0x18(%r12), %rcx
movq %r15, (%rcx,%rax,8)
addq $0x5, %r14
jmp 0x3540
leaq 0x40e6(%rip), %rsi      # 0x760f
jmp 0x3532
leaq 0x410a(%rip), %rsi      # 0x763c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
addq $0x4, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
callq 0x5568
movq %rax, %r15
movq %rax, %rdi
callq 0x4bae
cmpl $0x2, %eax
je 0x358f
leaq 0x3ad2(%rip), %rsi      # 0x7048
leaq 0x3c7f(%rip), %rdx      # 0x71fc
movq %r14, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000000, %rbx # imm = 0x7FFC000000000000
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r15
movq 0x10(%r15), %rcx
movq %rcx, %rdx
notq %rdx
testq %rbx, %rdx
je 0x36aa
andq 0x18(%r15), %rax
movq 0x10(%rax), %r12
movq %rcx, %xmm0
movq %xmm0, (%rsp)
callq 0x1050
ucomisd (%rsp), %xmm0
jne 0x36aa
jp 0x36aa
cvttsd2si %xmm0, %r15
testq %r15, %r15
js 0x36aa
movq %r14, %rdi
movl %r15d, %esi
callq 0x4a55
movq %rax, %rbx
testl %r15d, %r15d
je 0x369b
movq 0x18(%rbx), %rax
movl %r15d, %edx
leaq 0x1(%rdx), %rcx
andq $-0x2, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x39e6(%rip), %xmm1     # 0x7010
xorl %edx, %edx
movdqa 0x39ec(%rip), %xmm2     # 0x7020
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x39ec(%rip), %xmm4     # 0x7030
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x367a
movq %r12, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x368e
movq %r12, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x3644
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %rbx
jmp 0x36bf
leaq 0x3fc9(%rip), %rsi      # 0x767a
movq %r14, %rdi
xorl %eax, %eax
callq 0x4e18
addq $0x4, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x5568
movq %rax, %r15
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x370b
leaq 0x3956(%rip), %rsi      # 0x7048
leaq 0x3b0f(%rip), %rdx      # 0x7208
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000004, %r14 # imm = 0x7FFC000000000004
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %r15
movq 0x10(%r15), %rax
movq %rax, %rdx
shrq $0x32, %rdx
leaq 0x3f7e(%rip), %rsi      # 0x76b2
cmpl $0x3fff, %edx           # imm = 0x3FFF
jb 0x374e
andq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x374e
addq $0x18, %rax
incq %r14
movq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
callq 0x5568
movq %rax, %r15
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x37e8
leaq 0x3879(%rip), %rsi      # 0x7048
leaq 0x3a45(%rip), %rdx      # 0x721b
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000000, %r14 # imm = 0x7FFC000000000000
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r15
movq 0x10(%r15), %rax
movq %rax, %rcx
notq %rcx
testq %r14, %rcx
je 0x3828
movq %rax, %xmm0
movq %xmm0, 0x8(%rsp)
callq 0x1050
ucomisd 0x8(%rsp), %xmm0
jne 0x3828
jnp 0x384a
leaq 0x3ea4(%rip), %rsi      # 0x76d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
addq $0x4, %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cvttsd2si %xmm0, %r14
movq %rbx, %rdi
callq 0x4ff1
movl %r14d, %edi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5568
movq %rax, %r14
movq %rax, %rdi
callq 0x4bae
cmpl $0x1, %eax
je 0x389b
leaq 0x37c6(%rip), %rsi      # 0x7048
leaq 0x3997(%rip), %rdx      # 0x7220
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4e18
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r14
movq 0x10(%r14), %rdi
movq %rdi, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x38c8
andq %rdi, %rax
cmpl $0x1, (%rax)
je 0x38c8
cmpl $0x2, (%rax)
jne 0x38e1
callq 0x4789
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movq %xmm0, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3e0d(%rip), %rsi      # 0x76f5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
jmp 0x38d9
nop
// File: /workspace/github_c_makefile_star2_O1/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, %r15 # imm = 0x7FFC000000000004
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq %rsi, 0x8(%r14)
movq %rsi, 0x18(%r14)
movq %rsi, 0x10(%r14)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x20(%r14)
leaq 0x1(%r15), %rax
movq %rax, 0x28(%r14)
movl $0x1, 0x30(%r14)
movq %r14, 0x58(%rdi)
movb $0x0, 0x880(%rdi)
movq %r14, %rdi
callq 0x39a0
cmpl $0x0, 0x30(%r14)
je 0x396e
leaq 0x8(%rsp), %rdi
callq 0x3a9b
jmp 0x397b
leaq 0x2(%r15), %rax
movq %rax, 0x68(%rbx)
movq %rax, 0x30(%rsp)
cmpb $0x1, 0x880(%rbx)
jne 0x398d
movq %r15, 0x68(%rbx)
movq %r15, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x68(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x40c9
movq 0x10(%rbx), %rax
movzbl (%rax), %ecx
leal -0x22(%rcx), %edx
cmpl $0xc, %edx
ja 0x39e3
leaq 0x3d5d(%rip), %rsi      # 0x771c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movl $0x6, 0x30(%rbx)
jmp 0x3a0d
movl $0x5, 0x30(%rbx)
jmp 0x3a0d
movl $0x4, 0x30(%rbx)
jmp 0x3a0d
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x3a13
movl $0x9, 0x30(%rbx)
jmp 0x3a0d
movl $0x8, 0x30(%rbx)
jmp 0x3a0d
movl $0x2, 0x30(%rbx)
jmp 0x3a0d
movl $0x3, 0x30(%rbx)
movq %rax, 0x18(%rbx)
popq %rbx
retq
testl %ecx, %ecx
je 0x3a74
cmpl $0x2b, %ecx
je 0x3a35
cmpl $0x2d, %ecx
jne 0x3a44
movb 0x1(%rax), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
jbe 0x39eb
testl %ecx, %ecx
je 0x3a74
cmpl $0x2b, %ecx
jne 0x3a44
movb 0x1(%rax), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
jbe 0x39eb
testl %ecx, %ecx
je 0x3a74
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x1a, %dl
jb 0x3a6b
movl %ecx, %edx
addl $-0x21, %edx
cmpl $0x3e, %edx
ja 0x3a7d
movabsq $0x600000007a005639, %rsi # imm = 0x600000007A005639
btq %rdx, %rsi
jae 0x3a7d
movl $0x7, 0x30(%rbx)
jmp 0x3a0d
movl $0x0, 0x30(%rbx)
jmp 0x3a0d
cmpl $0x7e, %ecx
je 0x3a6b
movq 0x18(%rbx), %rax
movsbl (%rax), %edx
leaq 0x3ce8(%rip), %rsi      # 0x7778
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x10(%rdi), %rax
incq %rax
movabsq $0x100002600, %rcx      # imm = 0x100002600
movzbl -0x1(%rax), %edx
cmpq $0x3b, %rdx
ja 0x413e
btq %rdx, %rcx
jae 0x4105
movq %rax, 0x10(%rdi)
incl 0x24(%rdi)
cmpb $0xa, %dl
jne 0x4100
incl 0x20(%rdi)
movl $0x1, 0x24(%rdi)
incq %rax
jmp 0x40da
cmpq $0x3b, %rdx
jne 0x413e
movq 0x10(%rdi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x4128
cmpl $0xa, %ecx
je 0x4128
movq %rax, 0x10(%rdi)
incl 0x24(%rdi)
jmp 0x410f
movq %rax, 0x10(%rdi)
incl 0x24(%rdi)
cmpb $0xa, %cl
jne 0x413e
incl 0x20(%rdi)
movl $0x1, 0x24(%rdi)
movq 0x10(%rdi), %rax
cmpb $0x0, (%rax)
je 0x4148
retq
movl $0x0, 0x30(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/read.c
// Function: error_print
static void error_print(reader_t *reader, const char *format, ...) {
    reader->vm->has_error = true;
    if (reader->vm->config.error_fn == NULL) {
        return;
    }

    // TODO Move magic number and actually determine the size needed
    char message[256];

    va_list contents;
    va_start(contents, format);

    vsnprintf(message, 256, format, contents);

    va_end(contents);

    reader->vm->config.error_fn(reader->vm, reader->line, reader->column,
                                message);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x41a9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq (%rdi), %rax
movb $0x1, 0x880(%rax)
cmpq $0x0, 0x28(%rax)
je 0x420c
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r10, %rdx
callq 0x1080
movq (%rbx), %rdi
movl 0x20(%rbx), %esi
movl 0x24(%rbx), %edx
movq %r14, %rcx
callq *0x28(%rdi)
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/read.c
// Function: read_vector
static void read_vector(reader_t *reader) {
    next_char(reader);  // consumes '#'
    next_char(reader);  // consumes '('

    vector_t *vec = vector_new(reader->vm, 0);
    while (reader->toktype != TOK_EOF) {
        next_token(reader);
        if (reader->toktype == TOK_RPAREN) {
            reader->tokval = PTR_VAL(vec);
            next_char(reader);
            return;
        } else {
            read1(reader);
            value_t elem = reader->tokval;
            vector_push(reader->vm, vec, elem);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movb (%rax), %cl
leaq 0x1(%rax), %rdx
movq %rdx, 0x10(%rdi)
incl 0x24(%rdi)
cmpb $0xa, %cl
jne 0x423e
incl 0x20(%rbx)
movl $0x1, 0x24(%rbx)
movb 0x1(%rax), %cl
addq $0x2, %rax
movq %rax, 0x10(%rbx)
incl 0x24(%rbx)
cmpb $0xa, %cl
jne 0x425b
incl 0x20(%rbx)
movl $0x1, 0x24(%rbx)
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x4a55
cmpl $0x0, 0x30(%rbx)
je 0x42cb
movq %rax, %r14
movq %rbx, %rdi
callq 0x39a0
cmpl $0x3, 0x30(%rbx)
je 0x429b
movq %rbx, %rdi
callq 0x3a9b
movq (%rbx), %rdi
movq 0x28(%rbx), %rdx
movq %r14, %rsi
callq 0x4c62
cmpl $0x0, 0x30(%rbx)
jne 0x426e
jmp 0x42cb
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
orq %rax, %r14
movq %r14, 0x28(%rbx)
movq 0x10(%rbx), %rax
movb (%rax), %cl
incq %rax
movq %rax, 0x10(%rbx)
incl 0x24(%rbx)
cmpb $0xa, %cl
jne 0x42cb
incl 0x20(%rbx)
movl $0x1, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4329
testq %rax, %rax
je 0x4321
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x3900
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x5781
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
movq %r12, %rdi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O1/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 0x3634(%rip), %rsi      # 0x796f
callq 0x11a0
testq %rax, %rax
je 0x43a3
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
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 0x43b5
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1060
cmpq %r12, %rax
jb 0x43bd
movb $0x0, (%r15,%rax)
movq %r14, %rdi
callq 0x10a0
jmp 0x43a6
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1228
movq %rbx, %rdi
callq 0x1204
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x30, %rsp
movq %rdi, %r14
callq 0x4329
testq %rax, %rax
je 0x4450
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4ee0
leaq 0x29c(%rip), %rax       # 0x468c
movq %rax, 0x8(%r14)
leaq -0x127(%rip), %rax      # 0x42d4
movq %rax, 0x10(%r14)
movq $0x4000000, 0x18(%r14)  # imm = 0x4000000
movq %r14, %rdi
callq 0x4f23
movq %rax, %r14
movq %rax, %rdi
callq 0x13d9
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3900
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5781
movq %r14, %rdi
callq 0x4ff1
movq %rbx, %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x124c
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4ee0
leaq 0x211(%rip), %rax       # 0x468c
movq %rax, 0x8(%rbx)
leaq -0x1b2(%rip), %rax      # 0x42d4
movq %rax, 0x10(%rbx)
movq $0x4000000, 0x18(%rbx)  # imm = 0x4000000
movq %rbx, %rdi
callq 0x4f23
movq %rax, %rbx
movq %rax, %rdi
callq 0x13d9
movq %rax, %r14
movq 0x6b21(%rip), %r13      # 0xafd0
movq (%r13), %rdi
leaq 0x33e0(%rip), %rsi      # 0x789a
leaq 0x342b(%rip), %rdx      # 0x78ec
xorl %eax, %eax
callq 0x1130
movq (%r13), %rcx
leaq 0x341f(%rip), %rdi      # 0x78f2
movl $0x3, %esi
movl $0x1, %edx
callq 0x11c0
movq 0x6aef(%rip), %rax      # 0xafd8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1110
testq %rax, %rax
je 0x457c
movq %rsp, %r15
movabsq $0x7ffc000000000005, %rbp # imm = 0x7FFC000000000005
leaq 0x33e0(%rip), %r12      # 0x78f2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3900
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5781
cmpq %rbp, %rax
je 0x454a
movq (%r13), %rdi
movq %rax, %rsi
callq 0x600a
movq (%r13), %rsi
movl $0xa, %edi
callq 0x1100
movq (%r13), %rcx
movl $0x3, %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x11c0
movq 0x6a71(%rip), %rax      # 0xafd8
movq (%rax), %rdx
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1110
testq %rax, %rax
jne 0x4512
movq (%r13), %rsi
movl $0xa, %edi
callq 0x1100
movq (%r13), %rcx
leaq 0x3361(%rip), %rdi      # 0x78f6
movl $0xa, %esi
movl $0x1, %edx
callq 0x11c0
movq %rbx, %rdi
callq 0x4ff1
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
je 0x4600
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jne 0x4607
movq 0x8(%rbx), %r14
leaq 0x3325(%rip), %rsi      # 0x7901
movq %r14, %rdi
callq 0x1120
testl %eax, %eax
je 0x4612
leaq 0x336d(%rip), %rsi      # 0x795c
movq %r14, %rdi
callq 0x1120
testl %eax, %eax
je 0x4666
cmpl $0x1, %ebp
jne 0x4607
callq 0x4458
jmp 0x4685
movq 0x8(%rbx), %rdi
callq 0x43c5
jmp 0x4685
movq 0x69b7(%rip), %rbx      # 0xafd0
movq (%rbx), %rcx
leaq 0x32e5(%rip), %rdi      # 0x7908
movl $0x19, %esi
movl $0x1, %edx
callq 0x11c0
movq (%rbx), %rcx
leaq 0x32e6(%rip), %rdi      # 0x7922
movl $0x1d, %esi
movl $0x1, %edx
callq 0x11c0
movq (%rbx), %rcx
leaq 0x32eb(%rip), %rdi      # 0x7940
movl $0x1b, %esi
movl $0x1, %edx
callq 0x11c0
jmp 0x4685
movq 0x6963(%rip), %rax      # 0xafd0
movq (%rax), %rdi
leaq 0x32ef(%rip), %rsi      # 0x7966
leaq 0x326e(%rip), %rdx      # 0x78ec
xorl %eax, %eax
callq 0x1130
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x469d
cmpl $-0x1, %edx
je 0x46b5
retq
movq 0x6954(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x3329(%rip), %rsi      # 0x79d7
xorl %eax, %eax
jmp 0x1130
movq 0x693c(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x3326(%rip), %rsi      # 0x79ec
movq %r8, %rdx
xorl %eax, %eax
jmp 0x1130