LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_convert
awlval* builtin_convert(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "convert");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QSYM, "convert");

    awlval* tsym = awlval_pop(a, 0);
    awlval* v = awlval_take(a, 0);

    awlval* res;
    awlval_type_t type = awlval_parse_sysname(tsym->sym);
    if (errno != EINVAL) {
        res = awlval_convert(type, v);
    } else {
        res = awlval_err("no such type: %s", tsym->sym);
    }

    awlval_del(tsym);
    awlval_del(v);

    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x5414
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x548c
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x543e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %r15
movq 0x18(%r14), %rdi
callq 0x10174
movl %eax, %ebx
callq 0x2060
cmpl $0x16, (%rax)
jne 0x546f
movq 0x18(%r14), %rsi
leaq 0xd130(%rip), %rdi      # 0x1253b
xorl %eax, %eax
callq 0x1032f
jmp 0x5479
leaq 0xccdf(%rip), %rdi      # 0x120fa
leaq 0xd111(%rip), %rsi      # 0x12533
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
jmp 0x548f
callq 0x10138
movq %rax, %r14
movl $0x4, %edi
callq 0x10138
leaq 0xccea(%rip), %rdi      # 0x12141
leaq 0xd0d5(%rip), %rsi      # 0x12533
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x542e
movl %ebx, %edi
movq %r15, %rsi
callq 0x11080
movq %rax, %rbx
movq %r14, %rdi
callq 0x10767
movq %r15, %rdi
callq 0x10767
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_print
awlval* builtin_print(awlenv* e, awlval* a) {
    EVAL_ARGS(e, a);
    for (int i = 0; i < a->count; i++) {
        if (i != 0) {
            awl_printf(" ");
        }
        if (a->cell[i]->type == AWLVAL_STR) {
            awl_printf("%s", a->cell[i]->str);
        } else {
            awlval_print(a->cell[i]);
        }
    }
    awlval_del(a);
    return awlval_qexpr();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x5789
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x0, 0x4(%rbx)
jle 0x57dd
leaq 0xcdb3(%rip), %r14      # 0x12549
leaq 0xdd5d(%rip), %r15      # 0x134fa
xorl %r12d, %r12d
testq %r12, %r12
je 0x57af
movq %r15, %rdi
xorl %eax, %eax
callq 0xfb16
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
cmpl $0x5, (%rdi)
jne 0x57cc
movq 0x18(%rdi), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xfb16
jmp 0x57d1
callq 0xfc07
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0x57a0
movq %rbx, %rdi
callq 0x10767
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x106fb
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_error
awlval* builtin_error(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "error");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_STR, "error");

    awlval* err = awlval_err(a->cell[0]->str);
    awlval_del(a);
    return err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x588d
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x58bd
movq %rbx, %rax
jmp 0x58b5
leaq 0xc866(%rip), %rdi      # 0x120fa
leaq 0xcd05(%rip), %rsi      # 0x125a0
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x5, %edi
jne 0x58d8
movq 0x18(%rax), %rdi
xorl %eax, %eax
callq 0x1032f
jmp 0x58a7
callq 0x10138
movq %rax, %r14
movl $0x5, %edi
callq 0x10138
leaq 0xc850(%rip), %rdi      # 0x12141
leaq 0xcca8(%rip), %rsi      # 0x125a0
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x58a7
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_new
dict* dict_new(const copy_fn copier, const del_fn deleter) {
    dict* d = dict_new_no_bindings();
    d->copier = copier;
    d->deleter = deleter;
    return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x593f
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_new_no_bindings
dict* dict_new_no_bindings(void) {
    dict* d = safe_malloc(sizeof(dict));
    d->size = DICT_INITIAL_SIZE;
    d->count = 0;
    d->syms = safe_malloc(sizeof(char*) * DICT_INITIAL_SIZE);
    for (int i = 0; i < DICT_INITIAL_SIZE; i++) {
        d->syms[i] = NULL;
    }
    d->vals = safe_malloc(sizeof(void*) * DICT_INITIAL_SIZE);
    d->copier = NULL;
    d->deleter = NULL;
    return d;
}

// Assembly:
pushq %rbx
movl $0x28, %edi
callq 0x2290
testq %rax, %rax
je 0x59ad
movq %rax, %rbx
movq $0x10, (%rax)
movl $0x80, %edi
callq 0x2290
testq %rax, %rax
je 0x59b2
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x80, %edi
callq 0x2290
testq %rax, %rax
je 0x59b7
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x2494
callq 0x246f
callq 0x244a
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_del
void dict_del(dict* d) {
    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            free(d->syms[i]);
            maybe_delete(d, d->vals[i]);
        }
    }
    free(d->syms);
    free(d->vals);
    free(d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x59fb
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x59f0
callq 0x23f0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x59f0
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x59cb
movq 0x8(%rbx), %rdi
callq 0x23f0
movq 0x10(%rbx), %rdi
callq 0x23f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_index
int dict_index(const dict* d, const char* k) {
    int i = dict_findslot(d, k);
    if (!d->syms[i]) {
        i = -1;
    }
    return i;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5a38
movq 0x8(%rbx), %rcx
cltq
xorl %edx, %edx
cmpq $0x1, (%rcx,%rax,8)
sbbl %edx, %edx
orl %edx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_findslot
static int dict_findslot(const dict* d, const char* k) {
    unsigned int i = dict_hash(k) % d->size;
    unsigned int probe = 1;
    while (d->syms[i] && !streq(d->syms[i], k)) {
        i = (i + probe) % d->size;
        probe += DICT_PROBE_INTERVAL;
    }
    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %cl
testb %cl, %cl
je 0x5a6b
leaq 0x1(%rbx), %rdx
movl $0x1505, %eax           # imm = 0x1505
movl %eax, %esi
shll $0x5, %esi
addl %eax, %esi
movsbl %cl, %eax
xorl %esi, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x5a54
jmp 0x5a70
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
divl (%r14)
movl %edx, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x5ab3
movl $0x1, %ebp
movq %rbx, %rsi
callq 0x11b89
testb %al, %al
jne 0x5ab3
addl %ebp, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl (%r14)
incl %ebp
movq 0x8(%r14), %rax
movl %edx, %r15d
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
jne 0x5a8a
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_set
static void dict_set(dict* d, const char* k, void* v) {
    int i = dict_findslot(d, k);
    if (d->syms[i]) {
        v = maybe_copy(d, v);
        maybe_delete(d, d->vals[i]);
        d->vals[i] = v;
        return;
    }

    /* no existing entry found */
    d->count++;
    /* resize if needed */
    if (d->count / (float)d->size >= DICT_LOAD_FACTOR) {
        dict_resize(d);
        i = dict_findslot(d, k);
    }
    d->syms[i] = safe_malloc(strlen(k) + 1);
    strcpy(d->syms[i], k);
    d->vals[i] = maybe_copy(d, v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5a38
movq 0x8(%rbx), %r12
movslq %eax, %r14
cmpq $0x0, (%r12,%r14,8)
je 0x5b6a
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x5b4b
movq %rbp, %rdi
callq *%rax
movq %rax, %rbp
movq 0x20(%rbx), %rax
addq $0x10, %rbx
testq %rax, %rax
je 0x5ca8
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
jmp 0x5ca8
movl %eax, %r13d
movq %rbp, 0x10(%rsp)
movl 0x4(%rbx), %eax
incl %eax
movl %eax, 0x4(%rbx)
cvtsi2ss %eax, %xmm0
movslq (%rbx), %rbp
cvtsi2ss %ebp, %xmm1
divss %xmm1, %xmm0
ucomiss 0xca60(%rip), %xmm0     # 0x125f0
jb 0x5c5d
leal (,%rbp,2), %eax
movl %eax, 0xc(%rsp)
movl %eax, (%rbx)
movq 0x10(%rbx), %r13
movq %rbp, %r14
shlq $0x4, %r14
movq %r14, %rdi
callq 0x2290
testq %rax, %rax
je 0x5cc3
movq %rax, 0x8(%rbx)
testl %ebp, %ebp
jle 0x5bec
movl 0xc(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movq $0x0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5bd8
movq %r14, %rdi
callq 0x2290
testq %rax, %rax
je 0x5cc8
movq %rax, 0x10(%rbx)
testl %ebp, %ebp
jle 0x5c3f
xorl %r14d, %r14d
movq (%r12,%r14,8), %rsi
testq %rsi, %rsi
je 0x5c37
movq (%r13,%r14,8), %rdx
movq %rbx, %rdi
callq 0x5b10
movq (%r12,%r14,8), %rdi
callq 0x23f0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x5c37
movq (%r13,%r14,8), %rdi
callq *%rax
incq %r14
cmpq %r14, %rbp
jne 0x5c08
movq %r12, %rdi
callq 0x23f0
movq %r13, %rdi
callq 0x23f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a38
movl %eax, %r13d
movq %r15, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
testq %rax, %rax
je 0x5cbe
movq 0x8(%rbx), %rcx
movslq %r13d, %r14
movq %rax, (%rcx,%r14,8)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2080
movq 0x18(%rbx), %rax
testq %rax, %rax
movq 0x10(%rsp), %rbp
je 0x5ca4
movq %rbp, %rdi
callq *%rax
movq %rax, %rbp
addq $0x10, %rbx
movq (%rbx), %rax
movq %rbp, (%rax,%r14,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2503
callq 0x24de
callq 0x24b9
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_rm
void dict_rm(dict* d, const char* k) {
    int i = dict_findslot(d, k);
    if (d->syms[i]) {
        d->count--;
        maybe_delete(d, d->vals[i]);
        free(d->syms[i]);
        d->syms[i] = NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5a38
movq 0x8(%rbx), %rcx
movslq %eax, %r14
cmpq $0x0, (%rcx,%r14,8)
je 0x5d16
decl 0x4(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x5cfd
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x23f0
movq 0x8(%rbx), %rax
movq $0x0, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_copy
dict* dict_copy(const dict* d) {
    dict* n = safe_malloc(sizeof(dict));
    n->size = d->size;
    n->count = 0;
    n->copier = d->copier;
    n->deleter = d->deleter;
    n->syms = safe_malloc(sizeof(char*) * d->size);
    for (int i = 0; i < d->size; i++) {
        n->syms[i] = NULL;
    }
    n->vals = safe_malloc(sizeof(void*) * d->size);

    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            dict_set(n, d->syms[i], d->vals[i]);
        }
    }

    return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %edi
callq 0x2290
testq %rax, %rax
je 0x5dd7
movq %rax, %r14
movslq (%rbx), %r12
movl %r12d, (%rax)
movl $0x0, 0x4(%rax)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x2290
testq %rax, %rax
je 0x5ddc
movq %rax, 0x8(%r14)
testl %r12d, %r12d
jle 0x5d87
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2170
movq %r15, %rdi
callq 0x2290
testq %rax, %rax
je 0x5de1
movq %rax, 0x10(%r14)
cmpl $0x0, (%rbx)
jle 0x5dc8
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x5dbd
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
callq 0x5b10
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x5da0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2572
callq 0x254d
callq 0x2528
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_all_keys
char** dict_all_keys(const dict* d) {
    char** keys = safe_malloc(sizeof(char*) * d->count);
    int offset = 0;

    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            keys[offset++] = d->syms[i];
        }
    }
    return keys;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rdi), %rdi
shlq $0x3, %rdi
callq 0x2290
testq %rax, %rax
je 0x5e2c
movslq (%rbx), %rcx
testq %rcx, %rcx
jle 0x5e2a
movq 0x8(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
movq (%rdx,%rsi,8), %r8
testq %r8, %r8
je 0x5e22
movslq %edi, %r9
incl %edi
movq %r8, (%rax,%r9,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x5e10
popq %rbx
retq
callq 0x2597
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/dict.c
// Function: dict_all_vals
void** dict_all_vals(const dict* d) {
    void** vals = safe_malloc(sizeof(void*) * d->count);
    int offset = 0;

    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            vals[offset++] = d->vals[i];
        }
    }
    return vals;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rdi), %rdi
shlq $0x3, %rdi
callq 0x2290
testq %rax, %rax
je 0x5e79
movslq (%rbx), %rcx
testq %rcx, %rcx
jle 0x5e77
movq 0x8(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq $0x0, (%rdx,%rsi,8)
je 0x5e6f
movq 0x10(%rbx), %r8
movq (%r8,%rsi,8), %r8
movslq %edi, %r9
incl %edi
movq %r8, (%rax,%r9,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x5e57
popq %rbx
retq
callq 0x25bc
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/eval.c
// Function: awlval_eval_sexpr
awlval* awlval_eval_sexpr(awlenv* e, awlval* v) {
    if (v->count == 0) {
        awlval_del(v);
        return awlval_err("cannot evaluate empty %s", awlval_type_name(AWLVAL_SEXPR));
    }

    EVAL_SINGLE_ARG(e, v, 0);
    awlval* f = awlval_pop(v, 0);

    if (!ISCALLABLE(f->type)) {
        awlval* err = awlval_err("cannot evaluate %s; incorrect type for arg 0; got %s, expected callable",
                awlval_type_name(AWLVAL_SEXPR), awlval_type_name(f->type));
        awlval_del(v);
        awlval_del(f);
        return err;
    }

    awlval* result = awlval_call(e, f, v);
    awlval_del(f);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x4(%rsi)
je 0x6040
movq %rdi, %r15
xorl %edx, %edx
callq 0x61cd
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x603b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
movl (%rax), %eax
addl $-0x7, %eax
cmpl $0x3, %eax
jae 0x6068
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6280
movq %rax, %rbx
movq %r14, %rdi
callq 0x10767
movq %rbx, %rax
jmp 0x60a7
movq %rsi, %rdi
callq 0x10767
movl $0xb, %edi
callq 0x10138
leaq 0xc5e1(%rip), %rdi      # 0x1263a
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1032f
movl $0xb, %edi
callq 0x10138
movq %rax, %r15
movl (%r14), %edi
callq 0x10138
leaq 0xc5cf(%rip), %rdi      # 0x12653
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r15
movq %rbx, %rdi
callq 0x10767
movq %r14, %rdi
callq 0x10767
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/eval.c
// Function: awlval_eval_inside_qexpr
awlval* awlval_eval_inside_qexpr(awlenv* e, awlval* v) {
    switch (v->type) {
        case AWLVAL_SEXPR:
        case AWLVAL_QEXPR:
        {
            for (int i = 0; i < v->count; i++) {
                // Special case for C-Expressions
                if (v->cell[i]->type == AWLVAL_CEXPR) {
                    awlval* cexpr = awlval_eval_cexpr(e, awlval_pop(v, i));
                    if (cexpr->type == AWLVAL_ERR) {
                        awlval_del(v);
                        return cexpr;
                    }

                    // Populate current container with result of CExpr
                    if (cexpr->type == AWLVAL_QEXPR) {
                        v = awlval_shift(v, cexpr, i);
                    } else {
                        v = awlval_insert(v, cexpr, i);
                    }
                } else {
                    v->cell[i] = awlval_eval_inside_qexpr(e, v->cell[i]);
                    if (v->cell[i]->type == AWLVAL_ERR) {
                        return awlval_take(v, i);
                    }
                }
            }
            return v;
            break;
        }

        case AWLVAL_EEXPR:
        {
            return awlval_eval(e, awlval_take(v, 0));
            break;

        }

        default:
            return v;
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0xb(%rax), %ecx
cmpl $0x2, %ecx
jae 0x6177
cmpl $0x0, 0x4(%r14)
jle 0x619f
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
cmpl $0xe, (%rsi)
jne 0x611b
movq %r14, %rdi
movl %r15d, %esi
callq 0x10c23
movq %rax, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5e90
movq %rax, %r12
movl (%rax), %ebp
cmpl $0x2, %ebp
jne 0x613a
movq %r14, %rdi
callq 0x10767
jmp 0x615a
movq %rbx, %rdi
callq 0x60ad
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
cmpl $0x2, (%rax)
jne 0x6162
jmp 0x61b4
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
cmpl $0xc, %ebp
jne 0x614f
callq 0x10d6a
jmp 0x6154
callq 0x10d03
movq %rax, %r14
movq %r13, %r12
movq %r12, %r13
cmpl $0x2, %ebp
je 0x61a2
incq %r15
movslq 0x4(%r14), %rax
movq %r14, %r12
cmpq %rax, %r15
jl 0x60da
jmp 0x61a2
cmpl $0xd, %eax
jne 0x619f
movq %r14, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5e90
movq %r14, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10c7f
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/eval.c
// Function: awlval_eval_arg
awlval* awlval_eval_arg(awlenv* e, awlval* v, int arg) {
    v->cell[arg] = awlval_eval(e, v->cell[arg]);
    if (v->cell[arg]->type == AWLVAL_ERR) {
        return awlval_take(v, arg);
    }
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq 0x8(%rsi), %rax
movslq %edx, %r15
movq (%rax,%r15,8), %rsi
callq 0x5e90
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
cmpl $0x2, (%rax)
jne 0x620b
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x10c7f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/eval.c
// Function: awlval_eval_args
awlval* awlval_eval_args(awlenv* e, awlval* v) {
    for (int i = 0; i < v->count; i++) {
        v->cell[i] = awlval_eval(e, v->cell[i]);
    }

    for (int i = 0; i < v->count; i++) {
        if (v->cell[i]->type == AWLVAL_ERR) {
            return awlval_take(v, i);
        }
    }
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
testl %ecx, %ecx
jle 0x624d
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x5e90
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movslq 0x4(%rbx), %rcx
cmpq %rcx, %r15
jl 0x6229
testl %ecx, %ecx
jle 0x626a
movq 0x8(%rbx), %rax
movl %ecx, %ecx
xorl %esi, %esi
movq (%rax,%rsi,8), %rdx
cmpl $0x2, (%rdx)
je 0x6273
incq %rsi
cmpq %rsi, %rcx
jne 0x6259
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10c7f
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/eval.c
// Function: awlval_eval_macro
awlval* awlval_eval_macro(awlval* m) {
    awlenv* e = awlenv_copy(m->env);
    awlval* b = awlval_copy(m->body);

    awlval* v = awlval_eval(e, b);

    awlenv_del(e);

    if (v->type == AWLVAL_QEXPR) {
        v->type = AWLVAL_SEXPR;
    }
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1102d
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x10a5f
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e90
movq %rax, %rbx
movq %r14, %rdi
callq 0x107f6
cmpl $0xc, (%rbx)
jne 0x65c0
movl $0xb, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/linenoise.c
// Function: strclone
static char *strclone(const char *str) {
    size_t size = strlen(str) + 1;
    char *copy = malloc(size);
    if (copy == NULL) return NULL;

    memcpy(copy, str, size);
    return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x2290
testq %rax, %rax
je 0x6e6b
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2270
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/main.c
// Function: main
int main(int argc, char** argv) {
    setup_awl();
    awlenv* e = awlenv_new_top_level();

    /* if the only argument is the interpreter name, run repl */
    if (argc == 1) {
        run_repl(e);
    } else {
        run_scripts(e, argc, argv);
    }

    awlenv_del_top_level(e);
    teardown_awl();
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0x2cba
callq 0x113f5
movq %rax, %rbx
movq %rax, %rdi
cmpl $0x1, %ebp
jne 0x7d45
callq 0x1005a
jmp 0x7d4f
movl %ebp, %esi
movq %r14, %rdx
callq 0x2c4c
movq %rbx, %rdi
callq 0x118e8
callq 0x2cd4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_stack_pushp
static void mpc_stack_pushp(mpc_stack_t *s, mpc_parser_t *p) {
  s->parsers_num++;
  mpc_stack_parsers_reserve_more(s);
  s->parsers[s->parsers_num-1] = p;
  s->states[s->parsers_num-1] = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
leal 0x1(%rcx), %edx
movl %edx, (%rdi)
cmpl %eax, %ecx
jl 0x8dec
incl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x9ca1(%rip), %xmm0     # 0x12a58
callq 0x23a0
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x22e0
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movslq 0x4(%rbx), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
movslq (%rbx), %rcx
movq %r14, -0x8(%rax,%rcx,8)
movq 0x10(%rbx), %rax
movl $0x0, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popp
static void mpc_stack_popp(mpc_stack_t *s, mpc_parser_t **p, int *st) {
  *p = s->parsers[s->parsers_num-1];
  *st = s->states[s->parsers_num-1];
  s->parsers_num--;
  mpc_stack_parsers_reserve_less(s);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
movq -0x8(%rax,%rcx,8), %rax
movq %rax, (%rsi)
movq 0x10(%rdi), %rax
movl -0x4(%rax,%rcx,4), %eax
movl %eax, (%rdx)
movl (%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rdi)
cvtsi2sdl 0x4(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x9c0a(%rip), %xmm1     # 0x12a58
callq 0x20f0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8ea8
movl 0x4(%rbx), %eax
decl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x9bed(%rip), %xmm0     # 0x12a60
callq 0x2340
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x22e0
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movslq 0x4(%rbx), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_stack_pushr
static void mpc_stack_pushr(mpc_stack_t *s, mpc_result_t x, int r) {
  s->results_num++;
  mpc_stack_results_reserve_more(s);
  s->results[s->results_num-1] = x;
  s->returns[s->results_num-1] = r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x18(%rdi), %ecx
movl 0x1c(%rdi), %eax
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rdi)
cmpl %eax, %ecx
jl 0x8f0f
incl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x9b7f(%rip), %xmm0     # 0x12a58
callq 0x23a0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%r14)
movq 0x20(%r14), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x22e0
movq %rax, 0x20(%r14)
movq 0x28(%r14), %rdi
movslq 0x1c(%r14), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x28(%r14)
movq 0x20(%r14), %rax
movslq 0x18(%r14), %rcx
movq %r15, -0x8(%rax,%rcx,8)
movq 0x28(%r14), %rax
movslq 0x18(%r14), %rcx
movl %ebx, -0x4(%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_err_fail
static mpc_err_t *mpc_err_fail(const char *filename, mpc_state_t s, const char *failure) {
  mpc_err_t *x = malloc(sizeof(mpc_err_t));
  x->filename = malloc(strlen(filename) + 1);
  strcpy(x->filename, filename);
  x->state = s;
  x->expected_num = 0;
  x->expected = NULL;
  x->failure = malloc(strlen(failure) + 1);
  strcpy(x->failure, failure);
  x->recieved = ' ';
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl $0x30, %edi
callq 0x2290
movq %rax, %r14
movq %r12, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %r12, %rsi
callq 0x2080
movq %r15, (%r14)
movl %ebp, 0x8(%r14)
movl $0x0, 0xc(%r14)
movq $0x0, 0x20(%r14)
movq %rbx, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
movb $0x20, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_err_new
static mpc_err_t *mpc_err_new(const char *filename, mpc_state_t s, const char *expected, char recieved) {
  mpc_err_t *x = malloc(sizeof(mpc_err_t));
  x->filename = malloc(strlen(filename) + 1);
  strcpy(x->filename, filename);
  x->state = s;
  x->expected_num = 1;
  x->expected = malloc(sizeof(char*));
  x->expected[0] = malloc(strlen(expected) + 1);
  strcpy(x->expected[0], expected);
  x->failure = NULL;
  x->recieved = recieved;
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
movl $0x30, %edi
callq 0x2290
movq %rax, %r15
movq %r13, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x10(%r15)
movq %rax, %rdi
movq %r13, %rsi
callq 0x2080
movq %r12, (%r15)
movl %ebp, 0x8(%r15)
movl $0x1, 0xc(%r15)
movl $0x8, %edi
callq 0x2290
movq %rax, %r12
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2080
movq $0x0, 0x18(%r15)
movb %bl, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_input_peekc
static char mpc_input_peekc(mpc_input_t *i) {
  
  char c;
  
  switch (i->type) {
    case MPC_INPUT_STRING: return i->string[i->state.pos];
    case MPC_INPUT_FILE: 
      
      if (feof(i->file)) { return '\0'; }
      
      c = fgetc(i->file);
      fseek(i->file, -1, SEEK_CUR);
      break;
    
    case MPC_INPUT_PIPE:
      
      if (feof(i->file)) { return '\0'; }
      
      if (!i->buffer) { c = getc(i->file); ungetc(c, i->file); break; }
      
      if (i->buffer && mpc_input_buffer_in_range(i)) {
        return mpc_input_buffer_get(i);
      } else {
        c = getc(i->file); ungetc(c, i->file);
        break;
      }
      
  }
  
  return c;
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x9103
cmpl $0x1, %eax
je 0x90d4
testl %eax, %eax
jne 0x9112
movq 0x20(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb (%rax,%rcx), %bpl
jmp 0x9112
movq 0x30(%rbx), %rdi
callq 0x2240
testl %eax, %eax
jne 0x9110
movq 0x30(%rbx), %rdi
callq 0x2190
movl %eax, %ebp
movq 0x30(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x22d0
jmp 0x9112
movq 0x30(%rbx), %rdi
callq 0x2240
testl %eax, %eax
je 0x911f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x914c
movslq 0x10(%rbx), %r15
movq %r14, %rdi
callq 0x2110
movq 0x40(%rbx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
cmpq %r15, %rax
jbe 0x914c
subq %rcx, %r15
movb (%r14,%r15), %bpl
jmp 0x9112
movq 0x30(%rbx), %rdi
callq 0x23b0
movl %eax, %ebp
movsbl %bpl, %edi
movq 0x30(%rbx), %rsi
callq 0x22c0
jmp 0x9112
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popr
static int mpc_stack_popr(mpc_stack_t *s, mpc_result_t *x) {
  int r;
  *x = s->results[s->results_num-1];
  r = s->returns[s->results_num-1];
  s->results_num--;
  mpc_stack_results_reserve_less(s);
  return r;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movslq 0x18(%rdi), %rcx
movq -0x8(%rax,%rcx,8), %rax
movq %rax, (%rsi)
movq 0x28(%rdi), %rax
movslq 0x18(%rdi), %rcx
movl -0x4(%rax,%rcx,4), %ebp
leal -0x1(%rcx), %eax
movl %eax, 0x18(%rdi)
cvtsi2sdl 0x1c(%rdi), %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd 0x98b1(%rip), %xmm1     # 0x12a58
callq 0x20f0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9200
movl 0x1c(%rbx), %eax
decl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x9895(%rip), %xmm0     # 0x12a60
callq 0x2340
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rbx)
movq 0x20(%rbx), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x22e0
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rdi
movslq 0x1c(%rbx), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x28(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_input_mark
static void mpc_input_mark(mpc_input_t *i) {
  
  if (i->backtrack < 1) { return; }
  
  i->marks_num++;
  i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_num);
  i->lasts = realloc(i->lasts, sizeof(int) * i->marks_num);
  i->marks[i->marks_num-1] = i->state;
  i->lasts[i->marks_num-1] = i->last;
  
  if (i->type == MPC_INPUT_PIPE && i->marks_num == 1) {
    i->buffer = calloc(1, 1);
  }
  
}

// Assembly:
cmpl $0x0, 0x38(%rdi)
jle 0x929b
pushq %rbx
movq %rdi, %rbx
movslq 0x3c(%rdi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x3c(%rdi)
movq 0x40(%rdi), %rdi
leaq 0x4(,%rax,4), %rax
leaq (%rax,%rax,2), %rsi
callq 0x22e0
movq %rax, 0x40(%rbx)
movq 0x48(%rbx), %rdi
movslq 0x3c(%rbx), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x48(%rbx)
movq 0x40(%rbx), %rax
movslq 0x3c(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movl 0x18(%rbx), %edx
movl %edx, -0x4(%rax,%rcx,4)
movq 0x10(%rbx), %rdx
movq %rdx, -0xc(%rax,%rcx,4)
movsbl 0x50(%rbx), %eax
movq 0x48(%rbx), %rcx
movslq 0x3c(%rbx), %rdx
movl %eax, -0x4(%rcx,%rdx,4)
cmpl $0x2, (%rbx)
jne 0x929a
cmpl $0x1, 0x3c(%rbx)
jne 0x929a
movl $0x1, %edi
movl $0x1, %esi
callq 0x2200
movq %rax, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_input_unmark
static void mpc_input_unmark(mpc_input_t *i) {
  
  if (i->backtrack < 1) { return; }
  
  i->marks_num--;
  i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_num);
  i->lasts = realloc(i->lasts, sizeof(int) * i->marks_num);
  
  if (i->type == MPC_INPUT_PIPE && i->marks_num == 0) {
    free(i->buffer);
    i->buffer = NULL;
  }
  
}

// Assembly:
cmpl $0x0, 0x38(%rdi)
jle 0x9348
pushq %rbx
movq %rdi, %rbx
movslq 0x3c(%rdi), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0x3c(%rdi)
movq 0x40(%rdi), %rdi
leaq -0x4(,%rax,4), %rax
leaq (%rax,%rax,2), %rsi
callq 0x22e0
movq %rax, 0x40(%rbx)
movq 0x48(%rbx), %rdi
movslq 0x3c(%rbx), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x48(%rbx)
cmpl $0x2, (%rbx)
jne 0x9347
cmpl $0x0, 0x3c(%rbx)
jne 0x9347
movq 0x28(%rbx), %rdi
callq 0x23f0
movq $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_input_new_string
static mpc_input_t *mpc_input_new_string(const char *filename, const char *string) {

  mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
  i->filename = malloc(strlen(filename) + 1);
  strcpy(i->filename, filename);
  i->type = MPC_INPUT_STRING;
  
  i->state = mpc_state_new();
  
  i->string = malloc(strlen(string) + 1);
  strcpy(i->string, string);
  i->buffer = NULL;
  i->file = NULL;
  
  i->backtrack = 1;
  i->marks_num = 0;
  i->marks = NULL;
  i->lasts = NULL;

  i->last = -1;
  
  return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x58, %edi
callq 0x2290
movq %rax, %rbx
movq %r15, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2080
xorl %ebp, %ebp
movl %ebp, (%rbx)
movq $0x0, 0x10(%rbx)
movl %ebp, 0x18(%rbx)
movq %r14, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x20(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2080
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x1, 0x38(%rbx)
movups %xmm0, 0x3c(%rbx)
movl %ebp, 0x4c(%rbx)
movb $-0x1, 0x50(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_input_new_file
static mpc_input_t *mpc_input_new_file(const char *filename, FILE *file) {
  
  mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
  i->filename = malloc(strlen(filename) + 1);
  strcpy(i->filename, filename);
  i->type = MPC_INPUT_FILE;
  i->state = mpc_state_new();
  
  i->string = NULL;
  i->buffer = NULL;
  i->file = file;
  
  i->backtrack = 1;
  i->marks_num = 0;
  i->marks = NULL;
  i->lasts = NULL;
  
  i->last = -1;
  
  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x58, %edi
callq 0x2290
movq %rax, %r15
movq %r14, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2080
movl $0x1, %eax
movl %eax, (%r15)
movq $0x0, 0x10(%r15)
xorl %ecx, %ecx
movl %ecx, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq %rbx, 0x30(%r15)
movl %eax, 0x38(%r15)
movups %xmm0, 0x3c(%r15)
movl %ecx, 0x4c(%r15)
movb $-0x1, 0x50(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_input_new_pipe
static mpc_input_t *mpc_input_new_pipe(const char *filename, FILE *pipe) {

  mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
  i->filename = malloc(strlen(filename) + 1);
  strcpy(i->filename, filename);
  
  i->type = MPC_INPUT_PIPE;
  i->state = mpc_state_new();
  
  i->string = NULL;
  i->buffer = NULL;
  i->file = pipe;
  
  i->backtrack = 1;
  i->marks_num = 0;
  i->marks = NULL;
  i->lasts = NULL;
  
  i->last = -1;
  
  return i;
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x58, %edi
callq 0x2290
movq %rax, %r15
movq %r14, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2080
movl $0x2, (%r15)
movq $0x0, 0x10(%r15)
xorl %eax, %eax
movl %eax, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq %rbx, 0x30(%r15)
movl $0x1, 0x38(%r15)
movups %xmm0, 0x3c(%r15)
movl %eax, 0x4c(%r15)
movb $-0x1, 0x50(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_parse_contents
int mpc_parse_contents(const char *filename, mpc_parser_t *p, mpc_result_t *r) {
  
  FILE *f = fopen(filename, "rb");
  int res;
  
  if (f == NULL) {
    r->output = NULL;
    r->error = mpc_err_fail(filename, mpc_state_new(), "Unable to open file!");
    return 0;
  }
  
  res = mpc_parse_file(filename, f, p, r);
  fclose(f);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x94fd(%rip), %rsi      # 0x12b05
callq 0x2330
testq %rax, %rax
je 0x9647
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0x94d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x80cd
movl %eax, %ebx
movq %r12, %rdi
callq 0x9459
movq %r14, %rdi
callq 0x2100
movl %ebx, %eax
jmp 0x9666
movq $0x0, (%rbx)
leaq 0x94b3(%rip), %rcx      # 0x12b08
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8f2e
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_lift_val
mpc_parser_t *mpc_lift_val(mpc_val_t *x) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_LIFT_VAL;
  p->data.lift.x = x;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x4, 0x10(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_lift
mpc_parser_t *mpc_lift(mpc_ctor_t lf) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_LIFT;
  p->data.lift.lf = lf;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x3, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_char
mpc_parser_t *mpc_char(char c) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_SINGLE;
  p->data.single.x = c;
  return mpc_expectf(p, "'%c'", c);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0xb, 0x10(%rax)
movb %bl, 0x18(%rax)
leaq 0x8e4a(%rip), %rsi      # 0x12b6e
movq %rax, %rdi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
jmp 0x9bd5
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_range
mpc_parser_t *mpc_range(char s, char e) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_RANGE;
  p->data.range.x = s;
  p->data.range.y = e;
  return mpc_expectf(p, "character between '%c' and '%c'", s, e);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0xe, 0x10(%rax)
movb %bpl, 0x18(%rax)
movb %bl, 0x19(%rax)
leaq 0x8def(%rip), %rsi      # 0x12b53
movq %rax, %rdi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9bd5
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_noneof
mpc_parser_t *mpc_noneof(const char *s) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_NONEOF;
  p->data.string.x = malloc(strlen(s) + 1);
  strcpy(p->data.string.x, s);
  return mpc_expectf(p, "one of '%s'", s);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movq %rax, %r14
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0xd, 0x10(%rax)
movq %rbx, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
leaq 0x8d49(%rip), %rsi      # 0x12b73
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9bd5
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_satisfy
mpc_parser_t *mpc_satisfy(int(*f)(char)) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_SATISFY;
  p->data.satisfy.f = f;
  return mpc_expectf(p, "character satisfying function %p", f);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0xf, 0x10(%rax)
movq %rbx, 0x18(%rax)
leaq 0x8d14(%rip), %rsi      # 0x12b7f
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x9bd5
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_apply_to
mpc_parser_t *mpc_apply_to(mpc_parser_t *a, mpc_apply_to_t f, void *x) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_APPLY_TO;
  p->data.apply_to.x = a;
  p->data.apply_to.f = f;
  p->data.apply_to.d = x;
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_predictive
mpc_parser_t *mpc_predictive(mpc_parser_t *a) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_PREDICT;
  p->data.predict.x = a;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x13, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_not_lift
mpc_parser_t *mpc_not_lift(mpc_parser_t *a, mpc_dtor_t da, mpc_ctor_t lf) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_NOT;
  p->data.not.x = a;
  p->data.not.dx = da;
  p->data.not.lf = lf;
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x14, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_maybe_lift
mpc_parser_t *mpc_maybe_lift(mpc_parser_t *a, mpc_ctor_t lf) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_MAYBE;
  p->data.not.x = a;
  p->data.not.lf = lf;
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_many
mpc_parser_t *mpc_many(mpc_fold_t f, mpc_parser_t *a) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_MANY;
  p->data.repeat.x = a;
  p->data.repeat.f = f;
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x16, 0x10(%rax)
movq %rbx, 0x28(%rax)
movq %r14, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_many1
mpc_parser_t *mpc_many1(mpc_fold_t f, mpc_parser_t *a) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_MANY1;
  p->data.repeat.x = a;
  p->data.repeat.f = f;
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x17, 0x10(%rax)
movq %rbx, 0x28(%rax)
movq %r14, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpc_count
mpc_parser_t *mpc_count(int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_COUNT;
  p->data.repeat.n = n;
  p->data.repeat.f = f;
  p->data.repeat.x = a;
  p->data.repeat.dx = da;
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x18, 0x10(%rax)
movl %ebp, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/mpc.c
// Function: mpcf_strfold
mpc_val_t *mpcf_strfold(int n, mpc_val_t **xs) {
  char *x = calloc(1, 1);
  int i;
  for (i = 0; i < n; i++) {
    x = realloc(x, strlen(x) + strlen(xs[i]) + 1);
    strcat(x, xs[i]);
    free(xs[i]);
  }
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %edi
movl $0x1, %esi
callq 0x2200
movq %rax, %r14
testl %ebp, %ebp
jle 0xa4f2
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2110
movq %rax, %r15
movq (%rbx,%rbp,8), %r12
movq %r12, %rdi
callq 0x2110
leaq (%r15,%rax), %rsi
incq %rsi
movq %r14, %rdi
callq 0x22e0
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x2360
movq %r12, %rdi
callq 0x23f0
incq %rbp
cmpq %rbp, %r13
jne 0xa4ae
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/voithos[P]awl/src/mpc.c
// Function: mpcf_re_repeat
static mpc_val_t *mpcf_re_repeat(int n, mpc_val_t **xs) {
  
  int num;
  if (xs[1] == NULL) { return xs[0]; }
  if (strcmp(xs[1], "*") == 0) { free(xs[1]); return mpc_many(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "+") == 0) { free(xs[1]); return mpc_many1(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "?") == 0) { free(xs[1]); return mpc_maybe_lift(xs[0], mpcf_ctor_str); }
  num = *(int*)xs[1];
  free(xs[1]);
  
  return mpc_count(num, mpcf_strfold, xs[0], free);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0xb7c6
leaq 0x694f(%rip), %rsi      # 0x12090
movq %r14, %rdi
callq 0x2210
testl %eax, %eax
je 0xb7cb
leaq 0x693a(%rip), %rsi      # 0x1208e
movq %r14, %rdi
callq 0x2210
testl %eax, %eax
je 0xb7f6
leaq 0x6a8a(%rip), %rsi      # 0x121f5
movq %r14, %rdi
callq 0x2210
testl %eax, %eax
je 0xb833
movl (%r14), %ebp
movq %r14, %rdi
callq 0x23f0
movq 0xf823(%rip), %r14      # 0x1afb0
movq (%rbx), %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x18, 0x10(%rax)
movl %ebp, 0x18(%rax)
leaq -0x1335(%rip), %rcx     # 0xa483
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %r14, 0x30(%rax)
jmp 0xb82e
movq (%rbx), %rax
jmp 0xb82e
movq %r14, %rdi
callq 0x23f0
movq (%rbx), %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x16, 0x10(%rax)
jmp 0xb81f
movq %r14, %rdi
callq 0x23f0
movq (%rbx), %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x17, 0x10(%rax)
movq %rbx, 0x28(%rax)
leaq -0x13a7(%rip), %rcx     # 0xa483
movq %rcx, 0x20(%rax)
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x23f0
movq (%rbx), %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x2200
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x15, 0x10(%rax)
movq %rbx, 0x18(%rax)
leaq -0xcaf(%rip), %rcx      # 0xabb8
movq %rcx, 0x28(%rax)
jmp 0xb82e