LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_parse_sysname
awlval_type_t awlval_parse_sysname(const char* sysname) {
    /* Ordering reflects most common types first */
    if (streq(sysname, "int")) {
        return AWLVAL_INT;
    } else if (streq(sysname, "float")) {
        return AWLVAL_FLOAT;
    } else if (streq(sysname, "str")) {
        return AWLVAL_STR;
    } else if (streq(sysname, "bool")) {
        return AWLVAL_BOOL;
    } else if (streq(sysname, "qsym")) {
        return AWLVAL_QSYM;
    } else if (streq(sysname, "qexpr")) {
        return AWLVAL_QEXPR;
    } else if (streq(sysname, "err")) {
        return AWLVAL_ERR;
    } else if (streq(sysname, "builtin")) {
        return AWLVAL_BUILTIN;
    } else if (streq(sysname, "fn")) {
        return AWLVAL_FN;
    } else if (streq(sysname, "macro")) {
        return AWLVAL_MACRO;
    } else if (streq(sysname, "sym")) {
        return AWLVAL_SYM;
    } else if (streq(sysname, "dict")) {
        return AWLVAL_DICT;
    } else if (streq(sysname, "sexpr")) {
        return AWLVAL_SEXPR;
    } else if (streq(sysname, "eexpr")) {
        return AWLVAL_EEXPR;
    } else if (streq(sysname, "cexpr")) {
        return AWLVAL_CEXPR;
    } else {
        errno = EINVAL;
        return 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x360c(%rip), %rsi      # 0x10fd2
callq 0xf0d6
xorl %ebx, %ebx
testb %al, %al
jne 0xdb2e
leaq 0x3367(%rip), %rsi      # 0x10d43
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xd9ef
pushq $0x1
jmp 0xdb2d
leaq 0x3e2f(%rip), %rsi      # 0x11825
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xda09
pushq $0x5
jmp 0xdb2d
leaq 0x35c6(%rip), %rsi      # 0x10fd6
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xda23
pushq $0x6
jmp 0xdb2d
leaq 0x3df6(%rip), %rsi      # 0x11820
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xda3d
pushq $0x4
jmp 0xdb2d
leaq 0x35ad(%rip), %rsi      # 0x10ff1
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xda57
pushq $0xc
jmp 0xdb2d
leaq 0x3db6(%rip), %rsi      # 0x11814
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xda71
pushq $0x2
jmp 0xdb2d
leaq 0x3da0(%rip), %rsi      # 0x11818
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xda8b
pushq $0x7
jmp 0xdb2d
leaq 0x29ce(%rip), %rsi      # 0x10460
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xdaa5
pushq $0x8
jmp 0xdb2d
leaq 0x2a45(%rip), %rsi      # 0x104f1
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xdabc
pushq $0x9
jmp 0xdb2d
leaq 0x3d5e(%rip), %rsi      # 0x11821
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xdad3
pushq $0x3
jmp 0xdb2d
leaq 0x351d(%rip), %rsi      # 0x10ff7
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xdaea
pushq $0xa
jmp 0xdb2d
leaq 0x34fa(%rip), %rsi      # 0x10feb
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xdb01
pushq $0xb
jmp 0xdb2d
leaq 0x34f4(%rip), %rsi      # 0x10ffc
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xdb18
pushq $0xd
jmp 0xdb2d
leaq 0x34e3(%rip), %rsi      # 0x11002
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0xdb38
pushq $0xe
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2060
movl $0x16, (%rax)
jmp 0xdb2e
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_err
awlval* awlval_err(const char* fmt, ...) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_ERR;

    va_list va;
    va_start(va, fmt);

    v->err = safe_malloc(512);
    vsnprintf(v->err, 512, fmt, va);

    unsigned int l = strlen(v->err) + 1;
    v->err = realloc(v->err, l);
    v->err[l - 1] = '\0';

    va_end(va);

    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0xdbaf
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
pushq $0x38
popq %rdi
callq 0xdc33
movq %rax, %rbx
movl $0x2, (%rax)
movq %rsp, %r15
movq %r12, 0x10(%r15)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movl $0x200, %edi            # imm = 0x200
callq 0xdc33
movq %rax, %r12
movl $0x200, %esi            # imm = 0x200
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x20c0
movq %r12, %rdi
callq 0x2110
movq %rax, %r14
leal 0x1(%rax), %esi
movq %r12, %rdi
callq 0x22e0
movq %rax, 0x18(%rbx)
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_int
awlval* awlval_int(long x) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_INT;
    v->lng = x;
    return v;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0xdc33
andl $0x0, (%rax)
movq %rbx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_float
awlval* awlval_float(double x) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_FLOAT;
    v->dbl = x;
    return v;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
pushq $0x38
popq %rdi
callq 0xdc33
movl $0x1, (%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_sym_base
static awlval* awlval_sym_base(const char* s) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->length = strlen(s);
    v->sym = safe_malloc(strlen(s) + 1);
    strcpy(v->sym, s);
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0xdc33
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movl %eax, 0x10(%r14)
leaq 0x1(%rax), %rdi
callq 0xdc33
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_str
awlval* awlval_str(const char* s) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_STR;
    v->length = strlen(s);
    v->str = safe_malloc(v->length + 1);
    strcpy(v->str, s);
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0xdc33
movq %rax, %r14
movl $0x5, (%rax)
movq %rbx, %rdi
callq 0x2110
movl %eax, 0x10(%r14)
incl %eax
movslq %eax, %rdi
callq 0xdc33
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_bool
awlval* awlval_bool(bool b) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_BOOL;
    v->bln = b;
    return v;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x38
popq %rdi
callq 0xdc33
movl $0x6, (%rax)
movb %bl, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_fun
awlval* awlval_fun(const awlbuiltin builtin, const char* builtin_name) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_BUILTIN;
    v->builtin = builtin;
    v->builtin_name = safe_malloc(strlen(builtin_name) + 1);
    strcpy(v->builtin_name, builtin_name);
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0xdc33
movq %rax, %r15
movl $0x7, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0xdc33
movq %rax, 0x20(%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_lambda
awlval* awlval_lambda(awlenv* closure, awlval* formals, awlval* body) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_FN;
    v->env = awlenv_new();
    v->env->parent = closure;
    v->env->parent->references++;
    v->formals = formals;
    v->body = body;
    v->called = false;
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x38
popq %rdi
callq 0xdc33
movq %rax, %r12
movl $0x8, (%rax)
callq 0xddef
movq %rax, 0x18(%r12)
movq %r15, (%rax)
incl 0x14(%r15)
movq %r14, 0x20(%r12)
movq %rbx, 0x28(%r12)
movb $0x0, 0x30(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlenv_new
awlenv* awlenv_new(void) {
    awlenv* e = safe_malloc(sizeof(awlenv));
    e->parent = NULL;
    e->internal_dict = dict_new(awlval_copy_proxy, awlval_del_proxy);
    e->top_level = false;
    e->references = 1;
    return e;
}

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq 0xdc33
movq %rax, %rbx
andq $0x0, (%rax)
leaq 0x61(%rip), %rdi        # 0xde67
leaq 0x5f(%rip), %rsi        # 0xde6c
callq 0x4de8
movq %rax, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl $0x1, 0x14(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_dict
awlval* awlval_dict(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_DICT;
    v->count = 0;
    v->length = 0;
    v->d = dict_new(awlval_copy_proxy, awlval_del_proxy);
    return v;
}

// Assembly:
pushq %rbx
pushq $0x38
popq %rdi
callq 0xdc33
movq %rax, %rbx
movq $0xa, (%rax)
andl $0x0, 0x10(%rax)
leaq 0x15(%rip), %rdi        # 0xde67
leaq 0x13(%rip), %rsi        # 0xde6c
callq 0x4de8
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_sexpr
awlval* awlval_sexpr(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_SEXPR;
    v->count = 0;
    v->length = 0;
    v->cell = NULL;
    return v;
}

// Assembly:
pushq %rax
pushq $0x38
popq %rdi
callq 0xdc33
movl $0xb, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_qexpr
awlval* awlval_qexpr(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_QEXPR;
    v->count = 0;
    v->length = 0;
    v->cell = NULL;
    return v;
}

// Assembly:
pushq %rax
pushq $0x38
popq %rdi
callq 0xdc33
movl $0xc, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_eexpr
awlval* awlval_eexpr(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_EEXPR;
    v->count = 0;
    v->length = 0;
    v->cell = NULL;
    return v;
}

// Assembly:
pushq %rax
pushq $0x38
popq %rdi
callq 0xdc33
movl $0xd, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_cexpr
awlval* awlval_cexpr(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_CEXPR;
    v->count = 0;
    v->length = 0;
    v->cell = NULL;
    return v;
}

// Assembly:
pushq %rax
pushq $0x38
popq %rdi
callq 0xdc33
movl $0xe, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlenv_del
void awlenv_del(awlenv* e) {
    e->references--;

    if (e->references <= 0 && !e->top_level) {
        if (e->parent && e->parent->references >= 1) {
            awlenv_del(e->parent);
        }

        dict_del(e->internal_dict);
        free(e);
    }
}

// Assembly:
pushq %rbx
movl 0x14(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x14(%rdi)
cmpl $0x1, %eax
jg 0xdf6e
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
je 0xdf70
popq %rbx
retq
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xdf83
cmpl $0x0, 0x14(%rdi)
jle 0xdf83
callq 0xdf56
movq 0x8(%rbx), %rdi
callq 0x4e85
movq %rbx, %rdi
popq %rbx
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_keys_dict
awlval* awlval_keys_dict(awlval* x) {
    int count = dict_count(x->d);
    char** keys = dict_all_keys(x->d);

    awlval* v = awlval_qexpr();
    for (int i = 0; i < count; i++) {
        awlval_add(v, awlval_qsym(keys[i]));
    }

    free(keys);
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0x5218
movl %eax, %ebx
movq 0x18(%r14), %rdi
callq 0x521c
movq %rax, %r14
callq 0xde89
movq %rax, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
cmpq %r12, %rbx
je 0xe0ee
movq (%r14,%r12,8), %rdi
callq 0xdce8
movq %r15, %rdi
movq %rax, %rsi
callq 0xdf95
incq %r12
jmp 0xe0d0
movq %r14, %rdi
callq 0x23f0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_vals_dict
awlval* awlval_vals_dict(awlval* x) {
    int count = dict_count(x->d);
    awlval** vals = (awlval**)dict_all_vals(x->d);

    awlval* v = awlval_qexpr();
    for (int i = 0; i < count; i++) {
        awlval_add(v, awlval_copy(vals[i]));
    }

    free(vals);
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0x5218
movl %eax, %ebx
movq 0x18(%r14), %rdi
callq 0x5256
movq %rax, %r14
callq 0xde89
movq %rax, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
cmpq %r12, %rbx
je 0xe156
movq (%r14,%r12,8), %rdi
callq 0xe16d
movq %r15, %rdi
movq %rax, %rsi
callq 0xdf95
incq %r12
jmp 0xe138
movq %r14, %rdi
callq 0x23f0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_join
awlval* awlval_join(awlval* x, awlval* y) {
    while (y->count) {
        x = awlval_add(x, awlval_pop(y, 0));
    }

    awlval_del(y);
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4(%r14)
je 0xe365
movq %r14, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rbx, %rdi
movq %rax, %rsi
callq 0xdf95
jmp 0xe347
movq %r14, %rdi
callq 0xded1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_shift
awlval* awlval_shift(awlval* x, awlval* y, int i) {
    while (y->count) {
        x = awlval_insert(x, awlval_pop(y, y->count - 1), i);
    }

    awlval_del(y);
    return x;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%r14), %esi
testl %esi, %esi
je 0xe40c
decl %esi
movq %r14, %rdi
callq 0xe2bf
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0xe378
jmp 0xe3eb
movq %r14, %rdi
callq 0xded1
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_reverse
awlval* awlval_reverse(awlval* x) {
    if (x->type == AWLVAL_QEXPR) {
        return awlval_reverse_qexpr(x);
    } else if (x->type == AWLVAL_STR) {
        return awlval_reverse_str(x);
    } else {
        return awlval_reverse_qsym(x);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0xe455
cmpl $0xc, %eax
jne 0xe455
callq 0xde89
movq %rax, %r14
movl 0x4(%rbx), %esi
testl %esi, %esi
je 0xe473
decl %esi
movq %rbx, %rdi
callq 0xe2bf
movq %r14, %rdi
movq %rax, %rsi
callq 0xdf95
jmp 0xe437
movq 0x18(%rbx), %rdi
callq 0xf0e3
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x23f0
movq %r14, 0x18(%rbx)
movq %rbx, %r14
jmp 0xe47b
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_slice_step
awlval* awlval_slice_step(awlval* x, int start, int end, int step) {
    if (x->type == AWLVAL_QEXPR) {
        return awlval_slice_step_qexpr(x, start, end, step);
    } else if (x->type == AWLVAL_STR) {
        return awlval_slice_step_str(x, start, end, step);
    } else {
        return awlval_slice_step_qsym(x, start, end, step);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0xe4c2
cmpl $0xc, %eax
jne 0xe4c2
movl %r15d, %r12d
subl $0x1, %r12d
jb 0xe510
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %rdi
callq 0xded1
jmp 0xe4a8
movq 0x18(%rbx), %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0xf131
movq %rax, %r14
cmpl $0x2, %ebp
jl 0xe4f7
cmpb $0x0, (%r14)
je 0xe4f7
movq %r14, %rdi
movl %ebp, %esi
callq 0xf176
movq %rax, %r15
movq %r14, %rdi
callq 0x23f0
movq %r15, %r14
movq 0x18(%rbx), %rdi
callq 0x23f0
movq %r14, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
subl %r15d, %r14d
movl 0x4(%rbx), %ecx
cmpl %ecx, %r14d
jge 0xe530
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe2bf
movq %rax, %rdi
callq 0xded1
jmp 0xe513
cmpl $0x2, %ebp
setl %al
testl %ecx, %ecx
sete %dl
orb %al, %dl
jne 0xe504
movl %ecx, %eax
cltd
idivl %ebp
movl %eax, %r14d
cmpl $0x1, %edx
sbbl $-0x1, %r14d
decl %ebp
pushq $0x1
popq %r15
cmpl %r14d, %ecx
jle 0xe504
movl %ebp, %r12d
subl $0x1, %r12d
jb 0xe577
movq %rbx, %rdi
movl %r15d, %esi
callq 0xe2bf
movq %rax, %rdi
callq 0xded1
jmp 0xe55c
movl 0x4(%rbx), %ecx
incl %r15d
jmp 0xe554
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_maybe_promote_numeric
void awlval_maybe_promote_numeric(awlval* a, awlval* b) {
    if (!(ISNUMERIC(a->type) && ISNUMERIC(b->type))) {
        return;
    }
    if (a->type == AWLVAL_FLOAT || b->type == AWLVAL_FLOAT) {
        awlval_promote_numeric(a);
        awlval_promote_numeric(b);
    }
}

// Assembly:
movl (%rdi), %ecx
cmpl $0x1, %ecx
ja 0xe5c8
movl (%rsi), %eax
cmpl $0x1, %eax
ja 0xe5c8
cmpl $0x1, %ecx
je 0xe5b2
cmpl $0x1, %eax
jne 0xe5c8
movl $0x1, (%rdi)
cvtsi2sdq 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdi)
movl (%rsi), %eax
cmpl $0x1, %eax
je 0xe5c8
movl $0x1, (%rsi)
cvtsi2sdq 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlenv_copy
awlenv* awlenv_copy(awlenv* e) {
    awlenv* n = safe_malloc(sizeof(awlenv));
    n->parent = e->parent;
    if (n->parent) {
        n->parent->references++;
    }
    n->internal_dict = dict_copy(e->internal_dict);
    n->top_level = e->top_level;
    n->references = 1;

    return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0xdc33
movq %rax, %r14
movq (%rbx), %rax
movq %rax, (%r14)
testq %rax, %rax
je 0xe613
incl 0x14(%rax)
movq 0x8(%rbx), %rdi
callq 0x5186
movq %rax, 0x8(%r14)
movb 0x10(%rbx), %al
movb %al, 0x10(%r14)
movl $0x1, 0x14(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlval_eq
bool awlval_eq(awlval* x, awlval* y) {
    awlval_maybe_promote_numeric(x, y);
    if (x->type != y->type) {
        return false;
    }

    switch (x->type) {
        case AWLVAL_BUILTIN:
            return y->type == AWLVAL_BUILTIN && x->builtin == y->builtin;
            break;

        case AWLVAL_FN:
        case AWLVAL_MACRO:
            return y->type == x->type && awlval_eq(x->formals, y->formals) && awlval_eq(x->body, y->body);
            break;

        case AWLVAL_INT:
            return x->lng == y->lng;
            break;

        case AWLVAL_FLOAT:
            return x->dbl == y->dbl;
            break;

        case AWLVAL_ERR:
            return streq(x->err, y->err);
            break;

        case AWLVAL_SYM:
        case AWLVAL_QSYM:
            return x->length == y->length && streq(x->sym, y->sym);
            break;

        case AWLVAL_STR:
            return x->length == y->length && streq(x->str, y->str);
            break;

        case AWLVAL_BOOL:
            return x->bln == y->bln;
            break;

        case AWLVAL_DICT:
            return dict_equal(x->d, y->d);
            break;

        case AWLVAL_SEXPR:
        case AWLVAL_QEXPR:
        case AWLVAL_EEXPR:
        case AWLVAL_CEXPR:
            if (x->count != y->count) {
                return false;
            }
            for (int i = 0; i < x->count; i++) {
                if (!awlval_eq(x->cell[i], y->cell[i])) {
                    return false;
                }
            }
            return true;
            break;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2e60(%rip), %r15      # 0x116dc
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe587
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0xe91d
cmpl $0xe, %eax
ja 0xe91d
movl %eax, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0xe867
testb %al, %al
je 0xe91d
movq 0x28(%r14), %r14
movq 0x28(%rbx), %rbx
jmp 0xe87c
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
jne 0xe91d
xorl %r12d, %r12d
movslq 0x4(%r14), %rax
cmpq %rax, %r12
setge %r15b
jge 0xe966
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rsi
callq 0xe867
incq %r12
testb %al, %al
jne 0xe8cd
jmp 0xe966
movl 0x10(%r14), %eax
cmpl 0x10(%rbx), %eax
jne 0xe91d
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf0d6
xorl %r15d, %r15d
jmp 0xe966
movq 0x18(%r14), %rax
cmpq 0x18(%rbx), %rax
jmp 0xe962
movsd 0x18(%rbx), %xmm0
cmpeqsd 0x18(%r14), %xmm0
movq %xmm0, %r15
andl $0x1, %r15d
jmp 0xe966
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5296
movb 0x18(%r14), %al
cmpb 0x18(%rbx), %al
sete %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlenv_new_top_level
awlenv* awlenv_new_top_level(void) {
    awlenv* e = awlenv_new();
    e->top_level = true;
    awlenv_add_builtins(e);
    awlenv_add_core_lib(e);
    return e;
}

// Assembly:
pushq %rbx
callq 0xddef
movq %rax, %rbx
movb $0x1, 0x10(%rax)
movq %rax, %rdi
callq 0xe9a7
movq %rbx, %rdi
callq 0xeddf
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlenv_add_core_lib
void awlenv_add_core_lib(awlenv* e) {
    char* awl_base = get_base_path();

    char* corelib = path_join(awl_base, "lib/core");

    awlval* args = awlval_sexpr();
    args = awlval_add(args, awlval_str(corelib));
    awlval_del(builtin_import(e, args));

    free(awl_base);
    free(corelib);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xf20c
movq %rax, %rbx
leaq 0x2ab8(%rip), %rsi      # 0x118b1
movq %rax, %rdi
callq 0xf245
movq %rax, %r15
callq 0xde71
movq %rax, %r12
movq %r15, %rdi
callq 0xdcf6
movq %r12, %rdi
movq %rax, %rsi
callq 0xdf95
movq %r14, %rdi
movq %r12, %rsi
callq 0x4991
movq %rax, %rdi
callq 0xded1
movq %rbx, %rdi
callq 0x23f0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/types.c
// Function: awlenv_add_builtin
void awlenv_add_builtin(awlenv* e, char* name, awlbuiltin builtin) {
    awlval* k = awlval_sym(name);
    awlval* v = awlval_fun(builtin, name);
    awlenv_put(e, k, v);
    awlval_del(k);
    awlval_del(v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xdc99
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdd54
movq %rax, %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xeeb8
movq %r12, %rdi
callq 0xded1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xded1
nop
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.c
// Function: stringbuilder_new
stringbuilder_t* stringbuilder_new(void) {
    stringbuilder_t* sb = safe_malloc(sizeof(stringbuilder_t));
    sb->length = 0;
    sb->size = SB_START_SIZE;
    sb->str = safe_malloc(SB_START_SIZE);
    return sb;
}

// Assembly:
pushq %rbx
pushq $0x10
popq %rdi
callq 0xef58
movq %rax, %rbx
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, (%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0xef58
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.c
// Function: stringbuilder_write
void stringbuilder_write(stringbuilder_t* sb, const char* format, ...) {
    va_list arguments1;
    va_list arguments2;
    va_start(arguments1, format);
    va_copy(arguments2, arguments1);

    /* First use vsnprintf to check how large the printed result would be */
    int count = vsnprintf(NULL, 0, format, arguments1);

    /* If there isn't enough room, keep resizing until there is */
    int required_size = sb->length + count + 1;
    while (sb->size < required_size) {
        stringbuilder_resize(sb);
    }

    vsnprintf((sb->str + sb->length), count + 1, format, arguments2);
    sb->length += count;

    va_end(arguments1);
    va_end(arguments2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xeff4
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x10(%rsp)
movq (%rcx), %rax
movq %rax, (%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20c0
movl %eax, %ebp
movl (%rbx), %r12d
addl %eax, %r12d
movslq 0x4(%rbx), %rdi
cmpl %r12d, %edi
jg 0xf073
addq %rdi, %rdi
movl %edi, 0x4(%rbx)
movq 0x8(%rbx), %r15
callq 0xef58
movq %rax, 0x8(%rbx)
movslq (%rbx), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2270
movq %r15, %rdi
callq 0x23f0
jmp 0xf03f
movslq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movl %ebp, %eax
incl %eax
movslq %eax, %rsi
movq %rsp, %rcx
movq %r14, %rdx
callq 0x20c0
addl %ebp, (%rbx)
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.c
// Function: strrev
char* strrev(const char* str) {
    int len = strlen(str);
    char* newstr = safe_malloc(len + 1);

    char* start = newstr;
    const char* end = str + len - 1;

    for (int i = 0; i < len; i++) {
        *start = *end;
        start++;
        end--;
    }
    newstr[len] = '\0';
    return newstr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
incl %eax
movslq %eax, %rdi
callq 0xef58
movslq %r14d, %rcx
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
leaq (%rcx,%rbx), %rdi
decq %rdi
cmpl %edx, %esi
je 0xf125
movb (%rdi), %r8b
movb %r8b, (%rax,%rdx)
incq %rdx
decq %rdi
jmp 0xf112
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.c
// Function: strsubstr
char* strsubstr(const char* str, int start, int end) {
    int len = end - start;
    char* buffer = safe_malloc(len + 1);
    memcpy(buffer, &str[start], len);
    buffer[len] = '\0';
    return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
subl %esi, %ebx
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0xef58
movq %rax, %r15
movslq %ebp, %rsi
addq %r14, %rsi
movslq %ebx, %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2270
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.c
// Function: strstep
char* strstep(const char* str, int step) {
    int len = strlen(str);
    int bufferlen = len / step + (len % step == 0 ? 0 : 1);
    char* buffer = safe_malloc(bufferlen + 1);
    for (int i = 0, j = 0; i < bufferlen; i++, j += step) {
        buffer[i] = str[j];
    }
    buffer[bufferlen] = '\0';
    return buffer;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2110
cltd
idivl %ebp
movl %eax, %r14d
cmpl $0x1, %edx
sbbl $-0x1, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0xef58
movslq %ebp, %rcx
xorl %edx, %edx
testl %r14d, %r14d
movl $0x0, %esi
cmovgl %r14d, %esi
cmpq %rdx, %rsi
je 0xf1c2
movb (%rbx), %dil
movb %dil, (%rax,%rdx)
incq %rdx
addq %rcx, %rbx
jmp 0xf1ae
movslq %r14d, %rcx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.c
// Function: get_executable_path
char* get_executable_path(void) {
    /* TODO: reading /proc is definitely not cross platform */
    char* path = safe_malloc(BUFSIZE);

    int len = readlink("/proc/self/exe", path, BUFSIZE - 1);
    if (len == -1) {
        free(path);
        path = NULL;
    } else {
        path[len] = '\0';
    }
    return path;
}

// Assembly:
pushq %rbx
movl $0x1000, %edi           # imm = 0x1000
callq 0xef58
movq %rax, %rbx
leaq 0x26eb(%rip), %rdi      # 0x118ce
movl $0xfff, %edx            # imm = 0xFFF
movq %rax, %rsi
callq 0x20d0
cmpl $-0x1, %eax
jne 0xf201
movq %rbx, %rdi
callq 0x23f0
xorl %ebx, %ebx
jmp 0xf207
cltq
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.c
// Function: get_base_path
char* get_base_path(void) {
#ifdef EMSCRIPTEN
    char* base_path = safe_malloc(2);
    base_path[0] = '.';
    base_path[1] = '\0';
    return base_path;
#else
    // Executable is in 'bin' directory, so we need to go up twice
    char* exe_path = get_executable_path();
    char* base_path = path_join(dirname(exe_path), "../");
    free(exe_path);
    return base_path;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0xf1ce
movq %rax, %rbx
movq %rax, %rdi
callq 0x2150
leaq 0x26b6(%rip), %rsi      # 0x118dd
movq %rax, %rdi
callq 0xf245
movq %rax, %r14
movq %rbx, %rdi
callq 0x23f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/muayyad-alsadi[P]oneway/oneway.c
// Function: name_to_uid
uid_t name_to_uid(char const *name, gid_t *gid, char** home, char **shell)
{
  if (!name) return -1;
  struct passwd *ptr=getpwnam(name);
  if (0 == ptr) {
      fprintf(stderr, "could not find user [%s]\n", name);
      return -1;
  }
  *gid=ptr->pw_gid;
  *home=strdup(ptr->pw_dir);
  *shell=(ptr->pw_shell);
  return ptr->pw_uid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x1285
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
callq 0x1090
testq %rax, %rax
je 0x1296
movq %rax, %rbp
movl 0x14(%rax), %eax
movl %eax, (%r13)
movq 0x20(%rbp), %rdi
callq 0x1130
movq %rax, (%r15)
movq 0x28(%rbp), %rax
movq %rax, (%r14)
movl 0x10(%rbp), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d5b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd5d(%rip), %rsi       # 0x2004
movq %r12, %rdx
xorl %eax, %eax
callq 0x10a0
jmp 0x1285
// File: /workspace/github_c_makefile_star2_O2/singpolyma[P]mnemonicode/mnencode.c
// Function: counthex
int counthex(const mn_byte *s, size_t len) {
	int total = 0;
	size_t i;
	for(i = 0; i < len; i++) {
		if(isxdigit(s[i])) total++;
	}
	return total;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0xb203
callq 0xb0c0
movq (%rax), %rax
movzbl (%r15,%r12), %ecx
movzwl (%rax,%rcx,2), %eax
btl $0xc, %eax
adcl $0x0, %r14d
incq %r12
jmp 0xb1e0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/singpolyma[P]mnemonicode/mnencode.c
// Function: countLeadingCrapAndZeros
int countLeadingCrapAndZeros(const mn_byte *in, size_t inlen) {
	size_t i;
	for(i = 0; i < inlen; i++) {
		if(in[i] != '0' && isxdigit(in[i])) break; /* Find first non-zero hex digit */
	}
	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0xb24b
movzbl (%r14,%r15), %r12d
cmpq $0x30, %r12
je 0xb243
callq 0xb0c0
movq (%rax), %rax
testb $0x10, 0x1(%rax,%r12,2)
jne 0xb248
incq %r15
jmp 0xb223
movq %r15, %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/singpolyma[P]mnemonicode/mnencode.c
// Function: hex2bytes
int hex2bytes(int inlen, const mn_byte *in, mn_byte *out) {
	char t[3];
	int i, j = 0, k = 0;
	i = countLeadingCrapAndZeros(in, inlen);
	inlen = inlen - i;
	in = in + i;
	if(counthex(in, inlen) % 2 != 0) {
		t[j++] = '0';
	}
	for(i = 0; i < inlen; i++) {
		if(isxdigit(in[i])) {
			t[j++] = in[i];
			if(j == 2) {
				t[2] = '\0';
				errno = 0;
				out[k++] = strtol(t, NULL, 16);
				if(errno != 0) {
					return -1;
				}
				j = 0;
			}
		}
	}
	return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movslq %edi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0xb212
subl %eax, %r14d
movslq %eax, %r15
addq %r12, %r15
movslq %r14d, %rsi
movq %r15, %rdi
callq 0xb1cc
xorl %r12d, %r12d
movl $0x0, %r13d
testb $0x1, %al
je 0xb2a2
movb $0x30, 0x5(%rsp)
pushq $0x1
popq %r13
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0xb314
callq 0xb0c0
movq (%rax), %rcx
movzbl (%r15,%rbp), %eax
testb $0x10, 0x1(%rcx,%rax,2)
je 0xb309
movl %r13d, %ecx
movb %al, 0x5(%rsp,%rcx)
cmpl $0x1, %r13d
jne 0xb305
movb $0x0, 0x7(%rsp)
callq 0xb040
movq %rax, %r13
andl $0x0, (%rax)
leaq 0x5(%rsp), %rdi
xorl %esi, %esi
pushq $0x10
popq %rdx
callq 0xb090
movslq %r12d, %rcx
movb %al, (%rbx,%rcx)
cmpl $0x0, (%r13)
jne 0xb30e
incl %r12d
xorl %r13d, %r13d
jmp 0xb309
pushq $0x1
popq %r13
incq %rbp
jmp 0xb2ab
pushq $-0x1
popq %rax
movl %eax, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/singpolyma[P]mnemonicode/mnencode.c
// Function: main
int main(int argc, char **argv) {
	mn_byte *buf;
	mn_byte cbuf[0x10000];
	mn_byte xbuf[0x8000];
	char outbuf[0x90000];
	int buflen;
	int n;
	int hex_encoded_input = 0;

	if(argc > 1 && strcmp(argv[1],"-x") == 0) {
		hex_encoded_input = 1;
	}

	fprintf (stderr, "%s\n", mn_wordlist_version);

	buflen = fread(cbuf, 1, sizeof cbuf, stdin);

	if(hex_encoded_input) {
		buflen = hex2bytes(buflen, cbuf, xbuf);
		if(buflen < 0) {
			perror("hex2bytes");
			return EXIT_FAILURE;
		}
		buf = xbuf;
	} else {
		buf = cbuf;
	}

	n = mn_encode(buf, buflen, outbuf, sizeof outbuf, "x x x. x x x. x x x\n");

	if(n != 0) {
		fprintf(stderr, "mn_encode error %d\n", n);
		return EXIT_FAILURE;
	}

	fwrite(outbuf, 1, strlen (outbuf), stdout);
	putchar('\n');

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa8000, %rsp          # imm = 0xA8000
movb $0x1, %bpl
cmpl $0x2, %edi
jl 0xb350
movq 0x8(%rsi), %rax
cmpb $0x2d, (%rax)
jne 0xb350
cmpb $0x78, 0x1(%rax)
jne 0xb350
cmpb $0x0, 0x2(%rax)
setne %bpl
movq 0x5ca1(%rip), %r14      # 0x10ff8
movq (%r14), %rdi
leaq 0x5d1f(%rip), %rax      # 0x11080
movq (%rax), %rdx
leaq 0xc99(%rip), %rsi       # 0xc004
xorl %eax, %eax
callq 0xb080
movq 0x5c5f(%rip), %rax      # 0x10fd8
movq (%rax), %rcx
leaq 0x8000(%rsp), %rbx
pushq $0x1
popq %rsi
movl $0x10000, %edx          # imm = 0x10000
movq %rbx, %rdi
callq 0xb050
testb %bpl, %bpl
jne 0xb3b2
leaq 0x8000(%rsp), %rsi
movq %rsp, %rbx
movl %eax, %edi
movq %rbx, %rdx
callq 0xb259
testl %eax, %eax
js 0xb427
leaq 0xc59(%rip), %r8        # 0xc012
leaq 0x18000(%rsp), %rdx
movq %rbx, %rdi
movl %eax, %esi
movl $0x90000, %ecx          # imm = 0x90000
callq 0xb77f
testl %eax, %eax
jne 0xb412
leaq 0x18000(%rsp), %rbx
movq %rbx, %rdi
callq 0xb060
movq 0x5be5(%rip), %rcx      # 0x10fd0
movq (%rcx), %rcx
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0b0
pushq $0xa
popq %rdi
callq 0xb030
xorl %eax, %eax
addq $0xa8000, %rsp          # imm = 0xA8000
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rdi
leaq 0xc0b(%rip), %rsi       # 0xc027
movl %eax, %edx
xorl %eax, %eax
callq 0xb080
jmp 0xb433
leaq 0xbda(%rip), %rdi       # 0xc008
callq 0xb0a0
pushq $0x1
popq %rax
jmp 0xb406
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/bamlite.c
// Function: bam_header_destroy
void bam_header_destroy(bam_header_t *header)
{
    int32_t i;
    if (header == 0) return;
    if (header->target_name) {
        for (i = 0; i < header->n_targets; ++i)
            if (header->target_name[i]) free(header->target_name[i]);
        if (header->target_len) free(header->target_len);
        free(header->target_name);
    }
    if (header->text) free(header->text);
    free(header);
}

// Assembly:
testq %rdi, %rdi
je 0x2d84
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2d6c
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x2d5a
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2060
incq %r14
jmp 0x2d40
movq 0x10(%rbx), %rdi
callq 0x2060
movq 0x8(%rbx), %rdi
callq 0x2060
movq 0x28(%rbx), %rdi
callq 0x2060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/bamlite.c
// Function: bamlite_gzread
int bamlite_gzread(gzFile file, void *ptr, unsigned int len) {
    int ret = gzread(file, ptr, len);
    
    if (ret < 0) {
        int errnum = 0;
        const char *msg = gzerror(file, &errnum);
        fprintf(stderr, "gzread error: %s\n",
                Z_ERRNO == errnum ? strerror(errno) : msg);
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x22b0
movl %eax, %ebx
testl %eax, %eax
js 0x2f6e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2360
movq 0x2506f(%rip), %rcx     # 0x27ff8
movq (%rcx), %r14
cmpl $-0x1, (%r15)
jne 0x2f9e
callq 0x2080
movl (%rax), %edi
callq 0x2520
leaq 0x1b1e1(%rip), %rsi     # 0x1e186
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22c0
jmp 0x2f62
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/bamlite.c
// Function: bam_hrecs_sort_order
enum bam_sort_order bam_hrecs_sort_order(bam_header_t *header)
{
    char *hdr;
    size_t i, j, len;

    len = header->l_text;
    hdr = header->text;
    
    if (len < 3)
        if (len == 0 || *hdr == '\0')
            return ORDER_UNKNOWN;

    for (i = 0; i < len; i++) {
        if (!strncmp(hdr + i, "@HD", 3)) {
            i += 3;
            if (hdr[i] != '\t')
                return ORDER_UNKNOWN;
            i++;
            while (hdr[i]!='\n') {
                for (j = i; j < len && hdr[j] != '\0' && hdr[j] != '\n' && hdr[j] != '\t'; j++)
                    ;

                if (j - i < 3 || hdr[i + 2] != ':') {
                    return ORDER_UNKNOWN;
                }

                if (!strncmp(hdr + i, "SO", 2)) {
                    i += 3;
                    if (!strncmp(hdr + i, "unsorted", 8))
                        return ORDER_UNSORTED;
                    else if (!strncmp(hdr + i, "queryname", 9))
                        return ORDER_NAME;
                    else if (!strncmp(hdr + i, "coordinate", 10))
                        return ORDER_COORD;
                    else
                        return ORDER_UNKNOWN;
                }

                i = j + 1;
            }
        }
        while(hdr[i]!='\n')
            i++;
    }
    
    return ORDER_UNKNOWN;
}

// Assembly:
pushq %rbx
movq 0x18(%rdi), %rcx
movq 0x28(%rdi), %rdx
pushq $-0x1
popq %rax
cmpq $0x2, %rcx
ja 0x3256
testq %rcx, %rcx
je 0x3360
cmpb $0x0, (%rdx)
je 0x3360
xorl %edi, %edi
movl $0x601, %esi            # imm = 0x601
cmpq %rcx, %rdi
jae 0x3360
cmpb $0x40, (%rdx,%rdi)
jne 0x32f4
cmpb $0x48, 0x1(%rdx,%rdi)
jne 0x32f4
cmpb $0x44, 0x2(%rdx,%rdi)
jne 0x32f4
cmpb $0x9, 0x3(%rdx,%rdi)
jne 0x3360
addq $0x4, %rdi
movb (%rdx,%rdi), %r9b
cmpb $0xa, %r9b
je 0x32f4
leaq (%rdx,%rdi), %rbx
cmpq %rcx, %rdi
movq %rcx, %r10
cmovaq %rdi, %r10
movq %rdi, %r8
cmpq %rcx, %r8
jae 0x32c3
movzbl (%rdx,%r8), %r11d
cmpl $0xa, %r11d
ja 0x32be
btl %r11d, %esi
jb 0x32c6
incq %r8
jmp 0x32a8
movq %r10, %r8
movq %r8, %r10
subq %rdi, %r10
cmpq $0x3, %r10
jb 0x3360
cmpb $0x3a, 0x2(%rbx)
jne 0x3360
cmpb $0x53, %r9b
jne 0x32ec
cmpb $0x4f, 0x1(%rbx)
je 0x330a
incq %r8
movq %r8, %rdi
jmp 0x328d
movq %rdi, %r8
leaq 0x1(%r8), %rdi
cmpb $0xa, (%rdx,%r8)
movq %rdi, %r8
jne 0x32f7
jmp 0x325d
addq $0x3, %rbx
leaq 0x1ae0b(%rip), %rsi     # 0x1e120
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x3359
leaq 0x1adfe(%rip), %rsi     # 0x1e129
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x335d
leaq 0x1adf2(%rip), %rsi     # 0x1e133
pushq $0xa
popq %rdx
movq %rbx, %rdi
callq 0x20b0
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x2, %eax
jmp 0x3360
xorl %eax, %eax
jmp 0x3360
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/bamlite.c
// Function: get_target_end
int get_target_end(bam1_t *b)
{
    int i, s;
    uint8_t c;
    uint32_t n_cigar, *cigar;
    s = b->core.pos;
    cigar = bam1_cigar(b);
    n_cigar = b->core.n_cigar;
    for (i = 0; i < n_cigar; ++i) {
        c = cigar[i] & BAM_CIGAR_MASK;
        if (c == BAM_CMATCH || c == BAM_CDEL)
            s += cigar[i] >> BAM_CIGAR_SHIFT;
    }
    return s;
}

// Assembly:
movq 0x8(%rdi), %rcx
movl %ecx, %edx
shrl $0x18, %edx
addq 0x30(%rdi), %rdx
movl 0x4(%rdi), %eax
shrq $0x30, %rcx
xorl %esi, %esi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x339a
movl (%rdx,%rdi,4), %r8d
movl %r8d, %r9d
shrl $0x4, %r9d
testb $0xd, %r8b
cmovnel %esi, %r9d
addl %r9d, %eax
incq %rdi
jmp 0x337a
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/bamlite.c
// Function: bamlite_gzopen
gzFile bamlite_gzopen(const char *fn, const char *mode) {
    gzFile fp;
    if (strcmp(fn, "-") == 0) {
        fp = gzdopen(fileno((strstr(mode, "r"))? stdin : stdout), mode);
        if (!fp) {
            fprintf(stderr, "Couldn't open %s : %s",
                    (strstr(mode, "r"))? "stdin" : "stdout",
                    strerror(errno));
        }
        return fp;
    }
    if ((fp = gzopen(fn, mode)) == 0) {
        fprintf(stderr, "Couldn't open %s : %s\n", fn,
                errno ? strerror(errno) : "Out of memory");
    }
    return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x2d, (%rdi)
jne 0x33b2
cmpb $0x0, 0x1(%r14)
je 0x33d2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23b0
testq %rax, %rax
je 0x3454
movq %rax, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x72
popq %rsi
movq %rbx, %rdi
callq 0x2180
testq %rax, %rax
jne 0x33eb
movq 0x24be7(%rip), %rax     # 0x27fd0
jmp 0x33f2
movq 0x24be6(%rip), %rax     # 0x27fd8
movq (%rax), %rdi
callq 0x2310
movl %eax, %edi
movq %rbx, %rsi
callq 0x2130
testq %rax, %rax
jne 0x33c6
movq 0x24be8(%rip), %rax     # 0x27ff8
movq (%rax), %r14
pushq $0x72
popq %rsi
movq %rbx, %rdi
callq 0x2180
testq %rax, %rax
leaq 0x1ad32(%rip), %rax     # 0x1e15a
leaq 0x1ad25(%rip), %rbx     # 0x1e154
cmoveq %rax, %rbx
callq 0x2080
movl (%rax), %edi
callq 0x2520
leaq 0x1acf8(%rip), %rsi     # 0x1e13e
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
jmp 0x348a
movq 0x24b9d(%rip), %rax     # 0x27ff8
movq (%rax), %rbx
callq 0x2080
movl (%rax), %edi
testl %edi, %edi
jne 0x3472
leaq 0x1ad08(%rip), %rcx     # 0x1e178
jmp 0x347a
callq 0x2520
movq %rax, %rcx
leaq 0x1ace0(%rip), %rsi     # 0x1e161
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22c0
jmp 0x33c9
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/bamlite.c
// Function: bamlite_gzclose
int bamlite_gzclose(gzFile file) {
    int ret = gzclose(file);
    if (Z_OK != ret) {
        fprintf(stderr, "gzclose error: %s\n",
                          Z_ERRNO == ret ? strerror(errno) : zError(ret));
    }
    
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x2050
movl %eax, %ebx
testl %eax, %eax
jne 0x34af
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x24b42(%rip), %rax     # 0x27ff8
movq (%rax), %r14
cmpl $-0x1, %ebx
jne 0x34cc
callq 0x2080
movl (%rax), %edi
callq 0x2520
jmp 0x34d3
movl %ebx, %edi
callq 0x2190
leaq 0x1acbe(%rip), %rsi     # 0x1e198
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22c0
jmp 0x34a5
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/break.c
// Function: link_mat_init
link_mat_t *link_mat_init(asm_dict_t *dict, uint32_t b)
{
    link_mat_t *link_mat = (link_mat_t *) malloc(sizeof(link_mat_t));
    link_mat->b = b;
    link_mat->n = dict->n;
    link_mat->link = (link_t *) malloc(sizeof(link_t) * link_mat->n);

    uint32_t i;
    for (i = 0; i < link_mat->n; ++i)
        link_init(link_mat->link + i, i, div_ceil(dict->s[i].len, b));
    
    return link_mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x2330
movq %rax, %r15
movl %ebx, 0x4(%rsp)
movl %ebx, (%rax)
movq %r14, 0x10(%rsp)
movl (%r14), %r13d
movl %r13d, 0x4(%rax)
movq %r13, %rdi
shlq $0x4, %rdi
callq 0x2330
movq %rax, %r12
movq %r15, 0x8(%rsp)
movq %rax, 0x8(%r15)
xorl %ebp, %ebp
movabsq $0x100000000, %r15      # imm = 0x100000000
cmpq %r13, %rbp
je 0x35a2
movq %rbp, %r14
shlq $0x4, %r14
leaq (%r12,%r14), %rbx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
imulq $0x58, %rbp, %rcx
movq 0x8(%rax,%rcx), %rdi
movl 0x4(%rsp), %esi
callq 0x28ff
movl %ebp, (%r12,%r14)
movl %eax, 0x4(%r12,%r14)
movl %eax, %r14d
leaq (,%r14,8), %rdi
callq 0x2330
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rdx, %r14
je 0x3599
movq %rcx, (%rax,%rdx,8)
incq %rdx
addq %r15, %rcx
jmp 0x3588
movq %rax, 0x8(%rbx)
incq %rbp
jmp 0x3540
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/break.c
// Function: link_mat_destroy
void link_mat_destroy(link_mat_t *link_mat)
{
    if (!link_mat) return;
    uint32_t i;
    for (i = 0; i < link_mat->n; ++i)
        free(link_mat->link[i].link);
    free(link_mat->link);
    free(link_mat);
}

// Assembly:
testq %rdi, %rdi
je 0x35fa
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %r14
xorl %r15d, %r15d
movl 0x4(%rbx), %eax
movq 0x8(%rbx), %rdi
cmpq %rax, %r15
jae 0x35e8
movq (%rdi,%r14), %rdi
callq 0x2060
incq %r15
addq $0x10, %r14
jmp 0x35ca
callq 0x2060
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/break.c
// Function: add_break_point
KDQ_INIT(int64_t)

static void add_break_point(bp_t *bp, uint64_t p)
{
    if (bp->n == bp->m) {
        bp->m <<= 1;
        bp->p = (uint64_t *) realloc(bp->p, bp->m * sizeof(uint64_t));
    }
    bp->p[bp->n] = p;
    ++bp->n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %esi
cmpl 0x4(%rdi), %esi
jne 0x4022
addl %esi, %esi
movl %esi, 0x4(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x3, %rsi
callq 0x2390
movq %rax, 0x10(%rbx)
movl (%rbx), %esi
jmp 0x4026
movq 0x10(%rbx), %rax
movl %esi, %ecx
movq %r14, (%rax,%rcx,8)
incl %esi
movl %esi, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq