LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x6ea3(%rip), %rsi      # 0xa1c7
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x4d50
testb $0x1, %al
jne 0x3383
movq 0x38(%rsp), %rdi
leaq 0x7031(%rip), %rsi      # 0xa399
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x40(%rsp)
jmp 0x342b
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x85b0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x8450
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
cmpq %rax, 0x8(%rsp)
jne 0x341c
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rdx
addq $0x20, %rdx
leaq 0x6fab(%rip), %rsi      # 0xa3c0
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x8120
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x6992(%rip), %rsi      # 0xa13f
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movq 0xa80f(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x8d30
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x8120
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x6918(%rip), %rsi      # 0xa145
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movq 0xa78f(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x9600
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x418(%rsp)
movq %rsi, 0x410(%rsp)
movq %rdx, 0x408(%rsp)
movq 0x418(%rsp), %rdi
movq 0x408(%rsp), %rdx
leaq 0x684f(%rip), %rsi      # 0xa155
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x12a0
movq %rsp, %rdi
movq 0xa6bd(%rip), %rax      # 0xdfd8
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1100
cmpq $0x0, %rax
jne 0x3942
movabsq $0x7ffc000000000006, %rax # imm = 0x7FFC000000000006
movq %rax, 0x420(%rsp)
jmp 0x395a
movq 0x418(%rsp), %rdi
movq %rsp, %rsi
callq 0x4da0
movq %rax, 0x420(%rsp)
movq 0x420(%rsp), %rax
addq $0x428, %rsp            # imm = 0x428
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8120
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x67ad(%rip), %rsi      # 0xa15a
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x4d50
testb $0x1, %al
jne 0x3a09
movq 0x28(%rsp), %rdi
leaq 0x6a8b(%rip), %rsi      # 0xa47c
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x30(%rsp)
jmp 0x3a48
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
addq $0x18, %rdx
callq *%rax
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x18(%rsp)
jne 0x3a98
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
movq %rax, 0x30(%rsp)
jmp 0x3b9b
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rdi
callq 0x4d10
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x8(%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3ace
jmp 0x3b8c
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x3aee
jmp 0x3b6d
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x85b0
movq %rax, (%rsp)
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
cmpq %rax, (%rsp)
je 0x3b4a
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
cmpq %rax, (%rsp)
je 0x3b4a
movq 0x28(%rsp), %rdi
leaq 0x696b(%rip), %rsi      # 0xa49d
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x30(%rsp)
jmp 0x3b9b
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
cmpq %rax, (%rsp)
jne 0x3b6b
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
movq %rax, 0x30(%rsp)
jmp 0x3b9b
jmp 0x3b6d
jmp 0x3b6f
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3ab1
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x18(%rsp)
jne 0x3be8
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
movq %rax, 0x30(%rsp)
jmp 0x3ceb
movabsq $0x3ffffffffffff, %rdi  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rdi
callq 0x4d10
movq %rax, 0x8(%rsp)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, 0x8(%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3c1e
jmp 0x3cdc
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x3c3e
jmp 0x3cbd
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x85b0
movq %rax, (%rsp)
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
cmpq %rax, (%rsp)
je 0x3c9a
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
cmpq %rax, (%rsp)
je 0x3c9a
movq 0x28(%rsp), %rdi
leaq 0x6837(%rip), %rsi      # 0xa4b9
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x30(%rsp)
jmp 0x3ceb
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
cmpq %rax, (%rsp)
jne 0x3cbb
movabsq $0x7ffc000000000003, %rax # imm = 0x7FFC000000000003
movq %rax, 0x30(%rsp)
jmp 0x3ceb
jmp 0x3cbd
jmp 0x3cbf
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3c01
movabsq $0x7ffc000000000002, %rax # imm = 0x7FFC000000000002
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x4d50
testb $0x1, %al
jne 0x3d62
movq 0x68(%rsp), %rdi
leaq 0x678f(%rip), %rsi      # 0xa4d6
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x70(%rsp)
jmp 0x3e5a
movq 0x50(%rsp), %rax
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rax), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rcx), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rcx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4d10
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x6a80
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4d10
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rax, %rcx
callq 0x7c70
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8120
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x62bf(%rip), %rsi      # 0xa16c
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x6d70
cmpl $0x2, %eax
jne 0x3f2b
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x85b0
movq %rax, 0x30(%rsp)
jmp 0x3f44
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x85b0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x61fd(%rip), %rsi      # 0xa171
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x12a0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x8120
movq %rax, 0x18(%rsp)
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x7f70
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x60fa(%rip), %rsi      # 0xa17e
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x12a0
movq %rsp, %rdi
movq 0x20(%rsp), %rax
movl 0x70(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x70(%rax)
movl $0x10, %esi
leaq 0x6457(%rip), %rdx      # 0xa505
movb $0x0, %al
callq 0x10c0
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x68c0
movq %rax, %rdi
callq 0x4d10
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x6037(%rip), %rsi      # 0xa18b
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x12a0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x85b0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x20(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x10(%rax), %rdx
callq 0x85b0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x6d00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x8120
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x5f73(%rip), %rsi      # 0xa190
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x4d50
testb $0x1, %al
jne 0x4263
movq 0x20(%rsp), %rdi
leaq 0x62ad(%rip), %rsi      # 0xa509
movb $0x0, %al
callq 0x73a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x8120
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x5ed7(%rip), %rsi      # 0xa194
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x4d50
testb $0x1, %al
jne 0x4303
movq 0x20(%rsp), %rdi
leaq 0x622f(%rip), %rsi      # 0xa52b
movb $0x0, %al
callq 0x73a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq (%rsp), %rax
movq 0x18(%rax), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8120
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x5dda(%rip), %rsi      # 0xa1a7
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0x4d50
testb $0x1, %al
jne 0x4429
movq 0x28(%rsp), %rdi
leaq 0x613c(%rip), %rsi      # 0xa54d
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x30(%rsp)
jmp 0x444d
movq 0x8(%rsp), %rax
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
movl 0x14(%rax), %eax
cvtsi2sd %rax, %xmm0
callq 0x1b20
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x8120
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x5d18(%rip), %rsi      # 0xa1b5
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x30(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x6, %esi
callq 0x4d50
testb $0x1, %al
jne 0x4522
movq 0x48(%rsp), %rdi
leaq 0x606f(%rip), %rsi      # 0xa576
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x50(%rsp)
jmp 0x4613
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq 0x20(%rsp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x45bf
movq 0x20(%rsp), %rdi
callq 0x4cf0
callq 0x1050
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4cf0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x45bf
jp 0x45bf
movq 0x20(%rsp), %rdi
callq 0x4cf0
callq 0x1050
cvttsd2si %xmm0, %rax
cmpq $0x0, %rax
jl 0x45bf
movq 0x20(%rsp), %rdi
callq 0x4cf0
callq 0x1050
cvttsd2si %xmm0, %rax
movq 0x18(%rsp), %rcx
movl 0x14(%rcx), %ecx
cmpq %rcx, %rax
jl 0x45e3
movq 0x48(%rsp), %rdi
leaq 0x5fd7(%rip), %rsi      # 0xa5a2
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x50(%rsp)
jmp 0x4613
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4cf0
callq 0x1050
movq 0x8(%rsp), %rax
cvttsd2si %xmm0, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x8120
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x595f(%rip), %rsi      # 0xa1cc
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq 0x30(%rsp), %rcx
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq 0x28(%rsp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x491e
movq 0x28(%rsp), %rdi
callq 0x4cf0
callq 0x1050
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x4cf0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x491e
jp 0x491e
movq 0x28(%rsp), %rdi
callq 0x4cf0
callq 0x1050
cvttsd2si %xmm0, %rax
cmpq $0x0, %rax
jge 0x4942
movq 0x48(%rsp), %rdi
leaq 0x5d20(%rip), %rsi      # 0xa64a
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x50(%rsp)
jmp 0x49b1
movq 0x28(%rsp), %rdi
callq 0x4cf0
callq 0x1050
cvttsd2si %xmm0, %rax
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x6b10
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x49a2
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4975
movq 0x10(%rsp), %rdi
callq 0x4d10
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8120
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x57db(%rip), %rsi      # 0xa1d8
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x4d50
testb $0x1, %al
jne 0x4a59
movq 0x28(%rsp), %rdi
leaq 0x5c41(%rip), %rsi      # 0xa682
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x30(%rsp)
jmp 0x4a87
movq 0x28(%rsp), %rdi
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
andq 0x8(%rsp), %rsi
addq $0x18, %rsi
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x8120
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x56be(%rip), %rsi      # 0xa1eb
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movabsq $0x7ffc000000000000, %rax # imm = 0x7FFC000000000000
andq 0x10(%rsp), %rax
movabsq $0x7ffc000000000000, %rcx # imm = 0x7FFC000000000000
cmpq %rcx, %rax
je 0x4ba0
movq 0x10(%rsp), %rdi
callq 0x4cf0
callq 0x1050
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x4cf0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x4ba0
jp 0x4ba0
jmp 0x4bc2
movq 0x30(%rsp), %rdi
leaq 0x5af7(%rip), %rsi      # 0xa6a3
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x4cf0
callq 0x1050
cvttsd2si %xmm0, %rax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7650
movl 0xc(%rsp), %edi
callq 0x1190
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8120
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x55c3(%rip), %rsi      # 0xa1f0
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x12a0
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
andq 0x8(%rsp), %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x4c98
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x4d50
testb $0x1, %al
jne 0x4c98
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x4d50
testb $0x1, %al
jne 0x4c98
jmp 0x4cb5
movq 0x8(%rsp), %rdi
callq 0x6600
movl %eax, %eax
cvtsi2sd %rax, %xmm0
callq 0x1b20
movq %rax, 0x30(%rsp)
jmp 0x4cd7
movq 0x28(%rsp), %rdi
leaq 0x5a04(%rip), %rsi      # 0xa6c5
movb $0x0, %al
callq 0x73a0
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0x24(%rsp)
movl $0x1, 0x20(%rsp)
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
movq %rax, 0x28(%rsp)
movl $0x1, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x58(%rax)
movq 0x40(%rsp), %rax
movb $0x0, 0x880(%rax)
movq %rsp, %rdi
callq 0x4ea0
cmpl $0x0, 0x30(%rsp)
jne 0x4e47
movq 0x40(%rsp), %rax
movabsq $0x7ffc000000000006, %rcx # imm = 0x7FFC000000000006
movq %rcx, 0x68(%rax)
movabsq $0x7ffc000000000006, %rax # imm = 0x7FFC000000000006
movq %rax, 0x28(%rsp)
jmp 0x4e4f
movq %rsp, %rdi
callq 0x5130
movq 0x40(%rsp), %rax
testb $0x1, 0x880(%rax)
je 0x4e7f
movq 0x40(%rsp), %rax
movabsq $0x7ffc000000000004, %rcx # imm = 0x7FFC000000000004
movq %rcx, 0x68(%rax)
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %edi
callq 0x56d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x5319
jmp 0x532f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5339
jmp 0x5345
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x52f9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x53a5
jmp 0x5358
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0xe(%rsp)
je 0x5385
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x538f
jmp 0x539b
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5358
movq 0x10(%rsp), %rdi
callq 0x5720
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x53c2
movq 0x10(%rsp), %rax
movl $0x0, 0x30(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movb %dil, %al
movb %al, 0x7(%rsp)
movsbl 0x7(%rsp), %edi
callq 0x53d0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x5599
movsbl 0x7(%rsp), %edi
callq 0x5780
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x21, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x24, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x25, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x26, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x3a, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x3c, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x3d, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x3e, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x5e, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x5f, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, 0x6(%rsp)
je 0x5599
movsbl 0x7(%rsp), %eax
cmpl $0x2f, %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1e8, %rsp            # imm = 0x1E8
testb %al, %al
je 0x55ec
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq (%rax), %rax
movb $0x1, 0x880(%rax)
movq 0x1e0(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
jne 0x5639
jmp 0x56c5
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x1f0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0xd0(%rsp), %rdi
movq 0x1d8(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x1080
leaq 0xb0(%rsp), %rax
movq 0x1e0(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x1e0(%rsp), %rcx
movq (%rcx), %rdi
movq 0x1e0(%rsp), %rcx
movl 0x20(%rcx), %esi
movq 0x1e0(%rsp), %rcx
movl 0x24(%rcx), %edx
leaq 0xd0(%rsp), %rcx
callq *%rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movsbl -0x9(%rsp), %eax
cmpl $0xa, %eax
jne 0x5777
movq -0x8(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x24(%rax)
movb -0x9(%rsp), %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/read.c
// Function: read_number
static void read_number(reader_t *reader) {
    errno = 0;

    double d = strtod(reader->tokstart, NULL);

    if ((*reader->cur) == '-' || (*reader->cur) == '+') {
        next_char(reader);
    }

    while (is_digit(*reader->cur)) {
        next_char(reader);
    }

    if (*reader->cur == '.' && is_digit(peek_next_char(reader))) {
        next_char(reader);
        while (is_digit(*reader->cur)) {
            next_char(reader);
        }
    }

    if (*reader->cur == 'e' || *reader->cur == 'E') {
        next_char(reader);
        if (*reader->cur == '-' || *reader->cur == '+') {
            next_char(reader);
        }

        while (is_digit(*reader->cur)) {
            next_char(reader);
        }
    }

    if (errno == ERANGE) {
        // if strtod indicated that the number is too big
        error_print(reader, "Number beginning with %c is too large!",
                    *reader->tokstart);
        reader->tokval = NUM_VAL(0);

        return;
    }

    reader->tokval = NUM_VAL(d);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x1040
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1070
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x5a3e
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x5a48
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5a4a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %edi
callq 0x53d0
testb $0x1, %al
jne 0x5a61
jmp 0x5a6d
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5a4a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5ac5
movq 0x10(%rsp), %rdi
callq 0x5400
movsbl %al, %edi
callq 0x53d0
testb $0x1, %al
jne 0x5a96
jmp 0x5ac5
movq 0x10(%rsp), %rdi
callq 0x5720
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %edi
callq 0x53d0
testb $0x1, %al
jne 0x5ab7
jmp 0x5ac3
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5aa0
jmp 0x5ac5
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
je 0x5ae7
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x45, %eax
jne 0x5b44
movq 0x10(%rsp), %rdi
callq 0x5720
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x5b13
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x5b1d
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5b1f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %edi
callq 0x53d0
testb $0x1, %al
jne 0x5b36
jmp 0x5b42
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5b1f
jmp 0x5b44
callq 0x1040
cmpl $0x22, (%rax)
jne 0x5b83
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %edx
leaq 0x4c3d(%rip), %rsi      # 0xa7a3
movb $0x0, %al
callq 0x55b0
xorps %xmm0, %xmm0
callq 0x5e50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x5b9a
movsd 0x8(%rsp), %xmm0
callq 0x5e50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/read.c
// Function: read_string
static void read_string(reader_t *reader) {
    next_char(reader);
    reader->tokstart = reader->cur;
    while ((*reader->cur) != '\"') {
        next_char(reader);
    }

    next_char(reader);
    size_t len = reader->cur - reader->tokstart - 1;

    string_t *str = string_new(reader->vm, reader->tokstart, len);
    reader->tokval = PTR_VAL(str);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5720
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x5be2
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5bc5
movq 0x10(%rsp), %rdi
callq 0x5720
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x67e0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x5e30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/read.c
// Function: read_quote
static void read_quote(reader_t *reader) {
    next_char(reader);
    next_token(reader);

    symbol_t *s = symbol_intern(reader->vm, "quote", 5);

    read1(reader);
    value_t val = reader->tokval;

    reader->tokval =
        cons_fn(reader->vm, PTR_VAL(s), cons_fn(reader->vm, val, NIL_VAL));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5720
movq 0x20(%rsp), %rdi
callq 0x4ea0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x4509(%rip), %rsi      # 0xa185
movl $0x5, %edx
callq 0x6c30
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5130
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x5e30
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
callq 0x6d00
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x6d00
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5720
movq 0x10(%rsp), %rdi
callq 0x5720
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x6b10
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x5da2
movq 0x10(%rsp), %rdi
callq 0x4ea0
movq 0x10(%rsp), %rax
cmpl $0x3, 0x30(%rax)
jne 0x5d73
movq 0x8(%rsp), %rdi
callq 0x5e30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5da2
movq 0x10(%rsp), %rdi
callq 0x5130
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x6f90
jmp 0x5d31
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiribenes[P]scheme/src/read.c
// Function: read_symbol
static void read_symbol(reader_t *reader) {
    while (is_symbol(*reader->cur)) {
        next_char(reader);
    }

    size_t len = reader->cur - reader->tokstart;

    symbol_t *sym = symbol_intern(reader->vm, reader->tokstart, len);
    reader->tokval = PTR_VAL(sym);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %edi
callq 0x5440
testb $0x1, %al
jne 0x5dd0
jmp 0x5ddc
movq 0x10(%rsp), %rdi
callq 0x5720
jmp 0x5db9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x6c30
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x5e30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x18, %rsp
retq
nop