LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/builtins.c
// Function: builtin_reverse
awlval* builtin_reverse(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "reverse");
    EVAL_ARGS(e, a);
    AWLASSERT_ISORDEREDCOLLECTION(a, 0, "reverse");

    awlval* collection = awlval_take(a, 0);

    return awlval_reverse(collection);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0x50c5
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x1504a(%rip), %rdi     # 0x1a0e2
leaq 0x151a9(%rip), %rsi     # 0x1a248
movl $0x1, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x517b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x50ec
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x517b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0xc, (%rax)
je 0x515f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
je 0x515f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x4, (%rax)
je 0x515f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x161a0
movq %rax, %rcx
leaq 0x15118(%rip), %rdi     # 0x1a250
leaq 0x15109(%rip), %rsi     # 0x1a248
xorl %edx, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x517b
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17560
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x17720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/builtins.c
// Function: builtin_if
awlval* builtin_if(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 3, "if");

    EVAL_SINGLE_ARG(e, a, 0);
    AWLASSERT_TYPE(a, 0, AWLVAL_BOOL, "if");

    awlval* x;
    /* does not eval result; sends it back to awlval_eval for
     * potential tail call optimization */
    if (a->cell[0]->bln) {
        x = awlval_pop(a, 1);
    } else {
        x = awlval_pop(a, 2);
    }

    awlval_del(a);
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, 0x4(%rax)
je 0x5695
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x14a7a(%rip), %rdi     # 0x1a0e2
leaq 0x14ca2(%rip), %rsi     # 0x1a311
movl $0x3, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x576b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x7be0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x56be
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x576b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x6, (%rax)
je 0x5723
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x161a0
movq %rax, -0x38(%rbp)
movl $0x6, %edi
callq 0x161a0
movq -0x38(%rbp), %rcx
movq %rax, %r8
leaq 0x14a2d(%rip), %rdi     # 0x1a129
leaq 0x14c0e(%rip), %rsi     # 0x1a311
xorl %edx, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x576b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
testb $0x1, 0x18(%rax)
je 0x5748
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x174b0
movq %rax, -0x30(%rbp)
jmp 0x575a
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x174b0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/builtins.c
// Function: builtin_lambda
awlval* builtin_lambda(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "fn");
    AWLASSERT_ISEXPR(a, 0, "fn");

    for (int i = 0; i < a->cell[0]->count; i++) {
        AWLASSERT(a, (a->cell[0]->cell[i]->type == AWLVAL_SYM),
                "function 'fn' cannot take non-symbol argument at position %i", i);
    }

    awlval* formals = awlval_pop(a, 0);
    awlval* body = awlval_take(a, 0);
    return awlval_lambda(e, formals, body);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x4(%rax)
je 0x6085
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x1408a(%rip), %rdi     # 0x1a0e2
leaq 0x143e9(%rip), %rsi     # 0x1a448
movl $0x2, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6189
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0xc, (%rax)
je 0x60eb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0xb, (%rax)
je 0x60eb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x161a0
movq %rax, %rcx
leaq 0x1438a(%rip), %rdi     # 0x1a44b
leaq 0x14380(%rip), %rsi     # 0x1a448
xorl %edx, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6189
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6156
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x3, (%rax)
je 0x6149
movl -0x2c(%rbp), %esi
leaq 0x14371(%rip), %rdi     # 0x1a49c
movb $0x0, %al
callq 0x16600
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6189
jmp 0x614b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x60f2
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x174b0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17560
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x169e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/builtins.c
// Function: builtin_typeof
awlval* builtin_typeof(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "typeof");
    EVAL_ARGS(e, a);

    awlval* arg = awlval_take(a, 0);
    awlval* res = awlval_qsym(awlval_type_sysname(arg->type));
    awlval_del(arg);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0x6462
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x13caa(%rip), %rdi     # 0x1a0e2
leaq 0x140d5(%rip), %rsi     # 0x1a514
movl $0x1, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x64bd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6486
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x64bd
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17560
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x162c0
movq %rax, %rdi
callq 0x16890
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x16cf0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x4(%rax)
je 0x6525
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x13bea(%rip), %rdi     # 0x1a0e2
leaq 0x1401c(%rip), %rsi     # 0x1a51b
movl $0x2, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x662f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x654c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x662f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x4, (%rax)
je 0x65b1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x161a0
movq %rax, -0x50(%rbp)
movl $0x4, %edi
callq 0x161a0
movq -0x50(%rbp), %rcx
movq %rax, %r8
leaq 0x13b9f(%rip), %rdi     # 0x1a129
leaq 0x13f8a(%rip), %rsi     # 0x1a51b
xorl %edx, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x662f
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x174b0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17560
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x163e0
movl %eax, -0x44(%rbp)
callq 0x2050
cmpl $0x16, (%rax)
je 0x65fb
movl -0x44(%rbp), %edi
movq -0x38(%rbp), %rsi
callq 0x17ca0
movq %rax, -0x40(%rbp)
jmp 0x6615
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x13f19(%rip), %rdi     # 0x1a523
movb $0x0, %al
callq 0x16600
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x16cf0
movq -0x38(%rbp), %rdi
callq 0x16cf0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/util.h
// Function: safe_malloc
static inline void* safe_malloc(size_t size) {
    char* p = malloc(size);
    if (p == NULL) {
        fprintf(stderr, "failed to allocate memory\n");
        exit(-1);
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2250
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6a42
movq 0x1b5d1(%rip), %rax     # 0x21ff8
movq (%rax), %rdi
leaq 0x13b78(%rip), %rsi     # 0x1a5a9
movb $0x0, %al
callq 0x21f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6a87
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6b1b
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6b09
cmpl $0x0, -0x1c(%rbp)
je 0x6aae
leaq 0x14d91(%rip), %rdi     # 0x1b838
movb $0x0, %al
callq 0x158b0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x5, (%rax)
jne 0x6ae7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rsi
leaq 0x13a53(%rip), %rdi     # 0x1a531
movb $0x0, %al
callq 0x158b0
jmp 0x6afc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x15a00
jmp 0x6afe
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6a8e
movq -0x18(%rbp), %rdi
callq 0x16cf0
callq 0x16c00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0x6c55
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x134ba(%rip), %rdi     # 0x1a0e2
leaq 0x13959(%rip), %rsi     # 0x1a588
movl $0x1, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d0c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6c7c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d0c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
je 0x6ce1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x161a0
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x161a0
movq -0x38(%rbp), %rcx
movq %rax, %r8
leaq 0x1346f(%rip), %rdi     # 0x1a129
leaq 0x138c7(%rip), %rsi     # 0x1a588
xorl %edx, %edx
movb $0x0, %al
callq 0x16600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d0c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
movb $0x0, %al
callq 0x16600
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6d90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x6e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x80, %edi
callq 0x6e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x6dfc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6dd7
movl $0x80, %edi
callq 0x6e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6efc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6eef
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23a0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6f30
jmp 0x6ef1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6ea3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23a0
movq -0x8(%rbp), %rdi
callq 0x23a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6fb0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6f9a
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x75e0
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl (%rcx)
movl %edx, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x19(%rbp)
je 0x7011
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x18d50
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x701a
jmp 0x7036
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl (%rcx)
movl %edx, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6fdb
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/dict.c
// Function: maybe_copy
static void* maybe_copy(const dict* d, void* v) {
    if (d->copier) {
        return d->copier(v);
    } else {
        return v;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x70af
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x70b7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/dict.c
// Function: dict_lookup
static void* dict_lookup(const dict* d, const char* k) {
    int i = dict_findslot(d, k);
    if (d->syms[i]) {
        return d->vals[i];
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6fb0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7119
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x7121
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6fb0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x720a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7080
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6f30
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x72b8
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl (%rax), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x13390(%rip), %xmm1    # 0x1a5c8
ucomisd %xmm1, %xmm0
jb 0x7257
movq -0x8(%rbp), %rdi
callq 0x7630
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6fb0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x6e40
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7080
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6fb0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7342
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6f30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x6e40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x6e40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x73ed
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x73c3
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x6e40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x7463
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7456
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x7190
jmp 0x7458
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x740f
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
shlq $0x3, %rdi
callq 0x6e40
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x7510
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7503
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x7505
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x74bf
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
shlq $0x3, %rdi
callq 0x6e40
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x75a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7593
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x7595
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x754f
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/dict.c
// Function: dict_equal
bool dict_equal(const dict* d1, const dict* d2) {
    if (d1->count != d2->count) {
        return false;
    }
    /* TODO: Check keys/values, but order doesn't matter! */
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x75d2
movb $0x0, -0x1(%rbp)
jmp 0x75d6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/dict.c
// Function: dict_hash
static unsigned int dict_hash(const char* str) {
    /* djb2 hash */
    unsigned int hash = 5381;
    for (int i = 0; str[i]; i++) {
        /* XOR hash * 33 with current char val */
        hash = ((hash << 5) + hash) ^ str[i];
    }
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0xc(%rbp)     # imm = 0x1505
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x7629
movl -0xc(%rbp), %eax
shll $0x5, %eax
addl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x75f6
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/dict.c
// Function: dict_resize
static void dict_resize(dict* d) {
    int oldsize = d->size;
    d->size = d->size * DICT_GROWTH_FACTOR;

    char** syms = d->syms;
    void** vals = d->vals;

    d->syms = safe_malloc(sizeof(char*) * d->size);
    for (int i = 0; i < d->size; i++) {
        d->syms[i] = NULL;
    }
    d->vals = safe_malloc(sizeof(void*) * d->size);

    for (int i = 0; i < oldsize; i++) {
        if (syms[i]) {
            dict_set(d, syms[i], vals[i]);

            free(syms[i]);
            maybe_delete(d, vals[i]);
        }
    }
    free(syms);
    free(vals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x6e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x76b7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x768d
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x6e40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7744
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7737
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x7190
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6f30
jmp 0x7739
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x76d9
movq -0x18(%rbp), %rdi
callq 0x23a0
movq -0x20(%rbp), %rdi
callq 0x23a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7987
movq -0x18(%rbp), %rdi
callq 0x16cf0
movl $0xb, %edi
callq 0x161a0
movq %rax, %rsi
leaq 0x12ccf(%rip), %rdi     # 0x1a646
movb $0x0, %al
callq 0x16600
movq %rax, -0x8(%rbp)
jmp 0x7a4e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x7be0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x79b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7a4e
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x174b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
je 0x7a28
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
je 0x7a28
movq -0x20(%rbp), %rax
cmpl $0x9, (%rax)
je 0x7a28
movl $0xb, %edi
callq 0x161a0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x161a0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x12c5e(%rip), %rdi     # 0x1a65f
movb $0x0, %al
callq 0x16600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16cf0
movq -0x20(%rbp), %rdi
callq 0x16cf0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7a4e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7d20
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x16cf0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7770
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x2, (%rax)
jne 0x7c46
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x17560
movq %rax, -0x8(%rbp)
jmp 0x7c4e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x7cba
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7770
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c77
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x7d01
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x2, (%rax)
jne 0x7cf4
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x17560
movq %rax, -0x8(%rbp)
jmp 0x7d09
jmp 0x7cf6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7cc1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x17c20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x171d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7770
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16e00
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x815b
movq -0x20(%rbp), %rax
movl $0xb, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/eval.c
// Function: awlval_eval_cexpr
awlval* awlval_eval_cexpr(awlenv* e, awlval* v) {
    awlval* res = awlval_eval(e, awlval_take(v, 0));
    if (res->type == AWLVAL_ERR) {
        return res;
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17560
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x7770
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x81b6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x81be
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2250
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x873b
movq $0x0, -0x8(%rbp)
jmp 0x8754
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2230
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2530
callq 0x18360
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0xa355
movq -0x18(%rbp), %rdi
callq 0x160b0
jmp 0xa365
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x24a0
movq -0x18(%rbp), %rdi
callq 0x188a0
callq 0x2550
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_new
static mpc_stack_t *mpc_stack_new(const char *filename) {
  mpc_stack_t *s = malloc(sizeof(mpc_stack_t));
  
  s->parsers_num = 0;
  s->parsers_slots = 0;
  s->parsers = NULL;
  s->states = NULL;
  
  s->results_num = 0;
  s->results_slots = 0;
  s->results = NULL;
  s->returns = NULL;
  
  s->err = mpc_err_fail(filename, mpc_state_invalid(), "Unknown Error");
  
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x2250
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x134d0
movq -0x48(%rbp), %rdi
movl %edx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movl -0x38(%rbp), %edx
leaq 0xeea4(%rip), %rcx      # 0x1b14b
callq 0xc4f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x13500
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x135a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x13660
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl $0x30, %edi
callq 0x2250
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2070
movq -0x38(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x30(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x2070
movq -0x38(%rbp), %rax
movb $0x20, 0x28(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_string
static int mpc_input_string(mpc_input_t *i, const char *c, char **o) {
  
  char *co = NULL;
  const char *x = c;

  mpc_input_mark(i);
  while (*x) {
    if (mpc_input_char(i, *x, &co)) {
      free(co);
    } else {
      mpc_input_rewind(i);
      return 0;
    }
    x++;
  }
  mpc_input_unmark(i);
  
  *o = malloc(strlen(c) + 1);
  strcpy(*o, c);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xce30
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc99a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
leaq -0x28(%rbp), %rdx
movsbl (%rax), %esi
callq 0xc670
cmpl $0x0, %eax
je 0xc97a
movq -0x28(%rbp), %rdi
callq 0x23a0
jmp 0xc98c
movq -0x10(%rbp), %rdi
callq 0xcf20
movl $0x0, -0x4(%rbp)
jmp 0xc9d9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc94d
movq -0x10(%rbp), %rdi
callq 0xcfc0
movq -0x18(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2070
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_boundary
static int mpc_input_boundary(mpc_input_t* i) {
  
  char* word = "abcdefghijklmnopqrstuvwxyz"
               "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	       "0123456789_";
	       
  char peek = mpc_input_peekc(i);
  if (strchr(word, i->last) && peek == '\0') { return 1; }
  if (strchr(word, peek) && !strchr(word, i->last)) { return 1; }
  if (!strchr(word, peek) && strchr(word, i->last)) { return 1; }
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xe706(%rip), %rax      # 0x1b159
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcc10
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x50(%rax), %esi
callq 0x2100
cmpq $0x0, %rax
je 0xca8c
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0xca8c
movl $0x1, -0x4(%rbp)
jmp 0xcaf9
movq -0x18(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x2100
cmpq $0x0, %rax
je 0xcabf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x50(%rax), %esi
callq 0x2100
cmpq $0x0, %rax
jne 0xcabf
movl $0x1, -0x4(%rbp)
jmp 0xcaf9
movq -0x18(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x2100
cmpq $0x0, %rax
jne 0xcaf2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x50(%rax), %esi
callq 0x2100
cmpq $0x0, %rax
je 0xcaf2
movl $0x1, -0x4(%rbp)
jmp 0xcaf9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)