LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x10086
movq %rax, %r14
movl $0x5, (%rax)
movq %rbx, %rdi
callq 0x2110
movl %eax, 0x10(%r14)
incl %eax
movslq %eax, %rdi
callq 0x2290
testq %rax, %rax
je 0x1008b
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2778
callq 0x2753
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x100ad
movl $0x6, (%rax)
movb %bl, 0x18(%rax)
popq %rbx
retq
callq 0x279d
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x10107
movq %rax, %r14
movl $0x7, (%rax)
movq %r15, 0x18(%rax)
movq %rbx, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
testq %rax, %rax
je 0x1010c
movq %rax, 0x20(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x27e7
callq 0x27c2
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x1016a
movq %rax, %r12
movl $0x8, (%rax)
callq 0x1016f
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
callq 0x280c
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x18, %edi
callq 0x2290
testq %rax, %rax
je 0x101b0
movq %rax, %rbx
movq $0x0, (%rax)
leaq 0x75(%rip), %rdi        # 0x10205
leaq 0x73(%rip), %rsi        # 0x1020a
callq 0x5680
movq %rax, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl $0x1, 0x14(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x2831
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x10200
movq %rax, %rbx
movq $0xa, (%rax)
movl $0x0, 0x10(%rax)
leaq 0x1a(%rip), %rdi        # 0x10205
leaq 0x18(%rip), %rsi        # 0x1020a
callq 0x5680
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x2856
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x1022e
movl $0xb, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
callq 0x287b
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x10252
movl $0xc, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
callq 0x28a0
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x10276
movl $0xd, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
callq 0x28c5
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2290
testq %rax, %rax
je 0x1029a
movl $0xe, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
popq %rcx
retq
callq 0x28ea
// File: /workspace/github_c_makefile_star2_O3/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 0x10346
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
je 0x10348
popq %rbx
retq
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1035b
cmpl $0x0, 0x14(%rdi)
jle 0x1035b
callq 0x1032e
movq 0x8(%rbx), %rdi
callq 0x56ff
movq %rbx, %rdi
popq %rbx
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x5b3d
movl %eax, %ebp
movq 0x18(%rbx), %rdi
callq 0x5b41
movq %rax, %rbx
callq 0x10233
movq %rax, %r14
testl %ebp, %ebp
jle 0x104ef
movl %ebp, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
callq 0xffcd
movslq 0x4(%r14), %rbp
leaq 0x1(%rbp), %rcx
movl %ecx, 0x4(%r14)
incl 0x10(%r14)
movq %rax, %r15
movl $0x4, (%rax)
movq 0x8(%r14), %rdi
leaq 0x8(,%rbp,8), %rsi
callq 0x22e0
movq %rax, 0x8(%r14)
movq %r15, (%rax,%rbp,8)
incq %r13
cmpq %r13, %r12
jne 0x104ac
movq %rbx, %rdi
callq 0x23f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x5b3d
movl %eax, %ebp
movq 0x18(%rbx), %rdi
callq 0x5b88
movq %rax, %rbx
callq 0x10233
movq %rax, %r14
testl %ebp, %ebp
jle 0x1057d
movl %ebp, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
callq 0x10597
movslq 0x4(%r14), %rbp
leaq 0x1(%rbp), %rcx
movl %ecx, 0x4(%r14)
incl 0x10(%r14)
movq %rax, %r15
movq 0x8(%r14), %rdi
leaq 0x8(,%rbp,8), %rsi
callq 0x22e0
movq %rax, 0x8(%r14)
movq %r15, (%rax,%rbp,8)
incq %r13
cmpq %r13, %r12
jne 0x10540
movq %rbx, %rdi
callq 0x23f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0x1082a
movq %r14, %rdi
xorl %esi, %esi
callq 0x1075b
movslq 0x4(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x4(%rbx)
incl 0x10(%rbx)
movq %rax, %r15
movq 0x8(%rbx), %rdi
leaq 0x8(,%rcx,8), %rsi
callq 0x22e0
movq %rax, 0x8(%rbx)
movslq 0x4(%rbx), %rcx
movq %r15, -0x8(%rax,%rcx,8)
cmpl $0x0, 0x4(%r14)
jne 0x107ea
movq %r14, %rdi
callq 0x1029f
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %esi
testl %esi, %esi
je 0x108d4
movl %edx, %ebp
decl %esi
movq %r14, %rdi
callq 0x1075b
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x1083b
movl 0x4(%r14), %esi
testl %esi, %esi
jne 0x108b5
movq %r14, %rdi
callq 0x1029f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x10975
cmpl $0xc, %eax
jne 0x10975
callq 0x10233
movq %rax, %r12
movl 0x4(%rbx), %esi
testl %esi, %esi
je 0x1096b
movslq 0x4(%r12), %rbp
movl 0x10(%r12), %r14d
movq %r12, (%rsp)
movq 0x8(%r12), %r15
leaq 0x8(,%rbp,8), %r12
decl %esi
movq %rbx, %rdi
callq 0x1075b
movq %rax, %r13
incl %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x22e0
movq %rax, %r15
movq %r13, -0x8(%rax,%r12)
movl 0x4(%rbx), %esi
incl %ebp
addq $0x8, %r12
testl %esi, %esi
jne 0x10928
movq (%rsp), %r12
movl %ebp, 0x4(%r12)
movl %r14d, 0x10(%r12)
movq %r15, 0x8(%r12)
movq %rbx, %rdi
callq 0x1029f
jmp 0x10991
movq 0x18(%rbx), %rdi
callq 0x1169f
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x23f0
movq %r14, 0x18(%rbx)
movq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x10a82
cmpl $0xc, %eax
jne 0x10a82
testl %r15d, %r15d
je 0x10a08
movl %r15d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %rdi
callq 0x1029f
decl %r14d
jne 0x109da
subl %r15d, %ebp
jmp 0x10a08
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1075b
movq %rax, %rdi
callq 0x1029f
movl 0x4(%rbx), %ecx
cmpl %ecx, %ebp
jl 0x109f6
cmpl $0x2, 0x8(%rsp)
setl %al
testl %ecx, %ecx
sete %dl
orb %al, %dl
jne 0x10ac8
movl %ecx, %eax
cltd
idivl 0x8(%rsp)
cmpl $0x1, %edx
sbbl $-0x1, %eax
movl %eax, 0x14(%rsp)
cmpl %eax, %ecx
jle 0x10ac8
movq 0x8(%rsp), %rax
leal -0x1(%rax), %ebp
xorl %r13d, %r13d
movl $0x1, %r14d
movl %r14d, %r15d
subl %r13d, %r15d
movl %ebp, %r12d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1075b
movq %rax, %rdi
callq 0x1029f
decl %r12d
jne 0x10a57
addl %ebp, %r13d
addl 0x8(%rsp), %r14d
movl 0x14(%rsp), %eax
cmpl %eax, 0x4(%rbx)
jg 0x10a4e
jmp 0x10ac8
movq 0x18(%rbx), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x11703
movq %rax, %r15
cmpl $0x2, 0x8(%rsp)
jl 0x10abb
cmpb $0x0, (%r15)
je 0x10abb
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x11758
movq %rax, %r14
movq %r15, %rdi
callq 0x23f0
movq %r14, %r15
movq 0x18(%rbx), %rdi
callq 0x23f0
movq %r15, 0x18(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10b28
movl (%rsi), %eax
cmpl $0x1, %eax
ja 0x10b28
cmpl $0x1, %ecx
je 0x10b0f
cmpl $0x1, %eax
jne 0x10b28
movl $0x1, (%rdi)
cvtsi2sdq 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdi)
movl (%rsi), %eax
cmpl $0x1, %eax
je 0x10b28
movl $0x1, (%rsi)
xorps %xmm0, %xmm0
cvtsi2sdq 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x18, %edi
callq 0x2290
testq %rax, %rax
je 0x10ba4
movq %rax, %r14
movq (%rbx), %rax
movq %rax, (%r14)
testq %rax, %rax
je 0x10b7d
incl 0x14(%rax)
movq 0x8(%rbx), %rdi
callq 0x5a6c
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
callq 0x29ed
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10ae4
movl (%r14), %ecx
cmpl (%rbx), %ecx
jne 0x10ea1
leal -0x8(%rcx), %eax
cmpl $0x2, %eax
jae 0x10e32
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x10dee
testb %al, %al
je 0x10ea1
movq 0x28(%r14), %r14
movq 0x28(%rbx), %rbx
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x10df9
xorl %eax, %eax
cmpl $0xe, %ecx
ja 0x10ea3
movl %ecx, %ecx
leaq 0x28a2(%rip), %rdx      # 0x136e4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
jne 0x10ea1
testl %eax, %eax
jle 0x10ee7
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
callq 0x10dee
testb %al, %al
je 0x10ea3
incq %r15
movslq 0x4(%r14), %rcx
cmpq %rcx, %r15
jl 0x10e5f
jmp 0x10ea3
movl 0x10(%r14), %eax
cmpl 0x10(%rbx), %eax
jne 0x10ea1
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x11692
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%r14), %rax
cmpq 0x18(%rbx), %rax
jmp 0x10ed0
movsd 0x18(%rbx), %xmm0
cmpeqsd 0x18(%r14), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x10ea3
movb 0x18(%r14), %al
cmpb 0x18(%rbx), %al
sete %al
jmp 0x10ea3
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5bd5
movb $0x1, %al
jmp 0x10ea3
// File: /workspace/github_c_makefile_star2_O3/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 0x1016f
movq %rax, %rbx
movb $0x1, 0x10(%rax)
movq %rax, %rdi
callq 0x10f1d
movq %rbx, %rdi
callq 0x11355
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x117fc
movq %rax, %rbx
leaq 0x2547(%rip), %rsi      # 0x138b9
movq %rax, %rdi
callq 0x11835
movq %rax, %r14
callq 0x1020f
movq %rax, %r12
movq %r14, %rdi
callq 0x10032
movslq 0x4(%r12), %rbp
leaq 0x1(%rbp), %rcx
movl %ecx, 0x4(%r12)
incl 0x10(%r12)
movq %rax, %r13
movq 0x8(%r12), %rdi
leaq 0x8(,%rbp,8), %rsi
callq 0x22e0
movq %rax, 0x8(%r12)
movq %r13, (%rax,%rbp,8)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5220
movq %rax, %rdi
callq 0x1029f
movq %rbx, %rdi
callq 0x23f0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O3/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 0xffcd
movq %rax, %r12
movl $0x3, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x100b2
movq %rax, %rbx
movq 0x8(%r15), %rdi
movq 0x18(%r12), %rsi
movq %rax, %rdx
callq 0x5851
movq %r12, %rdi
callq 0x1029f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1029f
nop
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x10, %edi
callq 0x2290
testq %rax, %rax
je 0x11514
movq %rax, %rbx
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, (%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x2290
testq %rax, %rax
je 0x11519
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x2a37
callq 0x2a12
// File: /workspace/github_c_makefile_star2_O3/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 0x11589
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, %r15d
movl (%rbx), %ecx
movl 0x4(%rbx), %eax
leal (%rcx,%r15), %ebp
cmpl %ebp, %eax
jg 0x11615
addl %eax, %eax
movl %eax, 0x4(%rbx)
movq 0x8(%rbx), %r12
movslq %eax, %rdi
callq 0x2290
testq %rax, %rax
je 0x11642
movq %rax, 0x8(%rbx)
movslq (%rbx), %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2270
movq %r12, %rdi
callq 0x23f0
movl 0x4(%rbx), %eax
cmpl %ebp, %eax
jle 0x115dc
movl (%rbx), %ecx
movslq %ecx, %rdi
addq 0x8(%rbx), %rdi
movl %r15d, %eax
incl %eax
movslq %eax, %rsi
movq %rsp, %rcx
movq %r14, %rdx
callq 0x20c0
addl %r15d, (%rbx)
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a5c
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x2110
movq %rax, %rbx
movq %rax, %r15
shlq $0x20, %r15
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r15, %rdi
sarq $0x20, %rdi
callq 0x2290
testq %rax, %rax
je 0x116fe
sarq $0x20, %r15
testl %ebx, %ebx
jle 0x116f3
leaq (%r15,%r14), %rcx
decq %rcx
xorl %edx, %edx
movb (%rcx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
decq %rcx
cmpl %edx, %ebx
jne 0x116e2
movb $0x0, (%rax,%r15)
popq %rbx
popq %r14
popq %r15
retq
callq 0x2aa6
// File: /workspace/github_c_makefile_star2_O3/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, %r14d
movl %esi, %ebp
movq %rdi, %rbx
subl %esi, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x2290
testq %rax, %rax
je 0x11753
movq %rax, %r15
movslq %ebp, %rax
addq %rax, %rbx
movslq %r14d, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2270
movb $0x0, (%r15,%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2acb
// File: /workspace/github_c_makefile_star2_O3/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 0x2290
testq %rax, %rax
je 0x117af
testl %r14d, %r14d
jle 0x117a3
movslq %ebp, %rcx
movl %r14d, %edx
xorl %esi, %esi
movb (%rbx), %dil
movb %dil, (%rax,%rsi)
incq %rsi
addq %rcx, %rbx
cmpq %rsi, %rdx
jne 0x11791
movslq %r14d, %rcx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2af0
// File: /workspace/github_c_makefile_star2_O3/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 0x2290
testq %rax, %rax
je 0x117f7
movq %rax, %rbx
leaq 0x2108(%rip), %rdi      # 0x138d6
movl $0xfff, %edx            # imm = 0xFFF
movq %rax, %rsi
callq 0x20d0
cmpl $-0x1, %eax
jne 0x117ec
movq %rbx, %rdi
callq 0x23f0
xorl %ebx, %ebx
jmp 0x117f2
cltq
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0x2b15
// File: /workspace/github_c_makefile_star2_O3/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 0x117b4
movq %rax, %rbx
movq %rax, %rdi
callq 0x2150
leaq 0x20ce(%rip), %rsi      # 0x138e5
movq %rax, %rdi
callq 0x11835
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_O3/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 0xb10a
movq 0x8(%rsi), %rax
cmpb $0x2d, (%rax)
jne 0xb10a
cmpb $0x78, 0x1(%rax)
jne 0xb10a
cmpb $0x0, 0x2(%rax)
setne %bpl
movq 0x5ee7(%rip), %r14      # 0x10ff8
movq (%r14), %rdi
leaq 0x5f65(%rip), %rax      # 0x11080
movq (%rax), %rdx
leaq 0xedf(%rip), %rsi       # 0xc004
xorl %eax, %eax
callq 0xb080
movq 0x5ea5(%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 0xb16c
leaq 0x8000(%rsp), %rsi
movq %rsp, %rbx
movl %eax, %edi
movq %rbx, %rdx
callq 0xb377
testl %eax, %eax
js 0xb1e1
leaq 0xe9f(%rip), %r8        # 0xc012
leaq 0x18000(%rsp), %rdx
movq %rbx, %rdi
movl %eax, %esi
movl $0x90000, %ecx          # imm = 0x90000
callq 0xb82e
testl %eax, %eax
jne 0xb1cc
leaq 0x18000(%rsp), %rbx
movq %rbx, %rdi
callq 0xb060
movq 0x5e2b(%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 0xe51(%rip), %rsi       # 0xc027
movl %eax, %edx
xorl %eax, %eax
callq 0xb080
jmp 0xb1ed
leaq 0xe20(%rip), %rdi       # 0xc008
callq 0xb0a0
pushq $0x1
popq %rax
jmp 0xb1c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/yahs.c
// Function: print_asm_stats
static void print_asm_stats(uint64_t *n_stats, uint32_t *l_stats, int all)
{
#ifdef DEBUG
    int i;
    fprintf(stderr, "[I::%s] assembly stats:\n", __func__);
    for (i = 0; i < 10; ++i)
        fprintf(stderr, "[I::%s] N%d: %lu (n = %u)\n", __func__, (i + 1) * 10, n_stats[i], l_stats[i]);
#else
    fprintf(stderr, "[I::%s] assembly stats:\n", __func__);
    fprintf(stderr, "[I::%s]  N%d: %lu (n = %u)\n", __func__, 50, n_stats[4], l_stats[4]);
    fprintf(stderr, "[I::%s]  N%d: %lu (n = %u)\n", __func__, 90, n_stats[8], l_stats[8]);
    if (all)
        fprintf(stderr, "[I::%s]  N%d: %lu (n = %u)\n", __func__, 100, n_stats[9], l_stats[9]);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x27f30(%rip), %r12     # 0x2bff8
movq (%r12), %rdi
leaq 0x211e8(%rip), %rsi     # 0x252bb
leaq 0x211fa(%rip), %r14     # 0x252d4
movq %r14, %rdx
xorl %eax, %eax
callq 0x22c0
movq (%r12), %rdi
movq 0x28561(%rip), %r8      # 0x2c650
movl 0x2859a(%rip), %r9d     # 0x2c690
leaq 0x211e7(%rip), %r15     # 0x252e4
pushq $0x32
popq %rcx
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22c0
movq (%r12), %rdi
movq 0x28558(%rip), %r8      # 0x2c670
movl 0x28581(%rip), %r9d     # 0x2c6a0
pushq $0x5a
popq %rcx
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22c0
testl %ebx, %ebx
jne 0x413f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r12), %rdi
movq 0x2852e(%rip), %r8      # 0x2c678
movl 0x28553(%rip), %r9d     # 0x2c6a4
leaq 0x2118c(%rip), %rsi     # 0x252e4
leaq 0x21175(%rip), %rdx     # 0x252d4
pushq $0x64
popq %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O3/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 0x4f94
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x4f77
movl (%rbx), %eax
testl %eax, %eax
jle 0x4f60
xorl %r14d, %r14d
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4f55
callq 0x2060
movl (%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x4f41
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4f6e
callq 0x2060
movq 0x8(%rbx), %rdi
callq 0x2060
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4f85
callq 0x2060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x22b0
movl %eax, %ebp
testl %eax, %eax
js 0x518b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x25fc
jmp 0x5182
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x2, %rcx
ja 0x5461
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x5527
cmpb $0x0, (%rdx)
je 0x5527
xorl %edi, %edi
movl $0x601, %esi            # imm = 0x601
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x40, (%rdx,%rdi)
jne 0x550f
cmpb $0x48, 0x1(%rdx,%rdi)
jne 0x550f
cmpb $0x44, 0x2(%rdx,%rdi)
jne 0x550f
cmpb $0x9, 0x3(%rdx,%rdi)
jne 0x5527
leaq 0x4(%rdi), %r9
movb 0x4(%rdx,%rdi), %r8b
cmpb $0xa, %r8b
jne 0x54ac
movq %r9, %rdi
jmp 0x550f
leaq (%rdx,%rdi), %rbx
addq $0x4, %rbx
movq %r9, %rdi
cmpq %rcx, %r9
jae 0x54db
movq %r9, %rdi
movzbl (%rdx,%rdi), %r10d
cmpl $0xa, %r10d
ja 0x54d0
btl %r10d, %esi
jb 0x54db
incq %rdi
cmpq %rdi, %rcx
jne 0x54bf
movq %rcx, %rdi
movq %rdi, %r10
subq %r9, %r10
cmpq $0x3, %r10
jb 0x5527
cmpb $0x3a, 0x2(%rbx)
jne 0x5527
cmpb $0x53, %r8b
jne 0x54f9
cmpb $0x4f, 0x1(%rbx)
je 0x5529
leaq (%rdx,%rdi), %rbx
incq %rbx
incq %rdi
movb (%rbx), %r8b
movq %rdi, %r9
cmpb $0xa, %r8b
jne 0x54b7
cmpb $0xa, (%rdx,%rdi)
leaq 0x1(%rdi), %rdi
jne 0x550f
cmpq %rcx, %rdi
jb 0x546d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
addq $0x3, %rbx
leaq 0x1cbec(%rip), %rsi     # 0x22120
movl $0x8, %edx
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x557e
leaq 0x1cbdd(%rip), %rsi     # 0x22129
movl $0x9, %edx
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x5582
leaq 0x1cbcf(%rip), %rsi     # 0x22133
movl $0xa, %edx
movq %rbx, %rdi
callq 0x20b0
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x2, %eax
jmp 0x5527
xorl %eax, %eax
jmp 0x5527
movl $0x1, %eax
jmp 0x5527
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x4(%rdi), %eax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
shrq $0x30, %rdx
je 0x55c2
shrl $0x18, %ecx
addq 0x30(%rdi), %rcx
xorl %esi, %esi
xorl %edi, %edi
movl (%rcx,%rdi,4), %r8d
movl %r8d, %r9d
shrl $0x4, %r9d
testb $0xd, %r8b
cmovnel %esi, %r9d
addl %r9d, %eax
incq %rdi
cmpq %rdi, %rdx
jne 0x55a4
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x2d, (%rdi)
jne 0x55d9
cmpb $0x0, 0x1(%r14)
je 0x55f1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23b0
testq %rax, %rax
je 0x5634
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0x72, %esi
callq 0x2180
testq %rax, %rax
jne 0x560c
movq 0x269c6(%rip), %rax     # 0x2bfd0
jmp 0x5613
movq 0x269c5(%rip), %rax     # 0x2bfd8
movq (%rax), %rdi
callq 0x2310
movl %eax, %edi
movq %rbx, %rsi
callq 0x2130
testq %rax, %rax
jne 0x55e9
movq %rbx, %rdi
callq 0x2691
jmp 0x563c
movq %r14, %rdi
callq 0x2649
xorl %eax, %eax
jmp 0x55e9
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
callq 0x2050
movl %eax, %ebx
testl %eax, %eax
jne 0x5650
movl %ebx, %eax
popq %rbx
retq
movl %ebx, %edi
callq 0x26e6
jmp 0x564c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2330
movq %rax, %r15
movl %ebx, 0x4(%rsp)
movl %ebx, (%rax)
movq %r14, 0x20(%rsp)
movl (%r14), %ebx
movl %ebx, 0x4(%rax)
movq %rbx, %rdi
shlq $0x4, %rdi
callq 0x2330
movq %r15, 0x8(%rsp)
movq %rax, 0x8(%r15)
movq %rbx, 0x18(%rsp)
testq %rbx, %rbx
je 0x57cb
movq %rax, %r12
xorl %r15d, %r15d
movabsq $0x100000000, %rbx      # imm = 0x100000000
movabsq $0x200000000, %r14      # imm = 0x200000000
movq %rax, 0x10(%rsp)
movq %r15, %r13
shlq $0x4, %r13
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
imulq $0x58, %r15, %rcx
movq 0x8(%rax,%rcx), %rdi
movl 0x4(%rsp), %esi
callq 0x4b01
movl %eax, %ebp
movl %r15d, (%r12,%r13)
movl %eax, 0x4(%r12,%r13)
movl %eax, %r12d
leaq (,%r12,8), %rdi
callq 0x2330
movdqa 0x1cabc(%rip), %xmm7    # 0x221d0
pcmpeqd %xmm6, %xmm6
movdqa 0x1caa0(%rip), %xmm5    # 0x221c0
testl %ebp, %ebp
je 0x57b1
leaq -0x1(%r12), %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq 0x8(,%r12,8), %rcx
andq $-0x10, %rcx
pxor %xmm5, %xmm0
xorl %edx, %edx
xorl %esi, %esi
movdqa 0x1ca5d(%rip), %xmm1    # 0x221b0
movdqa %xmm1, %xmm2
pxor %xmm5, %xmm2
movdqa %xmm2, %xmm3
pcmpgtd %xmm0, %xmm3
pcmpeqd %xmm0, %xmm2
pshufd $0xf5, %xmm2, %xmm4     # xmm4 = xmm2[1,1,3,3]
pand %xmm3, %xmm4
pshufd $0xf5, %xmm3, %xmm2     # xmm2 = xmm3[1,1,3,3]
por %xmm4, %xmm2
movd %xmm2, %edi
notl %edi
testb $0x1, %dil
je 0x5789
movq %rdx, (%rax,%rsi)
pxor %xmm6, %xmm2
pextrw $0x4, %xmm2, %edi
testb $0x1, %dil
je 0x57a1
leaq (%rdx,%rbx), %rdi
movq %rdi, 0x8(%rax,%rsi)
paddq %xmm7, %xmm1
addq $0x10, %rsi
addq %r14, %rdx
cmpq %rsi, %rcx
jne 0x5753
movq 0x10(%rsp), %r12
addq %r12, %r13
movq %rax, 0x8(%r13)
incq %r15
cmpq 0x18(%rsp), %r15
jne 0x56cf
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x582d
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
je 0x5817
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2060
incq %r15
movl 0x4(%rbx), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x57fb
movq 0x8(%rbx), %rdi
callq 0x2060
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x626f
addl %esi, %esi
movl %esi, 0x4(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x3, %rsi
callq 0x2390
movq %rax, 0x10(%rbx)
movl (%rbx), %esi
jmp 0x6273
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
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/break.c
// Function: print_link_mat
void print_link_mat(link_mat_t *link_mat, asm_dict_t *dict, FILE *fp)
{
    int i, j, n;
    int64_t *link;
    for (i = 0; i < link_mat->n; ++i) {
        link = link_mat->link[i].link;
        n = link_mat->link[i].n;
        fprintf(fp, "%s:", dict->s[link_mat->link[i].s].name);
        for (j = 0; j < n; ++j)
            fprintf(fp, " %d", (int32_t) link[j]);
        fprintf(fp, "\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
cmpl $0x0, 0x4(%rdi)
je 0x6ebf
movq %rdx, %rbx
leaq 0x1b451(%rip), %r13     # 0x22291
xorl %ebp, %ebp
movq %rdi, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq %rbp, %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %r12
movslq 0x4(%rax,%rcx), %r14
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rdx
movl (%rax,%rcx), %eax
imulq $0x58, %rax, %rax
movq (%rdx,%rax), %rdx
movq %rbx, %rdi
leaq 0x1b413(%rip), %rsi     # 0x2228d
xorl %eax, %eax
callq 0x22c0
testq %r14, %r14
jle 0x6ea2
xorl %r15d, %r15d
movl (%r12,%r15,8), %edx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x22c0
incq %r15
cmpq %r15, %r14
jne 0x6e89
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2260
incq %rbp
movq 0x8(%rsp), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rbp
jb 0x6e47
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/break.c
// Function: print_break_point
void print_break_point(bp_t *bp, asm_dict_t *dict, FILE *fp)
{
    int i;
    fprintf(fp, "%s[%u]:", dict->s[bp->s].name, bp->n);
    for (i = 0; i < bp->n; ++i)
        fprintf(fp, " %lu", bp->p[i]);
    fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movl (%rdi), %ecx
movl 0x8(%rdi), %edx
imulq $0x58, %rdx, %rdx
movq (%rax,%rdx), %rdx
leaq 0x1b3a1(%rip), %rsi     # 0x22295
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22c0
cmpl $0x0, (%r14)
je 0x6f2e
leaq 0x1b392(%rip), %r15     # 0x2229d
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x22c0
incq %r12
movl (%r14), %eax
cmpq %rax, %r12
jb 0x6f0e
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2260
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/graph.c
// Function: graph_destroy
void graph_destroy(graph_t *g)
{
    if (!g) return;
    if (g == 0)
        return;
    if (g->arc)
        free(g->arc);
    if (g->idx)
        free(g->idx);
    free(g);
}

// Assembly:
testq %rdi, %rdi
je 0x86f5
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x86de
callq 0x2060
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x86ec
callq 0x2060
movq %rbx, %rdi
popq %rbx
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/graph.c
// Function: graph_print
void graph_print(const graph_t *g, FILE *fp, int no_seq)
{
    uint32_t i, n;
    uint64_t k;
    sd_aseq_t *s;

    n = g->sdict->n;
    for (i = 0; i < n; ++i) {
        s = &g->sdict->s[i];
        fprintf(fp, "S\t%s\t", s->name);
        if (!no_seq) {
            char *seq = 0;//get_asm_seq(g->sdict, s->name);
            if (seq) {
                fputs(seq, fp);
                free(seq);
            } else {
                fputc('*', fp);
            }
        } else {
            fputc('*', fp);
        }
        fprintf(fp, "\tLN:i:%lu", s->len);
        fputc('\n', fp);
    }
    
    for (k = 0; k < g->n_arc; ++k) {
        const graph_arc_t *a = &g->arc[k];
        if (a->del || a->comp) 
            continue;
        fprintf(fp, "L\t%s\t%c\t%s\t%c\t0M\tWT:f:%.6f", g->sdict->s[a->v>>1].name, "+-"[a->v&1], g->sdict->s[a->w>>1].name, "+-"[a->w&1], a->wt);
        if (a->rank >= 0) 
            fprintf(fp, "\tSR:i:%d", a->rank);
        fputc('\n', fp);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movl (%rax), %eax
testq %rax, %rax
je 0x8771
imulq $0x58, %rax, %r13
leaq 0x19c1e(%rip), %r12     # 0x2233b
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq 0x8(%rax), %r15
movq (%r15,%rbp), %rdx
movq %rbx, %rdi
leaq 0x19c00(%rip), %rsi     # 0x22335
xorl %eax, %eax
callq 0x22c0
movl $0x2a, %edi
movq %rbx, %rsi
callq 0x2260
movq 0x8(%r15,%rbp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x22c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2260
addq $0x58, %rbp
cmpq %rbp, %r13
jne 0x871f
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x8825
leaq 0x19bdb(%rip), %r13     # 0x22360
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x20(%r14), %r15
movq 0x18(%r15,%rbp), %rcx
shrq $0x3e, %rcx
jne 0x8815
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movl (%r15,%rbp), %ecx
movl 0x4(%r15,%rbp), %esi
movl %ecx, %edx
shrl %edx
imulq $0x58, %rdx, %rdx
movq (%rax,%rdx), %rdx
andl $0x1, %ecx
movsbl (%rcx,%r13), %ecx
movl %esi, %edi
shrl %edi
imulq $0x58, %rdi, %rdi
movq (%rax,%rdi), %r8
andl $0x1, %esi
movsbl (%rsi,%r13), %r9d
movsd 0x10(%r15,%rbp), %xmm0
movq %rbx, %rdi
leaq 0x19b62(%rip), %rsi     # 0x22345
movb $0x1, %al
callq 0x22c0
movl 0x8(%r15,%rbp), %edx
testl %edx, %edx
js 0x8804
movq %rbx, %rdi
leaq 0x19b66(%rip), %rsi     # 0x22363
xorl %eax, %eax
callq 0x22c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2260
movq 0x18(%r14), %rax
incq %r12
addq $0x20, %rbp
cmpq %rax, %r12
jb 0x878a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq