LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: ptr_free
void ptr_free(vm_t *vm, ptrvalue_t *ptr) {
    if (ptr->type == T_STRING) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_CONS) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_SYMBOL) {
        symbol_t *ptr_sym = (symbol_t *) ptr;
        symbol_t *prev = NULL;
        symbol_t *s = vm->symbol_table;
        while (s != NULL) {
            if (s->len == ptr_sym->len &&
                memcmp(s->name, ptr_sym->name, s->len * sizeof(char)) == 0) {
                if (prev != NULL) {
                    prev->next = s->next;
                    vm->symbol_table = prev;
                } else {
                    vm->symbol_table = s->next;
                }
                break;
            }
            prev = s;
            s = s->next;
        }
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_PRIMITIVE) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_FUNCTION || ptr->type == T_MACRO) {
        vm_realloc(vm, ptr, 0, 0);
    } else if (ptr->type == T_VECTOR) {
        vector_t *vec = (vector_t *) ptr;

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

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

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

// Assembly:
movl (%rsi), %eax
cmpl $0x7, %eax
ja 0x476c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xbb, %ecx
btl %eax, %ecx
jae 0x4713
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x502a
cmpl $0x2, %eax
jne 0x4753
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x46f6
movl 0x10(%rbx), %ebp
leaq 0x20(%rbx), %r15
xorl %r12d, %r12d
movq %rax, %r13
movl 0x10(%rax), %edx
cmpl %ebp, %edx
jne 0x4745
leaq 0x20(%r13), %rdi
movq %r15, %rsi
callq 0x1170
testl %eax, %eax
je 0x476d
movq 0x18(%r13), %rax
movq %r13, %r12
testq %rax, %rax
jne 0x472b
jmp 0x46f6
movq 0x18(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x502a
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0x46f6
retq
movq 0x18(%r13), %rax
testq %r12, %r12
je 0x477d
movq %rax, 0x18(%r12)
jmp 0x4780
movq %rax, %r12
movq %r12, 0x18(%r14)
jmp 0x46f6
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: hash_value
uint32_t hash_value(value_t val) {
#if NANTAG
    if (IS_PTR(val)) {
        return hash_ptr(AS_PTR(val));
    } else {
        value_conv_t data;
        data.bits = val;
        return hash_number(data.bits);
    }
#else   // ! NANTAG
    switch (val.type) {
        case V_NIL:
            return 0;
        case V_TRUE:
            return 1;
        case V_FALSE:
            return 2;
        case V_UNDEFINED:
            return 3;
        case V_NUM:
            return hash_number(AS_NUM(val));
        case V_PTR:
            return hash_ptr(AS_PTR(val));
        default:
            return 0;
    }
#endif  // NANTAG
}

// Assembly:
movq %rdi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x47b6
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rdi
movl (%rdi), %ecx
cmpl $0x2, %ecx
je 0x47d9
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x47d8
movl 0x14(%rdi), %eax
retq
movq %rdi, -0x8(%rsp)
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %ecx, %ecx
movzbl -0x8(%rsp,%rcx), %edx
incq %rcx
xorl %eax, %edx
imull $0x1000193, %edx, %eax  # imm = 0x1000193
cmpq $0x8, %rcx
jne 0x47c2
retq
movl 0x10(%rdi), %ecx
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
testq %rcx, %rcx
je 0x47d8
xorl %edx, %edx
movsbl 0x20(%rdi,%rdx), %esi
xorl %eax, %esi
imull $0x1000193, %esi, %eax  # imm = 0x1000193
incq %rdx
cmpq %rdx, %rcx
jne 0x47e8
jmp 0x47d8
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: cons_new
cons_t *cons_new(vm_t *vm) {
    cons_t *cons = (cons_t *) vm_realloc(vm, NULL, 0, sizeof(cons_t));

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

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

    return cons;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
movabsq $0x7ffc000000000001, %rcx # imm = 0x7FFC000000000001
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: string_new
string_t *string_new(vm_t *vm, const char *text, size_t len) {
    string_t *str = (string_t *) vm_realloc(
        vm, NULL, 0, sizeof(string_t) + sizeof(char) * (len + 1));

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

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

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

    hash_string(str);

    return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x19(%rdx), %rcx
xorl %r13d, %r13d
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movq %rax, %rbx
movl $0x1, (%rax)
movb %r13b, 0x4(%rax)
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, (%r14)
movl %r15d, 0x10(%rbx)
movb %r13b, 0x18(%rbx,%r15)
movq %rbx, %r14
addq $0x18, %r14
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x48a0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1150
movl 0x10(%rbx), %eax
movl $0x811c9dc5, %ecx       # imm = 0x811C9DC5
testq %rax, %rax
je 0x48c4
xorl %edx, %edx
movsbl (%r14,%rdx), %esi
xorl %ecx, %esi
imull $0x1000193, %esi, %ecx  # imm = 0x1000193
incq %rdx
cmpq %rdx, %rax
jne 0x48af
movl %ecx, 0x14(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: symbol_new
symbol_t *symbol_new(vm_t *vm, const char *name, size_t len) {
    if (len == 0 || name == NULL) {
        error_runtime(vm, "NULL or 0-length symbols are not allowed!");
        return NULL;
    }

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

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

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

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

    return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r12
testq %rdx, %rdx
setne %al
testq %rsi, %rsi
setne %cl
testb %al, %cl
jne 0x4906
leaq 0x3115(%rip), %rsi      # 0x7a0c
xorl %r15d, %r15d
movq %r12, %rdi
xorl %eax, %eax
callq 0x4e18
jmp 0x4958
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x21(%rdx), %rcx
xorl %r13d, %r13d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movq %rax, %r15
movl $0x2, (%rax)
movb %r13b, 0x4(%rax)
movq (%r12), %rax
movq %rax, 0x8(%r15)
movq %r15, (%r12)
movl %ebx, 0x10(%r15)
leaq 0x20(%r15), %rdi
movb %r13b, 0x20(%r15,%rbx)
movq $0x0, 0x18(%r15)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1150
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: primitive_new
primitive_t *primitive_new(vm_t *vm, primitive_fn fn) {
    primitive_t *prim =
        (primitive_t *) vm_realloc(vm, NULL, 0, sizeof(primitive_t));

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

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

    return prim;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movl $0x3, (%rax)
movb $0x0, 0x4(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
movq $0x0, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: function_new
function_t *function_new(vm_t *vm, env_t *env, value_t params, value_t body) {
    function_t *fn = (function_t *) vm_realloc(vm, NULL, 0, sizeof(function_t));

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

    fn->name = NULL;

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

    return fn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x30, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movl $0x4, (%rax)
movb $0x0, 0x4(%rax)
movq (%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r12)
movq $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: macro_new
function_t *macro_new(vm_t *vm, env_t *env, value_t params, value_t body) {
    function_t *macro =
        (function_t *) vm_realloc(vm, NULL, 0, sizeof(function_t));

    ptr_init(vm, &macro->p, T_MACRO);

    macro->name = NULL;

    macro->env = env;
    macro->params = params;
    macro->body = body;

    return macro;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x30, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movl $0x5, (%rax)
movb $0x0, 0x4(%rax)
movq (%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r12)
movq $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: vector_new
vector_t *vector_new(vm_t *vm, uint32_t count) {
    value_t *data = NULL;
    if (count > 0) {
        data = (value_t *) vm_realloc(vm, NULL, 0, sizeof(value_t) * count);
    }

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

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

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

    return vec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x4a7a
movl %ebx, %ecx
shlq $0x3, %rcx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movq %rax, %r15
jmp 0x4a7d
xorl %r15d, %r15d
movl $0x20, %ecx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movl $0x6, (%rax)
movb $0x0, 0x4(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
movl %ebx, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: env_new
env_t *env_new(vm_t *vm, value_t variables, env_t *up) {
    env_t *env = (env_t *) vm_realloc(vm, NULL, 0, sizeof(env_t));

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

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

    vm->env = env;

    return env;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movl $0x7, (%rax)
movb $0x0, 0x4(%rax)
movq (%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0x50(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: symbol_intern
symbol_t *symbol_intern(vm_t *vm, const char *name, size_t len) {
    for (symbol_t *s = vm->symbol_table; s != NULL; s = s->next) {
        if (s->len == len && memcmp(s->name, name, len * sizeof(char)) == 0) {
            return s;
        }
    }

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

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

    return sym;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x18(%rdi), %r14
testq %r14, %r14
sete %bpl
je 0x4b3a
movl 0x10(%r14), %eax
cmpq %r15, %rax
jne 0x4b2e
leaq 0x20(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1170
testl %eax, %eax
je 0x4b34
movq 0x18(%r14), %r14
jmp 0x4b09
testb $0x1, %bpl
je 0x4b57
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x48d4
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, 0x18(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: cons_fn
value_t cons_fn(vm_t *vm, value_t a, value_t b) {
    cons_t *result = cons_new(vm);
    result->car = a;
    result->cdr = b;
    return PTR_VAL(result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0x502a
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq (%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: cons_len
int32_t cons_len(value_t val) {
    int32_t len = 0;

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

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

// Assembly:
movabsq $-0x4000000000001, %rcx # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x7ffc000000000001, %rdx # imm = 0x7FFC000000000001
xorl %eax, %eax
movabsq $0x3ffffffffffff, %rsi  # imm = 0x3FFFFFFFFFFFF
movq %rdi, %r8
cmpq %rdx, %rdi
je 0x4c4d
cmpq %rcx, %rdi
jbe 0x4bfe
movq %rdi, %r9
andq %rsi, %r9
cmpl $0x0, (%r9)
jne 0x4bfe
movq 0x18(%r9), %r9
cmpq %rdx, %r9
je 0x4bfe
cmpq %rcx, %r9
jbe 0x4c51
andq %rsi, %r9
cmpl $0x0, (%r9)
jne 0x4c51
andq %rsi, %rdi
movq 0x18(%rdi), %rdi
cmpq %rdx, %rdi
je 0x4c4e
cmpq %rcx, %rdi
jbe 0x4c32
movq %rdi, %r9
andq %rsi, %r9
cmpl $0x0, (%r9)
jne 0x4c32
movq 0x18(%r9), %r9
cmpq %rdx, %r9
je 0x4c32
cmpq %rcx, %r9
jbe 0x4c58
andq %rsi, %r9
cmpl $0x0, (%r9)
jne 0x4c58
andq %rsi, %rdi
movq 0x18(%rdi), %rdi
andq %rsi, %r8
movq 0x18(%r8), %r8
addl $0x2, %eax
cmpq %r8, %rdi
jne 0x4bd1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
incl %eax
retq
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x4c5d
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
subl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/value.c
// Function: vector_push
void vector_push(vm_t *vm, vector_t *vec, value_t val) {
    if (vec->count + 1 > vec->capacity) {
        uint32_t capacity = vec->capacity ? vec->capacity << 1 : 2;
        vec->data = (value_t *) vm_realloc(vm, vec->data,
                                           vec->capacity * sizeof(value_t),
                                           capacity * sizeof(value_t));
        vec->capacity = capacity;
    }
    vec->data[vec->count++] = val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl 0x10(%rsi), %edx
movl 0x14(%rsi), %eax
incl %eax
cmpl %edx, %eax
jbe 0x4ca6
leal (%rdx,%rdx), %eax
testq %rdx, %rdx
movl $0x2, %r15d
cmovnel %eax, %r15d
movq 0x18(%r14), %rsi
shlq $0x3, %rdx
leaq (,%r15,8), %rcx
callq 0x502a
movq %rax, 0x18(%r14)
movl %r15d, 0x10(%r14)
movq 0x18(%r14), %rax
movl 0x14(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x14(%r14)
movq %rbx, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: error_runtime
void error_runtime(vm_t *vm, const char *format, ...) {
    vm->has_error = true;
    if (vm->config.error_fn == NULL) {
        return;
    }

    char message[256];

    va_list contents;
    va_start(contents, format);

    vsnprintf(message, 256, format, contents);

    va_end(contents);

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

// Assembly:
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 0x4e71
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)
movb $0x1, 0x880(%rdi)
cmpq $0x0, 0x28(%rdi)
je 0x4ed5
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 $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rcx
callq *0x28(%rbx)
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: scm_config_default
void scm_config_default(scm_config_t *config) {
    config->realloc_fn = scm_realloc_default;
    config->error_fn = NULL;
    config->load_fn = NULL;

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

// Assembly:
leaq 0x29(%rip), %rax        # 0x4f10
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x80000, 0x18(%rdi)    # imm = 0x80000
movq $0x10000, 0x20(%rdi)    # imm = 0x10000
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: vm_new
vm_t *vm_new(scm_config_t *config) {
    scm_realloc_fn reallocate = scm_realloc_default;
    if (config != NULL) reallocate = config->realloc_fn;

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

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

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

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

    vm->symbol_table = NULL;

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

    vm->top_env = NULL;

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

    vm->has_error = false;

    return vm;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdi, %rdi
je 0x4f34
movq (%r14), %rax
jmp 0x4f3b
leaq -0x2b(%rip), %rax       # 0x4f10
movl $0x888, %esi            # imm = 0x888
xorl %edi, %edi
callq *%rax
movq %rax, %rbx
movl $0x888, %edx            # imm = 0x888
movq %rax, %rdi
xorl %esi, %esi
callq 0x10e0
testq %r14, %r14
je 0x4f7d
movq %rbx, %rax
addq $0x20, %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x4fad
leaq -0x74(%rip), %rax       # 0x4f10
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq $0x80000, 0x38(%rbx)    # imm = 0x80000
movq $0x10000, 0x40(%rbx)    # imm = 0x10000
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x48(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x38(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
movq %rax, 0x68(%rbx)
movl $0x0, 0x70(%rbx)
movb $0x0, 0x880(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: vm_free
void vm_free(vm_t *vm) {
    ptrvalue_t *ptr = vm->head;
    while (ptr != NULL) {
        ptrvalue_t *next = ptr->next;
        ptr_free(vm, ptr);
        ptr = next;
    }

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x5014
movq 0x8(%rsi), %r14
movq %rbx, %rdi
callq 0x46d0
movq %r14, %rsi
testq %r14, %r14
jne 0x5000
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x502a
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: vm_realloc
void *vm_realloc(vm_t *vm, void *ptr, size_t old_size, size_t new_size) {
    vm->allocated += new_size - old_size;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, %rax
subq %rdx, %rax
addq 0x8(%rdi), %rax
movq %rax, 0x8(%rdi)
testq %rcx, %rcx
je 0x5059
cmpq 0x10(%r14), %rax
jbe 0x5059
movq %r14, %rdi
callq 0x5096
cmpq $0x2000001, 0x8(%r14)   # imm = 0x2000001
jb 0x5085
leaq 0x2a66(%rip), %rsi      # 0x7ad0
movq %r14, %rdi
movl $0x2000000, %edx        # imm = 0x2000000
xorl %eax, %eax
callq 0x4e18
subq %rbx, 0x8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%r14), %rax
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: vm_push_temp
void vm_push_temp(vm_t *vm, ptrvalue_t *ptr) {
    if (ptr == NULL) {
        error_runtime(vm, "Cannot have a NULL as a temporary root!");
    }
    if (vm->num_temp >= MAX_NUM_TEMP) {
        error_runtime(
            vm, "Trying to add a temporary root that is over limit (%d is max)",
            MAX_NUM_TEMP);
    }
    vm->temp[vm->num_temp++] = ptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jne 0x5240
leaq 0x28db(%rip), %rsi      # 0x7b11
movq %r14, %rdi
xorl %eax, %eax
callq 0x4e18
cmpq $0x100, 0x78(%r14)      # imm = 0x100
jb 0x5260
leaq 0x28e8(%rip), %rsi      # 0x7b39
movq %r14, %rdi
movl $0x100, %edx            # imm = 0x100
xorl %eax, %eax
callq 0x4e18
movq 0x78(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x78(%r14)
movq %rbx, 0x80(%r14,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: env_push
env_t *env_push(vm_t *vm, env_t *env, value_t vars, value_t vals) {
    value_t alist = NIL_VAL;
    value_t vars_iter, vals_iter;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, (%rsp)
movq %rdi, %r14
movabsq $0x7ffc000000000001, %r12 # imm = 0x7FFC000000000001
movq %rdx, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x5378
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x3ffffffffffff, %rbx  # imm = 0x3FFFFFFFFFFFF
movq %rdx, %r13
andq %rbx, %r13
cmpl $0x0, (%r13)
jne 0x5378
cmpq %rbp, %r15
jbe 0x5336
movq %r15, %rax
andq %rbx, %rax
cmpl $0x0, (%rax)
je 0x5347
movq %r14, %rdi
leaq 0x285b(%rip), %rsi      # 0x7b9b
xorl %eax, %eax
callq 0x4e18
movq 0x10(%r13), %rsi
andq %rbx, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
callq 0x4b63
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x4b63
movq %rax, %r12
movq 0x18(%r13), %rdx
movq 0x18(%r15), %r15
cmpq %rbp, %rdx
ja 0x5319
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
cmpq %rax, %rdx
je 0x53a6
movq %r14, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0x4b63
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x4b63
movq %rax, %r12
movq %r14, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ab2
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: primitive_add
void primitive_add(vm_t *vm, env_t *env, const char *name, size_t len,
                   primitive_fn fn) {
    symbol_t *sym = symbol_intern(vm, name, len);

    primitive_t *prim = primitive_new(vm, fn);

    prim->name = sym;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x4af4
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x4965
movq %r12, 0x10(%rax)
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rcx, %rax
orq %rcx, %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4b63
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x4b63
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: apply
value_t apply(vm_t *vm, env_t *env, value_t fn, value_t args) {
    if (!IS_NIL(args) && !IS_CONS(args)) {
        error_runtime(vm, "|apply: Cannot apply to a non-list!");
        return NIL_VAL;
    }
    if (IS_PRIMITIVE(fn)) {
        primitive_t *prim = AS_PRIMITIVE(fn);
        return prim->fn(vm, env, args);
    } else if (IS_FUNCTION(fn)) {
        function_t *func = AS_FUNCTION(fn);
        value_t eargs = eval_list(vm, env, args);
        if (IS_PTR(eargs)) {
            vm_push_temp(vm, AS_PTR(eargs));
        }
        value_t result = apply_func(vm, env, func, eargs);
        if (IS_PTR(eargs)) {
            vm_pop_temp(vm);  // eargs
        }
        return result;
    }

    error_runtime(vm, "|apply: Cannot apply something else than a procedure!");
    return NIL_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movabsq $-0x4000000000001, %r13 # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
cmpq %rbx, %rcx
jne 0x548e
cmpq %r13, %rdx
jbe 0x5500
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
movq %rdx, %r15
andq %rbp, %r15
cmpl $0x3, (%r15)
jne 0x54ae
movq 0x18(%r15), %rax
movq %r14, %rdi
movq %rcx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
cmpq %r13, %rcx
jbe 0x54a5
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
cmpl $0x0, (%rax)
je 0x5455
leaq 0x2712(%rip), %rsi      # 0x7bbe
jmp 0x5507
cmpq %r13, %rdx
jbe 0x5500
cmpl $0x4, (%r15)
jne 0x5500
movq %r14, %rdi
movq %rcx, %rdx
callq 0x5568
movq %rax, %r12
cmpq %r13, %rax
jbe 0x54da
movq %r12, %rsi
andq %rbp, %rsi
movq %r14, %rdi
callq 0x5220
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %r14, %rdi
movq %r12, (%rsp)
movq %r12, %rcx
callq 0x52d8
movq 0x28(%r15), %r15
cmpq %rbx, %r15
jne 0x5523
addq $0x4, %rbx
jmp 0x5544
leaq 0x26db(%rip), %rsi      # 0x7be2
movq %r14, %rdi
xorl %eax, %eax
callq 0x4e18
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
andq %rbp, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5781
movq 0x18(%r15), %r15
cmpq %rbx, %r15
jne 0x5526
movq %rax, %rbx
cmpq %r13, (%rsp)
jbe 0x5511
cmpq $0x0, 0x78(%r14)
jne 0x5562
leaq 0x261f(%rip), %rsi      # 0x7b77
movq %r14, %rdi
xorl %eax, %eax
callq 0x4e18
decq 0x78(%r14)
jmp 0x5511
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: eval_list
value_t eval_list(vm_t *vm, env_t *env, value_t list) {
    if (IS_NIL(list)) {
        return NIL_VAL;
    }
    cons_t *head = NULL;
    cons_t *tail = NULL;

    for (cons_t *cons = AS_CONS(list);; cons = AS_CONS(cons->cdr)) {
        value_t temp = eval(vm, env, cons->car);
        if (head == NULL) {
            head = tail = AS_CONS(cons_fn(vm, temp, NIL_VAL));
            vm_push_temp(vm, (ptrvalue_t *) (head));
        } else {
            tail->cdr = cons_fn(vm, temp, NIL_VAL);
            tail = AS_CONS(tail->cdr);
        }
        if (IS_NIL(cons->cdr)) {
            break;
        }
    }
    vm_pop_temp(vm);  // head
    return PTR_VAL(head);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movabsq $0x7ffc000000000001, %r14 # imm = 0x7FFC000000000001
cmpq %r14, %rdx
je 0x562e
movq %rdx, %r15
movq %rdi, %rbx
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
movq $0x0, 0x8(%rsp)
xorl %r12d, %r12d
andq %rbp, %r15
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x5781
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4b63
movq %rax, %r13
cmpq $0x0, 0x8(%rsp)
je 0x55e1
movq %r13, 0x18(%r12)
andq %rbp, %r13
jmp 0x55f4
andq %rbp, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5220
movq %r13, 0x8(%rsp)
movq %r13, %r12
movq 0x18(%r15), %r15
cmpq %r14, %r15
jne 0x55aa
cmpq $0x0, 0x78(%rbx)
jne 0x5618
leaq 0x2569(%rip), %rsi      # 0x7b77
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
decq 0x78(%rbx)
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
movq 0x8(%rsp), %r14
orq %rax, %r14
movq %r14, %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/vm.c
// Function: find
value_t find(env_t *env, symbol_t *sym) {
    for (env_t *e = env; e != NULL; e = e->up) {
        if (IS_NIL(e->variables)) {
            // we're not going to find anything here, let's move on
            continue;
        }
        value_t pair, iter;
        SCM_FOREACH (pair, AS_CONS(e->variables), iter) {
            symbol_t *key = AS_SYMBOL(AS_CONS(pair)->car);
            if (key == sym) {
                return AS_CONS(pair)->cdr;
            }
        }
    }

    fprintf(stderr, "|find: Error: Symbol %s not bound\n", sym->name);
    // error_runtime(vm, "|find: Symbol %s is not bound in environment!",
    // sym->name);
    return UNDEFINED_VAL;
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
testq %rdi, %rdi
sete %cl
je 0x56ac
movabsq $0x7ffc000000000001, %rsi # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r8   # imm = 0x3FFFFFFFFFFFF
movq 0x10(%rdi), %r9
cmpq %rsi, %r9
je 0x569e
xorl %r10d, %r10d
andq %r8, %r9
movq 0x10(%r9), %rbx
andq %r8, %rbx
movq 0x10(%rbx), %r11
andq %r8, %r11
cmpq %rdx, %r11
jne 0x5686
movq 0x18(%rbx), %rax
cmpq %rdx, %r11
je 0x5698
movq 0x18(%r9), %r9
cmpq %rsi, %r9
sete %r10b
jne 0x566c
testb $0x1, %r10b
je 0x56ac
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
sete %cl
jne 0x5660
jmp 0x56ac
testb $0x1, %cl
jne 0x56b3
popq %rbx
retq
movq 0x593e(%rip), %rax      # 0xaff8
movq (%rax), %rdi
addq $0x20, %rdx
leaq 0x2550(%rip), %rsi      # 0x7c18
xorl %eax, %eax
callq 0x1130
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
addq $0x3, %rax
jmp 0x56b1
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: find_replace
value_t find_replace(env_t *env, symbol_t *sym, value_t new_val) {
    for (env_t *e = env; e != NULL; e = e->up) {
        if (IS_NIL(e->variables)) {
            // we're not going to find anything here, let's move on
            continue;
        }
        value_t pair, iter;
        SCM_FOREACH (pair, AS_CONS(e->variables), iter) {
            symbol_t *key = AS_SYMBOL(AS_CONS(pair)->car);
            if (key == sym) {
                AS_CONS(pair)->cdr = new_val;
                return new_val;
            }
        }
    }

    fprintf(stderr, "|find-replace: Error: Symbol %s not bound\n", sym->name);
    // error_runtime(vm, "|find: Symbol %s is not bound in environment!",
    // sym->name);
    return UNDEFINED_VAL;
}

// Assembly:
pushq %rbx
movq %rdx, %rax
movq %rsi, %rdx
testq %rdi, %rdi
sete %cl
je 0x574e
movabsq $0x7ffc000000000001, %rsi # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r8   # imm = 0x3FFFFFFFFFFFF
movq 0x10(%rdi), %r9
cmpq %rsi, %r9
je 0x5740
xorl %r10d, %r10d
andq %r8, %r9
movq 0x10(%r9), %rbx
andq %r8, %rbx
movq 0x10(%rbx), %r11
andq %r8, %r11
cmpq %rdx, %r11
jne 0x5728
movq %rax, 0x18(%rbx)
cmpq %rdx, %r11
je 0x573a
movq 0x18(%r9), %r9
cmpq %rsi, %r9
sete %r10b
jne 0x570e
testb $0x1, %r10b
je 0x574e
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
sete %cl
jne 0x5702
jmp 0x574e
testb $0x1, %cl
jne 0x5755
popq %rbx
retq
movq 0x589c(%rip), %rax      # 0xaff8
movq (%rax), %rdi
addq $0x20, %rdx
leaq 0x24d1(%rip), %rsi      # 0x7c3b
xorl %eax, %eax
callq 0x1130
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
addq $0x3, %rax
jmp 0x5753
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: eval
value_t eval(vm_t *vm, env_t *env, value_t val) {
    if (IS_VAL(val) || IS_STRING(val) || IS_PROCEDURE(val) || IS_VECTOR(val) ||
        IS_ENV(val)) {
        // These values are self evaluating
        return val;
    } else if (IS_SYMBOL(val)) {
        // This is a variable
        symbol_t *sym = AS_SYMBOL(val);
        value_t result = find(env, sym);
        if (IS_UNDEFINED(result)) {
            error_runtime(vm, "|eval: Can't eval %s - symbol not bound!",
                          sym->name);
        }
        return result;
    } else if (IS_CONS(val)) {
        // It's a function application
        value_t expanded = expand(vm, env, val);

        if (!IS_EQ(expanded, val)) {
            // macros encountered and expanded, now eval the expanded value
            return eval(vm, env, expanded);
        }

        cons_t *cons = AS_CONS(val);
        value_t fn = eval(vm, env, cons->car);
        value_t args = cons->cdr;

        if (!IS_PROCEDURE(fn)) {
            error_runtime(vm, "|eval: Car of eval'd cons is not a procedure!");
        }
        return apply(vm, env, fn, args);
    }

    // This should be an assert
    error_runtime(vm, "|eval: Cannot eval - unknown value type!");
    return NIL_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
cmpq %rbp, %r14
jbe 0x58d4
movq %r14, %r12
andq %r13, %r12
cmpl $0x1, (%r12)
je 0x58d4
cmpl $0x3, (%r12)
je 0x58d4
cmpl $0x4, (%r12)
je 0x58d4
cmpl $0x6, (%r12)
je 0x58d4
cmpl $0x7, (%r12)
je 0x58d4
cmpl $0x2, (%r12)
je 0x587e
cmpl $0x0, (%r12)
jne 0x58b9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x58e6
cmpq %r14, %rax
movq %rax, %r14
jne 0x57a9
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5781
movq %rax, %r14
movq 0x18(%r12), %r12
cmpq %rbp, %rax
jbe 0x584e
andq %r14, %r13
cmpl $0x3, (%r13)
je 0x585f
cmpq %rbp, %r14
jbe 0x584e
cmpl $0x4, (%r13)
je 0x585f
leaq 0x243a(%rip), %rsi      # 0x7c8f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x542e
movq %r15, %rdi
movq %r12, %rsi
callq 0x5640
movq %rax, %r14
movabsq $0x7ffc000000000001, %rax # imm = 0x7FFC000000000001
addq $0x3, %rax
cmpq %rax, %r14
jne 0x58d4
addq $0x20, %r12
leaq 0x23bc(%rip), %rsi      # 0x7c66
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4e18
jmp 0x58d4
movabsq $0x7ffc000000000001, %r14 # imm = 0x7FFC000000000001
leaq 0x23f3(%rip), %rsi      # 0x7cbd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4e18
movq %r14, %rax
addq $0x8, %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/vm.c
// Function: expand
value_t expand(vm_t *vm, env_t *env, value_t val) {
    symbol_t *sym;
    if (IS_SYMBOL(val)) {
        sym = AS_SYMBOL(val);
    } else if (IS_CONS(val) && IS_SYMBOL(AS_CONS(val)->car)) {
        sym = AS_SYMBOL(AS_CONS(val)->car);
    } else {
        return val;
    }

    value_t found = find(env, sym);
    if (IS_UNDEFINED(found) || !IS_MACRO(found)) {
        return val;
    }

    function_t *macro = AS_MACRO(found);
    value_t args = AS_CONS(val)->cdr;
    return apply_func(vm, env, macro, args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdx, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x59be
movq %rdi, %r14
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
movq %rbx, %r12
andq %r13, %r12
cmpl $0x2, (%r12)
movq %rbx, %rax
jne 0x597a
andq %r13, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5640
cmpq %rbp, %rax
jbe 0x59be
movq %rax, %r15
andq %r13, %r15
cmpl $0x5, (%r15)
jne 0x59be
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
movq 0x18(%r12), %rcx
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %r14, %rdi
callq 0x52d8
movq 0x28(%r15), %r15
cmpq %rbx, %r15
jne 0x599d
orq $0x4, %rbx
jmp 0x59be
cmpq %rbp, %rbx
jbe 0x59be
cmpl $0x0, (%r12)
jne 0x59be
movq 0x10(%r12), %rax
cmpq %rbp, %rax
jbe 0x59be
movq %rax, %rcx
andq %r13, %rcx
cmpl $0x2, (%rcx)
je 0x592d
jmp 0x59be
movq %rax, %r12
andq %r13, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5781
movq 0x18(%r15), %r15
cmpq %rbx, %r15
jne 0x59a0
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/vm.c
// Function: begin
value_t begin(vm_t *vm, env_t *env, value_t val) {
    value_t result = VOID_VAL;
    if (IS_NIL(val)) {
        return result;
    }
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(val), iter) { result = eval(vm, env, arg); }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
cmpq %rbx, %rdx
jne 0x59ee
orq $0x4, %rbx
jmp 0x5a1f
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %r14
movq 0x10(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5781
movq 0x18(%r14), %r14
cmpq %rbx, %r14
jne 0x5a01
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/write.c
// Function: write_cons
static void write_cons(FILE *f, cons_t *cons) {
    // First check if the list is circular
    // (we don't want to recurse forever)
    int32_t len = cons_len(PTR_VAL(cons));
    if (len == -1) {
        fprintf(f, "#<circular list>");
        return;
    }

    value_t arg, iter;
    SCM_FOREACH (arg, cons, iter) {
        write(f, arg);

        if (IS_NIL(AS_CONS(iter)->cdr)) {
            return;
        } else if (IS_CONS(AS_CONS(iter)->cdr)) {
            fprintf(f, " ");
        } else {
            fprintf(f, " . ");
            write(f, AS_CONS(iter)->cdr);
            return;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movabsq $-0x4000000000001, %r15 # imm = 0xFFFBFFFFFFFFFFFF
leaq 0x1(%r15), %r14
orq %rsi, %r14
movq %r14, %rdi
callq 0x4bae
cmpl $-0x1, %eax
je 0x5f02
movabsq $0x7ffc000000000001, %r12 # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %r14
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x5b9c
movq 0x18(%r14), %rax
cmpq %r12, %rax
je 0x5ef8
cmpq %r15, %rax
jbe 0x5f24
andq %r13, %rax
cmpl $0x0, (%rax)
jne 0x5f24
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1100
movq 0x18(%r14), %r14
cmpq %r12, %r14
jne 0x5ebd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1ede(%rip), %rdi      # 0x7de7
movl $0x10, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11c0
leaq 0x1ecd(%rip), %rdi      # 0x7df8
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
movq 0x18(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5b9c
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/write.c
// Function: write_string
static void write_string(FILE *f, string_t *str) {
    fprintf(f, "\"");

    for (uint32_t i = 0; i < str->len; i++) {
        char c = str->value[i];
        if (c == '\n') {
            fprintf(f, "\\n");
        } else if (c == '\\') {
            fprintf(f, "\\\\");
        } else if (c == '\"') {
            fprintf(f, "\\\"");
        } else {
            fprintf(f, "%c", c);
        }
    }

    fprintf(f, "\"");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x22, %edi
movq %rbx, %rsi
callq 0x1100
cmpl $0x0, 0x10(%r14)
je 0x5fef
xorl %ebp, %ebp
leaq 0x1e7f(%rip), %r15      # 0x7dff
leaq 0x1e7b(%rip), %r12      # 0x7e02
leaq 0x1e6e(%rip), %r13      # 0x7dfc
movzbl 0x18(%r14,%rbp), %eax
cmpl $0x5c, %eax
je 0x5fc1
cmpl $0x22, %eax
je 0x5fb2
cmpl $0xa, %eax
jne 0x5fd8
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rdi
jmp 0x5fce
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
jmp 0x5fce
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11c0
jmp 0x5fe3
movsbl %al, %edi
movq %rbx, %rsi
callq 0x1100
incq %rbp
movl 0x10(%r14), %eax
cmpq %rax, %rbp
jb 0x5f8e
movl $0x22, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/write.c
// Function: display
void display(FILE *f, value_t val) {
    // void is not printed with display
    if (!IS_STRING(val) && !IS_VOID(val)) {
        write(f, val);
    } else if (IS_STRING(val)) {
        string_t *str = AS_STRING(val);
        fprintf(f, "%.*s", str->len, str->value);
    }
}

// Assembly:
movq %rsi, %rcx
movq %rsi, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x6030
movabsq $0x3ffffffffffff, %rdx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rdx
cmpl $0x1, (%rdx)
sete %dl
jmp 0x6032
xorl %edx, %edx
movabsq $0x7ffc000000000005, %rsi # imm = 0x7FFC000000000005
cmpq %rsi, %rcx
je 0x604d
testb %dl, %dl
jne 0x604d
movq %rcx, %rsi
jmp 0x5b9c
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x607b
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rcx
cmpl $0x1, (%rcx)
jne 0x607b
movl 0x10(%rcx), %edx
addq $0x18, %rcx
leaq 0x1d53(%rip), %rsi      # 0x7dc7
xorl %eax, %eax
jmp 0x1130
retq
// File: /workspace/github_c_makefile_star2_O1/jiribenes[P]scheme/src/write.c
// Function: write_vector
static void write_vector(FILE *f, vector_t *vec) {
    fprintf(f, "#(");
    for (uint32_t i = 0; i < vec->count; i++) {
        write(f, vec->data[i]);
        if (i + 1 != vec->count) {
            fprintf(f, " ");
        }
    }
    fprintf(f, ")");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1d77(%rip), %rdi      # 0x7e05
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
cmpl $0x0, 0x14(%r14)
je 0x60dc
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x5b9c
incq %r15
movl 0x14(%r14), %eax
cmpq %rax, %r15
je 0x60d3
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1100
movl 0x14(%r14), %eax
cmpq %rax, %r15
jb 0x60aa
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O1/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_RecvByte(unsigned char*)
bool mstp_RecvByte(uint8_t* buffer)
{
    if (serailFD == -1) {
        std::cerr << "Error: serial port has not been connected yet. " << std::endl;
        return false;
    }

    if (read(serailFD, buffer, 1) != 1) {
        return false;
    }

    return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
movl 0x2a59(%rip), %edi      # 0x619c
cmpl $-0x1, %edi
je 0x375b
movl $0x1, %edx
callq 0x2220
cmpq $0x1, %rax
sete %al
jmp 0x379f
movq 0x288e(%rip), %rbx      # 0x5ff0
leaq 0xcb4(%rip), %rsi       # 0x441d
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_SendByte(unsigned char*, unsigned int)
bool mstp_SendByte(uint8_t* buffer, uint32_t length)
{
    if (serailFD == -1) {
        std::cerr << "Error: serial port has not been connected yet. " << std::endl;
        return false;
    }

    if (write(serailFD, buffer, length) != length) {
        return false;
    }
    return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movl 0x29f1(%rip), %edi      # 0x619c
cmpl $-0x1, %edi
je 0x37c5
movl %esi, %ebx
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2090
cmpq %rbx, %rax
sete %al
jmp 0x3809
movq 0x2824(%rip), %rbx      # 0x5ff0
leaq 0xc4a(%rip), %rsi       # 0x441d
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_Sleep(unsigned int)
void mstp_Sleep(uint32_t ms)
{
    // 1000 nano  seconds (nsec) == 1 micro seconds
    // 1000 micro seconds (us)  == 1 mili  seconds
    // 1000 mili  seconds (ms)  == 1 seconds
    //    1       second  (sec) == 1,000,000 micro seconds (us)

    uint32_t usec = ms * 1000;
    static struct timespec delay, rem;
    delay.tv_sec = usec / 1000000;

    delay.tv_nsec = (usec - (delay.tv_sec * 1000000)) * 1000;
    int ret = -1;
    while (ret != 0) {
        ret = nanosleep(&delay, &rem);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
imull $0x3e8, %edi, %eax      # imm = 0x3E8
imulq $0x431bde83, %rax, %rcx # imm = 0x431BDE83
shrq $0x32, %rcx
movq %rcx, 0x2989(%rip)      # 0x61b0
imulq $-0xf4240, %rcx, %rcx   # imm = 0xFFF0BDC0
addq %rax, %rcx
imulq $0x3e8, %rcx, %rax      # imm = 0x3E8
movq %rax, 0x2979(%rip)      # 0x61b8
leaq 0x296a(%rip), %rbx      # 0x61b0
leaq 0x2973(%rip), %r14      # 0x61c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
testl %eax, %eax
jne 0x384d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chipkin[P]Linux-HighSpeedSerialMonitor/linuxMSTPFunctions.c
// Function: mstp_TimerDifference()
uint32_t mstp_TimerDifference()
{
    struct timeval end;
    gettimeofday(&end, NULL);

    static long seconds, useconds;
    seconds = end.tv_sec - highspeedTimer.tv_sec;
    useconds = end.tv_usec - highspeedTimer.tv_usec;
    // 1000000 microseconds in a second
    // Return the time in microsecond (us)
    return ((seconds)*1000000 + useconds);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2270
movl (%rbx), %eax
subl 0x2914(%rip), %eax      # 0x61a0
imull $0xf4240, %eax, %eax    # imm = 0xF4240
addl 0x8(%rbx), %eax
subl 0x290d(%rip), %eax      # 0x61a8
addq $0x10, %rsp
popq %rbx
retq