LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x19b05(%rip), %r13     # 0x1e259
xorl %r12d, %r12d
movq %rdi, 0x8(%rsp)
movl 0x4(%rdi), %eax
cmpq %rax, %r12
jae 0x47e1
movq 0x8(%rdi), %rax
movq %r12, %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rbp
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %r14d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
imulq $0x58, %rdx, %rcx
movq (%rax,%rcx), %rdx
movq %rbx, %rdi
leaq 0x19abe(%rip), %rsi     # 0x1e255
xorl %eax, %eax
callq 0x22c0
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x47c9
movl (%rbp,%r15,8), %edx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x22c0
incq %r15
jmp 0x47ad
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2260
incq %r12
movq 0x8(%rsp), %rdi
jmp 0x475c
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: 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 0x19a47(%rip), %rsi     # 0x1e25d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22c0
leaq 0x19a3e(%rip), %r15     # 0x1e265
xorl %r12d, %r12d
movl (%r14), %eax
cmpq %rax, %r12
jae 0x484c
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x22c0
incq %r12
jmp 0x482a
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2260
// File: /workspace/github_c_makefile_star2_O2/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 0x5ddc
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2060
movq 0x28(%rbx), %rdi
callq 0x2060
movq %rbx, %rdi
popq %rbx
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x58, %rax, %r15
pushq $0xa
popq %r13
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x5e52
movq 0x8(%r14), %rax
movq 0x8(%rax), %r12
movq (%r12,%rbp), %rdx
movq %rbx, %rdi
leaq 0x184e4(%rip), %rsi     # 0x1e2fd
xorl %eax, %eax
callq 0x22c0
pushq $0x2a
popq %rdi
movq %rbx, %rsi
callq 0x2260
movq 0x8(%r12,%rbp), %rdx
movq %rbx, %rdi
leaq 0x184c9(%rip), %rsi     # 0x1e303
xorl %eax, %eax
callq 0x22c0
movl %r13d, %edi
movq %rbx, %rsi
callq 0x2260
addq $0x58, %rbp
jmp 0x5dfe
leaq 0x184cf(%rip), %r13     # 0x1e328
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq 0x18(%r14), %r15
jae 0x5efb
movq 0x20(%r14), %rbp
movq 0x18(%rbp,%r12), %rax
shrq $0x3e, %rax
jne 0x5eef
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movl (%rbp,%r12), %ecx
movl 0x4(%rbp,%r12), %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(%rbp,%r12), %xmm0
movq %rbx, %rdi
leaq 0x1844a(%rip), %rsi     # 0x1e30d
movb $0x1, %al
callq 0x22c0
movl 0x8(%rbp,%r12), %edx
testl %edx, %edx
js 0x5ee4
movq %rbx, %rdi
leaq 0x1844e(%rip), %rsi     # 0x1e32b
xorl %eax, %eax
callq 0x22c0
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2260
incq %r15
addq $0x20, %r12
jmp 0x5e5f
addq $0x8, %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/graph.c
// Function: graph_add_arc
graph_arc_t *graph_add_arc(graph_t *g, uint32_t v, uint32_t w, int64_t link_id, int comp, double wt)
{
    graph_arc_t *a;
    if (g->m_arc == g->n_arc) {
        uint64_t old_m = g->m_arc;
        g->m_arc = g->m_arc? g->m_arc<<1 : 16;
        g->arc = (graph_arc_t *) realloc(g->arc, g->m_arc * sizeof(graph_arc_t));
        memset(&g->arc[old_m], 0, (g->m_arc - old_m) * sizeof(graph_arc_t));
    }
    a = &g->arc[g->n_arc++];
    a->v = v;
    a->w = w;
    a->wt = wt;
    a->rank = -1;
    a->link_id = link_id >= 0? link_id : g->n_arc - 1;
    if (link_id >= 0) 
        a->rank = g->arc[link_id].rank; // TODO: this is not always correct!
    a->del = a->strong = 0;
    a->comp = comp;
    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %esi, %r12d
movq %rdi, %r15
movq 0x10(%rdi), %rbp
movq 0x18(%rdi), %rdi
cmpq %rdi, %rbp
jne 0x5f91
leaq (,%rbp,2), %rax
testq %rbp, %rbp
pushq $0x10
popq %rsi
cmovneq %rax, %rsi
movq %rsi, 0x10(%r15)
movq 0x20(%r15), %rdi
shlq $0x5, %rsi
movsd %xmm0, 0x10(%rsp)
movl %edx, 0xc(%rsp)
callq 0x2390
movq %rax, %r13
movq %rax, 0x20(%r15)
movq %rbp, %rdi
shlq $0x5, %rdi
addq %rax, %rdi
movq 0x10(%r15), %rdx
subq %rbp, %rdx
shlq $0x5, %rdx
xorl %esi, %esi
callq 0x21e0
movl 0xc(%rsp), %edx
movsd 0x10(%rsp), %xmm0
movq 0x18(%r15), %rdi
jmp 0x5f95
movq 0x20(%r15), %r13
leaq 0x1(%rdi), %rax
movq %rax, 0x18(%r15)
movq %rdi, %rsi
shlq $0x5, %rsi
orl $-0x1, 0x8(%r13,%rsi)
testq %r14, %r14
cmovnsq %r14, %rdi
leaq (%rsi,%r13), %rax
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
andq %rdi, %rcx
movabsq $-0x2000000000000000, %rdi # imm = 0xE000000000000000
andq 0x18(%r13,%rsi), %rdi
orq %rcx, %rdi
movl %r12d, (%r13,%rsi)
movl %edx, 0x4(%r13,%rsi)
movsd %xmm0, 0x10(%r13,%rsi)
movq %rdi, 0x18(%r13,%rsi)
testq %r14, %r14
js 0x5fff
movq 0x20(%r15), %rdx
shlq $0x5, %r14
movl 0x8(%rdx,%r14), %edx
movl %edx, 0x8(%rax)
shlq $0x3f, %rbx
orq %rbx, %rcx
movq %rcx, 0x18(%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/graph.c
// Function: graph_arc_is_sorted
int graph_arc_is_sorted(const graph_t *g)
{
    uint64_t e;
    for (e = 1; e < g->n_arc; ++e)
        if (g->arc[e-1].v > g->arc[e].v)
            break;
    return (e == g->n_arc);
}

// Assembly:
movq 0x18(%rdi), %rcx
cmpq $0x1, %rcx
movq %rcx, %rdx
adcq $0x0, %rdx
pushq $0x1
popq %rax
pushq $0x20
popq %rsi
cmpq %rcx, %rax
jae 0x604e
movq 0x20(%rdi), %r8
movl -0x20(%r8,%rsi), %r9d
cmpl (%r8,%rsi), %r9d
ja 0x604b
incq %rax
addq $0x20, %rsi
jmp 0x602e
movq %rax, %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: graph_arc_index_core
uint64_t *graph_arc_index_core(size_t max_seq, size_t n, const graph_arc_t *a)
{
    size_t i, last;
    uint64_t *idx;
    idx = (uint64_t *) calloc(max_seq * 2, 8);
    for (i = 1, last = 0; i <= n; ++i)
        if (i == n || graph_arc_head(a[i - 1]) != graph_arc_head(a[i]))
            idx[graph_arc_head(a[i - 1])] = (uint64_t) last<<32 | (i - last), last = i;
    return idx;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
addq %rdi, %rdi
pushq $0x8
popq %rsi
callq 0x2290
movq %r14, %rcx
shlq $0x5, %rcx
addq %rbx, %rcx
addq $-0x20, %rcx
addq $0x20, %rbx
pushq $0x1
popq %rdx
xorl %esi, %esi
cmpq %r14, %rdx
ja 0x60c8
jne 0x60a2
movl (%rcx), %edi
jmp 0x60a9
movl -0x20(%rbx), %edi
cmpl (%rbx), %edi
je 0x60bf
movq %rdx, %r8
subq %rsi, %r8
shlq $0x20, %rsi
orq %r8, %rsi
movl %edi, %edi
movq %rsi, (%rax,%rdi,8)
movq %rdx, %rsi
incq %rdx
addq $0x20, %rbx
jmp 0x6097
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: read_graph_from_gfa
graph_t *read_graph_from_gfa(char *gfa)
{
    iostream_t *fp;
    char *line;
    char c0[1024], c1[1024], s0[4], s1[4], wts[1024];
    double wt;

    graph_t *g;
    g = graph_init();
    g->sdict = make_asm_dict_from_sdict(make_sdict_from_gfa(gfa, 0));
    
    fp = iostream_open(gfa);
    if (fp == NULL) {
        fprintf(stderr, "[E::%s] cannot open file %s for reading\n", __func__, gfa);
        exit(EXIT_FAILURE);
    }

    while ((line = iostream_getline(fp)) != NULL) {
        if (line[0] == 'L') {
            sscanf(line, "%*s %s %s %s %s %*s %s", c0, s0, c1, s1, wts);
            wt = strtof(wts + 5, NULL);
            graph_add_arc(g, (asm_sd_get(g->sdict, c0)<<1) | (s0[0]=='-'), (asm_sd_get(g->sdict, c1)<<1) | (s1[0]=='-'), -1, 0, wt);
        }
    }
    iostream_close(fp);

    graph_arc_sort(g);
    graph_arc_index(g);

    return g;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc28, %rsp            # imm = 0xC28
movq %rdi, %r15
callq 0x5dad
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
callq 0xec05
movq %rax, %rdi
callq 0xefa5
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x2a3e
testq %rax, %rax
je 0x621e
movq %rax, %r14
leaq 0x820(%rsp), %r13
leaq 0x420(%rsp), %r15
movq %r14, %rdi
callq 0x2b6c
testq %rax, %rax
je 0x61f1
cmpb $0x4c, (%rax)
jne 0x614c
leaq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movq %rax, %rdi
leaq 0x181d3(%rip), %rsi     # 0x1e348
movq %r13, %rdx
leaq 0x14(%rsp), %rcx
movq %r15, %r8
leaq 0x10(%rsp), %r9
xorl %eax, %eax
callq 0x2350
leaq 0x25(%rsp), %rdi
xorl %esi, %esi
callq 0x21d0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xeecc
xorl %ecx, %ecx
cmpb $0x2d, 0x14(%rsp)
sete %cl
leal (%rcx,%rax,2), %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0xeecc
xorl %ecx, %ecx
cmpb $0x2d, 0x10(%rsp)
sete %cl
leal (%rcx,%rax,2), %edx
movq %rbx, %rdi
movl %ebp, %esi
pushq $-0x1
popq %rcx
xorl %r8d, %r8d
movsd 0x18(%rsp), %xmm0
callq 0x5f0a
jmp 0x614c
movq %r14, %rdi
callq 0x2b0a
movq %rbx, %rdi
callq 0x6057
movq %rbx, %rdi
callq 0x60d0
movq %rbx, %rax
addq $0xc28, %rsp            # imm = 0xC28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x21dd3(%rip), %rax     # 0x27ff8
movq (%rax), %rdi
leaq 0x17fc1(%rip), %rsi     # 0x1e1f0
leaq 0x180fe(%rip), %rdx     # 0x1e334
movq %r15, %rcx
xorl %eax, %eax
callq 0x22c0
pushq $0x1
popq %rdi
callq 0x24b0
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: graph_clean
void graph_clean(graph_t *g, int shear)
{
    uint64_t n_arc, n;
    graph_arc_t *arc, *a;
    arc = g->arc;
    n_arc = g->n_arc;
    n = 0;
    for(a = arc; a < arc + n_arc; ++a) {
        if (!a->del) {
            memmove(arc + n, a, sizeof(graph_arc_t));
            ++n;
        }
    }
    g->n_arc = n;
#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] graph cleaned: #arcs %lu -> %ld\n", __func__, n_arc, n);
#endif
    if (shear) {
        uint64_t m = 16;
#ifdef DEBUG_GRAPH_PRUNE
        uint64_t m_arc = g->m_arc;
#endif
        while (m < n) 
            m <<= 1;
        g->arc = (graph_arc_t *) realloc(g->arc, m * sizeof(graph_arc_t));
        g->m_arc = m;
#ifdef DEBUG_GRAPH_PRUNE
        fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] memory sheared: #arcs %lu -> %ld\n", __func__, m_arc, m);
#endif
    }

    graph_arc_sort(g);
    graph_arc_index(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
shlq $0x5, %rcx
addq %rdx, %rcx
xorl %eax, %eax
movq %rdx, %rdi
cmpq %rcx, %rdi
jae 0x6290
testb $0x40, 0x1f(%rdi)
jne 0x628a
movq %rax, %r8
shlq $0x5, %r8
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%rdx,%r8)
movups %xmm0, (%rdx,%r8)
incq %rax
addq $0x20, %rdi
jmp 0x6263
movq %rax, 0x18(%rbx)
testl %esi, %esi
je 0x62be
pushq $0x10
popq %rcx
movq %rcx, %r14
addq %rcx, %rcx
cmpq %rax, %r14
jb 0x629b
movq 0x20(%rbx), %rdi
movq %r14, %rsi
shlq $0x5, %rsi
callq 0x2390
movq %rax, 0x20(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
callq 0x6057
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x60d0
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: graph_print_gv
void graph_print_gv(const graph_t *g, FILE *fp)
{
    uint64_t k;
    char *seq;

    fprintf(fp, "digraph {\n");
    fprintf(fp, "\t{\n");
    for (k = 0; k < g->sdict->n; ++k) {
        seq = g->sdict->s[k].name;
        fprintf(fp, "\t\t\"%s%c\" [style=filled fillcolor = salmon];\n", seq, '-');
        fprintf(fp, "\t\t\"%s%c\";\n", seq, '+');
    }
    fprintf(fp, "\t}\n");
    for (k = 0; k < g->n_arc; ++k) {
        const graph_arc_t *a = &g->arc[k];
        if (a->del) 
            continue;
        fprintf(fp, "\t\"%s%c\" -> \"%s%c\"[label=\"%.3f\"];\n", g->sdict->s[a->v>>1].name, "+-"[a->v&1], g->sdict->s[a->w>>1].name, "+-"[a->w&1], a->wt);
    }
    fprintf(fp, "}\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18072(%rip), %rdi     # 0x1e35f
pushq $0xa
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x24d0
leaq 0x18064(%rip), %rdi     # 0x1e36a
pushq $0x3
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x24d0
pushq $0x2b
popq %r13
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movl (%rax), %ecx
cmpq %rcx, %r12
jae 0x6367
movq 0x8(%rax), %rax
movq (%rax,%rbp), %r15
movq %rbx, %rdi
leaq 0x18034(%rip), %rsi     # 0x1e36e
movq %r15, %rdx
pushq $0x2d
popq %rcx
xorl %eax, %eax
callq 0x22c0
movq %rbx, %rdi
leaq 0x1804a(%rip), %rsi     # 0x1e39b
movq %r15, %rdx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x22c0
incq %r12
addq $0x58, %rbp
jmp 0x631d
leaq 0x18038(%rip), %rdi     # 0x1e3a6
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x24d0
xorl %r12d, %r12d
leaq 0x17fa2(%rip), %r13     # 0x1e328
leaq 0x1801d(%rip), %r15     # 0x1e3aa
xorl %ebp, %ebp
cmpq 0x18(%r14), %rbp
jae 0x63f9
movq 0x20(%r14), %rax
testb $0x40, 0x1f(%rax,%r12)
jne 0x63f0
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rsi
movl (%rax,%r12), %ecx
movl 0x4(%rax,%r12), %edi
movl %ecx, %edx
shrl %edx
imulq $0x58, %rdx, %rdx
movq (%rsi,%rdx), %rdx
andl $0x1, %ecx
movsbl (%rcx,%r13), %ecx
movl %edi, %r8d
shrl %r8d
imulq $0x58, %r8, %r8
movq (%rsi,%r8), %r8
andl $0x1, %edi
movsbl (%rdi,%r13), %r9d
movsd 0x10(%rax,%r12), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x22c0
incq %rbp
addq $0x20, %r12
jmp 0x638f
leaq 0x17fa7(%rip), %rdi     # 0x1e3a7
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24d0
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: graph_remove_multi_arcs
int graph_remove_multi_arcs(graph_t *g)
{
    uint32_t nv, na, v, n_del;
    graph_arc_t *av, *a, *b;

    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;
    for (v = 0; v < nv; ++v) {
        na = graph_arc_n(g, v);
        if (na > 0) {
            av = graph_arc_a(g, v);
            for (a = av; a < av + na; ++a) {
                if (a->del) 
                    continue;
                for(b = a + 1; b < av + na; ++b) {
                    if (b->del) 
                        continue;
                    if (a->w == b->w) {
                        b->del = 1;
                        ++n_del;
                    }
                }
            }
        }
    }
#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] number multi-arcs deleted: %d\n", __func__, n_del);
#endif
    graph_clean(g, 1);
    return n_del;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq 0x8(%rdi), %rcx
movl (%rcx), %ecx
addl %ecx, %ecx
xorl %edx, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %ebx, %ebx
cmpq %rcx, %rdx
je 0x64a2
movq 0x28(%rdi), %r8
movq (%r8,%rdx,8), %r8
movq %r8, %r9
andq %rsi, %r9
je 0x649d
shrq $0x1b, %r8
andq $-0x20, %r8
addq 0x20(%rdi), %r8
shlq $0x5, %r9
addq %r8, %r9
cmpq %r9, %r8
jae 0x649d
testq %rax, 0x18(%r8)
jne 0x6497
movq %r8, %r10
addq $0x20, %r10
cmpq %r9, %r10
jae 0x6497
movq 0x18(%r10), %r11
testq %rax, %r11
jne 0x6470
movl 0x4(%r8), %ebp
cmpl 0x4(%r10), %ebp
jne 0x6470
orq %rax, %r11
movq %r11, 0x18(%r10)
incl %ebx
jmp 0x6470
addq $0x20, %r8
jmp 0x6462
incq %rdx
jmp 0x643a
pushq $0x1
popq %rsi
callq 0x6248
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: graph_add_symm_arcs
int graph_add_symm_arcs(graph_t *g)
{
    uint32_t na, v, w, n_add;
    graph_arc_t *av, *a;

    // need to do it this as graph_add_arc could reallocate g->arc
    na = g->n_arc;
    av = g->arc;
    n_add = 0;
    for (a = av; a < av + na; ++a) {
        v = a->v;
        w = a->w;
        if (!graph_arc(g, w^1, v^1))
            ++n_add;
    }
    uint64_t old_m = g->m_arc;
    while (g->m_arc < na + n_add)
        g->m_arc <<= 1;
    g->arc = (graph_arc_t *) realloc(g->arc, g->m_arc * sizeof(graph_arc_t));
    memset(&g->arc[old_m], 0, (g->m_arc - old_m) * sizeof(graph_arc_t));
    
    av = g->arc;
    for (a = av; a < av + na; ++a) {
        v = a->v;
        w = a->w;
        if (graph_arc(g, w^1, v^1))
            continue;
        graph_add_arc(g, w^1, v^1, -1, 0, .0);
    }
#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] number symm-arcs added: %d\n", __func__, n_add);
#endif
    graph_arc_sort(g);
    graph_arc_index(g);

    return n_add;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r12d
movq 0x20(%rdi), %r14
movq %r12, %r15
shlq $0x5, %r15
leaq (%r14,%r15), %r13
xorl %ebp, %ebp
movq %r14, (%rsp)
cmpq %r13, %r14
jae 0x6501
movl (%r14), %edx
movl 0x4(%r14), %esi
xorl $0x1, %esi
xorl $0x1, %edx
movq %rbx, %rdi
callq 0x65b1
cmpq $0x1, %rax
adcl $0x0, %ebp
addq $0x20, %r14
jmp 0x64da
movq 0x10(%rbx), %r13
addl %ebp, %r12d
movq %r13, %rsi
cmpq %r12, %rsi
jae 0x6519
addq %rsi, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x650b
shlq $0x5, %rsi
movq (%rsp), %rdi
callq 0x2390
movq %rax, %r14
movq %rax, 0x20(%rbx)
movq %r13, %rdi
shlq $0x5, %rdi
addq %rax, %rdi
movq 0x10(%rbx), %rdx
subq %r13, %rdx
shlq $0x5, %rdx
xorl %esi, %esi
callq 0x21e0
addq %r14, %r15
cmpq %r15, %r14
jae 0x6590
movl (%r14), %r12d
movl 0x4(%r14), %r13d
xorl $0x1, %r13d
xorl $0x1, %r12d
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x65b1
testq %rax, %rax
jne 0x658a
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
pushq $-0x1
popq %rcx
xorl %r8d, %r8d
callq 0x5f0a
addq $0x20, %r14
jmp 0x654c
movq %rbx, %rdi
callq 0x6057
movq %rbx, %rdi
callq 0x60d0
movl %ebp, %eax
addq $0x8, %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/./graph.h
// Function: graph_arc
static inline graph_arc_t *graph_arc(graph_t *g, uint32_t v, uint32_t w)
{
    uint32_t i, nv = graph_arc_n(g, v);
    graph_arc_t *av = graph_arc_a(g, v);
    for (i = 0; i < nv; ++i)
        if (av[i].w == w) 
            return av + i;
    return 0;
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
movl %esi, %esi
movq (%rcx,%rsi,8), %rsi
movl %esi, %ecx
incq %rcx
shrq $0x1b, %rsi
andq $-0x20, %rsi
addq %rax, %rsi
addq $-0x20, %rsi
decq %rcx
je 0x65e5
leaq 0x20(%rsi), %rax
cmpl %edx, 0x24(%rsi)
movq %rax, %rsi
jne 0x65d3
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: trim_graph_tips
int trim_graph_tips(graph_t *g)
{
    uint32_t v, nv, n_del;
    graph_arc_t *av;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        if (graph_arc_n(g, v^1) != 1 || graph_arc_n(g, v) > 0)
            continue;
        av = graph_arc_a(g, v^1);
        if (graph_arc_n(g, av->w^1) > 1 && !is_mwt(g, av->w^1, v))
            n_del += graph_arc_del_existed(g, av);
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del tips: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %r14d
addl %r14d, %r14d
xorl %r15d, %r15d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
pushq $0x1
popq %r13
xorl %ebp, %ebp
cmpq %r14, %r15
je 0x6ce7
movq 0x28(%rbx), %rcx
movl %r15d, %eax
xorq $0x1, %rax
movq (%rcx,%rax,8), %rax
cmpl $0x1, %eax
jne 0x6c6a
cmpl $0x0, (%rcx,%r15,8)
je 0x6c6f
incq %r15
jmp 0x6c46
movq 0x20(%rbx), %rsi
shrq $0x1b, %rax
andq $-0x20, %rax
movl 0x4(%rsi,%rax), %edx
xorq $0x1, %rdx
movq (%rcx,%rdx,8), %rcx
testl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
je 0x6c6a
movq %rcx, %rdx
andq %r12, %rdx
je 0x6cd8
shrq $0x1b, %rcx
andq $-0x20, %rcx
addq %rsi, %rcx
shlq $0x5, %rdx
addq %rcx, %rdx
xorpd %xmm0, %xmm0
xorl %edi, %edi
cmpq %rdx, %rcx
jae 0x6cd4
movsd 0x10(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x6cce
movl 0x4(%rcx), %r8d
cmpq %r8, %r15
cmovel %r13d, %edi
movapd %xmm1, %xmm0
addq $0x20, %rcx
jmp 0x6caf
testl %edi, %edi
jne 0x6c6a
addq %rax, %rsi
movq %rbx, %rdi
callq 0x6be8
addl %eax, %ebp
jmp 0x6c6a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6248
movl %ebp, %eax
addq $0x8, %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/graph.c
// Function: trim_graph_blunts
int trim_graph_blunts(graph_t *g)
{
    uint32_t v, nv, na, n_del;
    uint8_t del;
    graph_arc_t *a, *av;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        if (graph_arc_n(g, v^1) > 0)
            continue;
        na = graph_arc_n(g, v);
        if (na > 1) {
            av = graph_arc_a(g, v);
            del = 1;
            for (a = av; a < av + na; ++a) {
                if (graph_arc_n(g, a->w) < 1) {
                    del = 0;
                    break;
                }
            }
            if (del)
                for (a = av; a < av + na; ++a)
                    n_del += graph_arc_del_existed(g, a);
        }
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del blunts: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %r15d
addl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
cmpq %r15, %r12
je 0x6d8f
movq 0x28(%rbx), %rax
movl %r12d, %ecx
xorq $0x1, %rcx
cmpl $0x0, (%rax,%rcx,8)
je 0x6d3b
incq %r12
jmp 0x6d20
movq (%rax,%r12,8), %rcx
testl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
je 0x6d36
movq %rcx, %r14
shrq $0x1b, %r14
andq $-0x20, %r14
addq 0x20(%rbx), %r14
movl %ecx, %r13d
shlq $0x5, %r13
addq %r14, %r13
movq %r14, %rcx
cmpq %r13, %rcx
jae 0x6d88
movl 0x4(%rcx), %edx
addq $0x20, %rcx
cmpl $0x0, (%rax,%rdx,8)
jne 0x6d63
jmp 0x6d36
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be8
addl %eax, %ebp
addq $0x20, %r14
cmpq %r13, %r14
jb 0x6d77
jmp 0x6d36
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6248
movl %ebp, %eax
addq $0x8, %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/graph.c
// Function: trim_graph_repeats
int trim_graph_repeats(graph_t *g)
{
    // TODO a more sophisticated implemetation for complex repeats
    uint32_t v, v1, v2, w1, w2, nv, n_del;
    graph_arc_t *av, *aw;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        if (graph_arc_n(g, v) != 2 || graph_arc_n(g, v^1) != 2)
            continue;
        av = graph_arc_a(g, v^1);
        v1 = av->w;
        v2 = (av + 1)->w;
        aw = graph_arc_a(g, v);
        w1 = aw->w;
        w2 = (aw + 1)->w;

        if ((graph_arc(g, v1, w1) && graph_arc(g, v2, w2)) ||
                (graph_arc(g, v1, w2) && graph_arc(g, v2, w1))) {
            n_del += graph_arc_del_existed(g, av);
            n_del += graph_arc_del_existed(g, av + 1);
            n_del += graph_arc_del_existed(g, aw);
            n_del += graph_arc_del_existed(g, aw + 1);
        }
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del repeats: %u\n", __func__, n_del);
#endif
    
    return n_del;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %edx
addl %edx, %edx
xorl %ebp, %ebp
movl $0x0, 0x8(%rsp)
movq %rdx, 0x18(%rsp)
cmpq %rbp, %rdx
je 0x6ef6
movq 0x28(%rbx), %rax
movq (%rax,%rbp,8), %r14
cmpl $0x2, %r14d
jne 0x6eee
movq %rbp, %rcx
xorq $0x1, %rcx
movq (%rax,%rcx,8), %r15
cmpl $0x2, %r15d
jne 0x6eee
movq 0x20(%rbx), %r13
shrq $0x1b, %r15
andq $-0x20, %r15
movl 0x4(%r13,%r15), %r12d
movl 0x24(%r13,%r15), %eax
movl %eax, 0xc(%rsp)
shrq $0x1b, %r14
andq $-0x20, %r14
movl 0x4(%r13,%r14), %edx
movl 0x24(%r13,%r14), %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
movl %r12d, %esi
movl %edx, 0x24(%rsp)
callq 0x65b1
testq %rax, %rax
je 0x6e5c
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x65b1
testq %rax, %rax
jne 0x6e85
movq %rbx, %rdi
movl %r12d, %esi
movl 0x10(%rsp), %edx
callq 0x65b1
testq %rax, %rax
je 0x6ee9
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x65b1
testq %rax, %rax
je 0x6ee9
leaq (%r15,%r13), %rsi
leaq (%r15,%r13), %r12
addq $0x20, %r12
leaq (%r13,%r14), %r15
leaq (%r14,%r13), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x6be8
movl %eax, %r13d
addl 0x8(%rsp), %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6be8
movl %eax, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6be8
movl %eax, %r14d
addl %r12d, %r14d
addl %r13d, %r14d
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x6be8
addl %r14d, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdx
incq %rbp
jmp 0x6dd3
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6248
movl 0x8(%rsp), %eax
addq $0x28, %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/graph.c
// Function: trim_graph_self_loops
int trim_graph_self_loops(graph_t *g)
{
    uint32_t n_del;
    graph_arc_t *a, *aw;
    n_del = 0;
    for (a = g->arc; a < g->arc + g->n_arc; ++a) {
        // might have bugs here
        if (graph_arc_n(g, a->v) > 1) 
            continue;
        aw = graph_arc(g, a->w, a->v);
        if (aw) 
            n_del += graph_arc_del_existed(g, aw);
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del self loops: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %r12
xorl %ebx, %ebx
movq %r12, %r15
movq 0x18(%r14), %rax
shlq $0x5, %rax
addq %r12, %rax
cmpq %rax, %r15
jae 0x6f70
movq 0x28(%r14), %rax
movl (%r15), %edx
testl $0xfffffffe, (%rax,%rdx,8) # imm = 0xFFFFFFFE
jne 0x6f6a
movl 0x4(%r15), %esi
movq %r14, %rdi
callq 0x65b1
testq %rax, %rax
je 0x6f6a
movq %r14, %rdi
movq %rax, %rsi
callq 0x6be8
addl %eax, %ebx
movq 0x20(%r14), %r12
addq $0x20, %r15
jmp 0x6f28
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6248
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: trim_graph_transitive_edges
int trim_graph_transitive_edges(graph_t *g)
{
    // TODO a more sophisticated implemetation for transitive edges > 2
    uint32_t v, nv, na, n_del;
    graph_arc_t *a1, *a2, *av;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        na = graph_arc_n(g, v);
        if (na < 2) 
            continue;
        av = graph_arc_a(g, v);
        for (a1 = av; a1 < av + na; ++a1) {
            for (a2 = av; a2 < av + na; ++a2) {
                if (a1 == a2) 
                    continue;
                if (graph_arc(g, a1->w, a2->w))
                    n_del += graph_arc_del_existed(g, a2);
            }
        }
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del transitive edges: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %eax
addl %eax, %eax
movq %rax, 0x8(%rsp)
xorl %ecx, %ecx
xorl %ebp, %ebp
cmpq 0x8(%rsp), %rcx
je 0x704c
movq 0x28(%rbx), %rax
movq (%rax,%rcx,8), %rax
testl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
je 0x7044
movq %rcx, 0x10(%rsp)
movq %rax, %r13
shrq $0x1b, %r13
andq $-0x20, %r13
addq 0x20(%rbx), %r13
movl %eax, %r15d
shlq $0x5, %r15
addq %r13, %r15
xorl %r12d, %r12d
movq %r13, 0x18(%rsp)
cmpq %r15, %r13
jae 0x703f
movq %r12, 0x20(%rsp)
movq 0x18(%rsp), %r14
cmpq %r15, %r14
jae 0x7030
testq %r12, %r12
je 0x7026
movl 0x4(%r13), %esi
movl 0x4(%r14), %edx
movq %rbx, %rdi
callq 0x65b1
testq %rax, %rax
je 0x7026
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be8
addl %eax, %ebp
addq $0x20, %r14
addq $-0x20, %r12
jmp 0x6ffa
addq $0x20, %r13
movq 0x20(%rsp), %r12
addq $0x20, %r12
jmp 0x6feb
movq 0x10(%rsp), %rcx
incq %rcx
jmp 0x6fab
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6248
movl %ebp, %eax
addq $0x28, %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/graph.c
// Function: trim_graph_pop_bubbles
int trim_graph_pop_bubbles(graph_t *g)
{
    // TODO a more sophisticated implemetation for complex bubbles
    uint32_t v, v1, v2, nv, na, n_del;
    graph_arc_t *av, *av1, *av2;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        na = graph_arc_n(g, v);
        if (na != 2)
            continue;
        av = graph_arc_a(g, v);
        v1 = av->w;
        v2 = (av + 1)->w;
        if (graph_arc_n(g, v1) == 1 && graph_arc_n(g, v2) == 1) {
            av1 = graph_arc_a(g, v1);
            av2 = graph_arc_a(g, v2);
            if (av1->w == av2->w) {
                n_del += graph_arc_del_existed(g, av);
                n_del += graph_arc_del_existed(g, av + 1);
                n_del += graph_arc_del_existed(g, av1);
                n_del += graph_arc_del_existed(g, av2);
            }
        }
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    printf("#del bubbles: %u\n", n_del);
#endif

    return n_del;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %r12d
addl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %r13, %r12
je 0x7149
movq 0x28(%rbx), %rdx
movq (%rdx,%r13,8), %rax
cmpl $0x2, %eax
jne 0x7141
movq 0x20(%rbx), %rcx
shrq $0x1b, %rax
andq $-0x20, %rax
movl 0x4(%rcx,%rax), %esi
movq (%rdx,%rsi,8), %r14
cmpl $0x1, %r14d
jne 0x7141
leaq (%rcx,%rax), %rsi
movl 0x24(%rsi), %edi
movq (%rdx,%rdi,8), %r15
cmpl $0x1, %r15d
jne 0x7141
shrq $0x1b, %r14
andq $-0x20, %r14
shrq $0x1b, %r15
andq $-0x20, %r15
movl 0x4(%rcx,%r14), %edx
cmpl 0x4(%rcx,%r15), %edx
jne 0x7141
addq %rcx, %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
addq %rcx, %r14
addq %rcx, %r15
movq %rbx, %rdi
callq 0x6be8
addl %ebp, %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x6be8
movl %eax, %ebp
addl 0xc(%rsp), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6be8
movl %eax, %r14d
addl %ebp, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6be8
movl %eax, %ebp
addl %r14d, %ebp
incq %r13
jmp 0x7088
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6248
movl %ebp, %eax
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/graph.c
// Function: trim_graph_pop_undirected
int trim_graph_pop_undirected(graph_t *g)
{
    uint32_t v, w, n_del;
    graph_arc_t *a;
    n_del = 0;
    for (a = g->arc; a < g->arc + g->n_arc; ++a) {
        if (graph_arc_n(g, a->v) != 1)
            continue;
        v = a->v;
        w = a->w;
        if (graph_arc(g, v^1, w) &&
                graph_arc_n(g, v^1) > 1 &&
                graph_arc_n(g, w) > 0) {
            ++n_del;
            graph_arc_del(g, w^1, v, 1);
            graph_arc_del(g, v^1, w, 1);
        }
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #solved undirected: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x20(%rdi), %rcx
movl $0x0, 0xc(%rsp)
movq %rcx, %rbp
movq 0x18(%r14), %rax
shlq $0x5, %rax
addq %rcx, %rax
cmpq %rax, %rbp
jae 0x720f
movq 0x28(%r14), %rbx
movl (%rbp), %r12d
cmpl $0x1, (%rbx,%r12,8)
jne 0x7206
movq %rcx, 0x10(%rsp)
movl 0x4(%rbp), %r15d
movq %r12, %r13
xorq $0x1, %r13
movq %r14, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x65b1
testq %rax, %rax
je 0x7201
testl $0xfffffffe, (%rbx,%r13,8) # imm = 0xFFFFFFFE
je 0x7201
cmpl $0x0, (%rbx,%r15,8)
je 0x7201
incl 0xc(%rsp)
movl %r15d, %esi
xorl $0x1, %esi
movq %r14, %rdi
movl %r12d, %edx
callq 0x722d
movq %r14, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x722d
movq 0x20(%r14), %rcx
jmp 0x7206
movq 0x10(%rsp), %rcx
addq $0x20, %rbp
jmp 0x7185
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6248
movl 0xc(%rsp), %eax
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/./graph.h
// Function: graph_arc_del
static inline void graph_arc_del(graph_t *g, uint32_t v, uint32_t w, int del)
{
    uint32_t i, nv = graph_arc_n(g, v);
    graph_arc_t *av = graph_arc_a(g, v);
    for (i = 0; i < nv; ++i)
        if (av[i].w == w) 
            av[i].del = !!del;
}

// Assembly:
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rax
movl %esi, %esi
movq (%rax,%rsi,8), %rsi
movl %esi, %eax
shlq $0x5, %rax
shrq $0x1b, %rsi
andq $-0x20, %rsi
addq %rsi, %rcx
addq $0x18, %rcx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x7268
cmpl %edx, -0x14(%rcx,%rsi)
jne 0x7262
orb $0x40, 0x7(%rcx,%rsi)
addq $0x20, %rsi
jmp 0x7252
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: trim_graph_weak_edges
int trim_graph_weak_edges(graph_t *g)
{
    uint32_t n_del;
    graph_arc_t *a;
    n_del = 0;
    for (a = g->arc; a < g->arc + g->n_arc; ++a)
        if (exist_strong_edge(g, a->v, a->wt) && exist_strong_edge(g, a->w^1, a->wt))
            n_del += graph_arc_del_existed(g, a);

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del weak edges: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %r12
xorl %ebx, %ebx
movq %r12, %r15
movq 0x18(%r14), %rax
shlq $0x5, %rax
addq %r12, %rax
cmpq %rax, %r15
jae 0x72d6
movl (%r15), %esi
movsd 0x10(%r15), %xmm0
movq %r14, %rdi
movsd %xmm0, (%rsp)
callq 0x72ef
testl %eax, %eax
je 0x72d0
movl 0x4(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x72ef
testl %eax, %eax
je 0x72d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6be8
addl %eax, %ebx
movq 0x20(%r14), %r12
addq $0x20, %r15
jmp 0x727d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6248
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: exist_strong_edge
static inline int exist_strong_edge(graph_t *g, uint32_t v, double wt)
{
    uint32_t na;
    graph_arc_t *a, *av;
    na = graph_arc_n(g, v);
    if (na < 2) 
        return 0;
    av = graph_arc_a(g, v);
    for (a = av; a < av + na; ++a)
        if (a->wt > wt)
            return 1;
    return 0;
}

// Assembly:
movq 0x28(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rdx
xorl %eax, %eax
testl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
je 0x7334
movq %rdx, %rcx
shrq $0x1b, %rcx
andq $-0x20, %rcx
addq 0x20(%rdi), %rcx
movl %edx, %edx
shlq $0x5, %rdx
addq %rcx, %rdx
pushq $0x1
popq %rsi
cmpq %rdx, %rcx
jae 0x7334
movsd 0x10(%rcx), %xmm1
addq $0x20, %rcx
ucomisd %xmm0, %xmm1
jbe 0x731e
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/graph.c
// Function: trim_graph_ambiguous_edges
int trim_graph_ambiguous_edges(graph_t *g)
{
    uint32_t n_del;
    graph_arc_t *a;
    n_del = 0;
    for (a = g->arc; a < g->arc + g->n_arc; ++a)
        if (graph_arc_n(g, a->v) > 1 || graph_arc_n(g, a->w^1) > 1)
            n_del += graph_arc_del_existed(g, a);

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del ambiguous edges: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
xorl %ebx, %ebx
movq %rax, %r15
movq 0x18(%r14), %rcx
shlq $0x5, %rcx
addq %rax, %rcx
cmpq %rcx, %r15
jae 0x738e
movq 0x28(%r14), %rcx
movl (%r15), %edx
testl $0xfffffffe, (%rcx,%rdx,8) # imm = 0xFFFFFFFE
jne 0x7377
movl 0x4(%r15), %edx
xorq $0x1, %rdx
testl $0xfffffffe, (%rcx,%rdx,8) # imm = 0xFFFFFFFE
je 0x7388
movq %r14, %rdi
movq %r15, %rsi
callq 0x6be8
addl %eax, %ebx
movq 0x20(%r14), %rax
addq $0x20, %r15
jmp 0x7346
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6248
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/link.c
// Function: kh_resize_str
KHASH_SET_INIT_STR(str)

void intra_link_mat_destroy(intra_link_mat_t *link_mat)
{
    if (!link_mat) return;
    uint32_t i;
    for (i = 0; i < link_mat->n; ++i)
        if (link_mat->links[i].n)
            free(link_mat->links[i].link);
    if (link_mat->links)
        free(link_mat->links);
    free(link_mat);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
cmpl $0x5, %eax
pushq $0x4
popq %rcx
movl %ecx, %r13d
cmovael %eax, %r13d
cvtsi2sd %r13, %xmm0
mulsd 0x106c3(%rip), %xmm0    # 0x1e648
addsd 0x10253(%rip), %xmm0    # 0x1e1e0
cvttsd2si %xmm0, %rdx
xorl %r12d, %r12d
cmpl %edx, 0x4(%rdi)
jae 0xe131
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movl %r13d, %r15d
shrl $0x2, %r15d
andl $-0x4, %r15d
cmpl $0x10, %eax
cmovbl %ecx, %r15d
xorl %edi, %edi
movq %r15, %rsi
callq 0x853c
pushq $-0x1
popq %r12
testq %rax, %rax
je 0xe131
movq %rax, %r14
movq %rax, %rdi
movl $0xaa, %esi
movq %r15, %rdx
callq 0x21e0
movl (%rbx), %edx
movl %r13d, %r15d
cmpl %r13d, %edx
jae 0xe00e
movq 0x18(%rbx), %rsi
leaq (,%r15,8), %rdx
xorl %edi, %edi
callq 0x8644
testq %rax, %rax
je 0xe143
movq %rax, 0x18(%rbx)
movl (%rbx), %edx
movq %r15, 0x10(%rsp)
movq %r13, 0x18(%rsp)
leal -0x1(%r13), %r15d
xorl %r8d, %r8d
pushq $0x2
popq %r13
cmpl %edx, %r8d
je 0xe0ec
movq 0x10(%rbx), %rbp
movl %r8d, %eax
shrl $0x4, %eax
movl (%rbp,%rax,4), %esi
leal (%r8,%r8), %ecx
andl $0x1e, %ecx
movl %esi, %edi
shrl %cl, %edi
testb $0x3, %dil
jne 0xe0e4
movq 0x18(%rbx), %rdx
movq %r8, 0x8(%rsp)
movl %r8d, %edi
movq (%rdx,%rdi,8), %r12
btsl %ecx, %esi
movl %esi, (%rbp,%rax,4)
movq %r12, %rdi
callq 0xe14f
xorl %edx, %edx
andl %r15d, %eax
movl %eax, %esi
shrl $0x4, %esi
movl (%r14,%rsi,4), %edi
leal (%rax,%rax), %ecx
andl $0x1e, %ecx
movl %r13d, %r8d
shll %cl, %r8d
testl %edi, %r8d
jne 0xe099
addl %edx, %eax
incl %eax
movl %edx, %ecx
incl %ecx
movl %ecx, %edx
jmp 0xe070
notl %r8d
andl %r8d, %edi
movl %edi, (%r14,%rsi,4)
movl (%rbx), %edx
movl %eax, %edi
cmpl %edx, %eax
jae 0xe0d7
movl (%rbp,%rsi,4), %r8d
shrl %cl, %r8d
movq 0x18(%rbx), %rax
testb $0x3, %r8b
jne 0xe0db
movq (%rax,%rdi,8), %rdx
movq %r12, (%rax,%rdi,8)
pushq $0x1
popq %rax
shll %cl, %eax
movq 0x10(%rbx), %rbp
orl %eax, (%rbp,%rsi,4)
movq %rdx, %r12
jmp 0xe066
movq 0x18(%rbx), %rax
movq 0x8(%rsp), %r8
movq %r12, (%rax,%rdi,8)
incl %r8d
jmp 0xe023
movq 0x18(%rsp), %r15
cmpl %r15d, %edx
jbe 0xe10e
movq 0x18(%rbx), %rsi
movq 0x10(%rsp), %rdx
shlq $0x3, %rdx
xorl %edi, %edi
callq 0x8644
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rsi
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x8447
movq %r14, 0x10(%rbx)
movl %r15d, (%rbx)
movl 0x4(%rbx), %eax
movl %eax, 0x8(%rbx)
movq 0x20(%rsp), %rax
movl %eax, 0xc(%rbx)
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
movq %r14, %rsi
callq 0x8447
jmp 0xe131
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/link.c
// Function: inter_link_mat_destroy
void inter_link_mat_destroy(inter_link_mat_t *link_mat)
{
    if (!link_mat) return;
    uint32_t i, j;
    for (i = 0; i < link_mat->n; ++i) {
        if (link_mat->links[i].n) {
            for (j = 0; j < 4; ++j) {
                free(link_mat->links[i].link[j]);
                free(link_mat->links[i].linkb[j]);
            }
        }
    }
    if (link_mat->links)
        free(link_mat->links);
    free(link_mat);
}

// Assembly:
testq %rdi, %rdi
je 0x9544
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x4
popq %r15
xorl %r12d, %r12d
movl (%rbx), %eax
movq 0x10(%rbx), %rdi
cmpq %rax, %r12
jae 0x9529
movq %r12, %rax
shlq $0x7, %rax
cmpl $0x0, 0x14(%rdi,%rax)
je 0x9520
movq %r14, %r13
movq %r15, %rbp
subq $0x1, %rbp
jb 0x9520
movq 0x10(%rbx), %rax
movq 0x20(%rax,%r13), %rdi
callq 0x2060
movq 0x10(%rbx), %rax
movq 0x40(%rax,%r13), %rdi
callq 0x2060
addq $0x8, %r13
jmp 0x94f8
incq %r12
subq $-0x80, %r14
jmp 0x94d9
callq 0x2060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]yahs/link.c
// Function: estimate_inter_link_mat_init_rss
long estimate_inter_link_mat_init_rss(asm_dict_t *dict, uint32_t resolution, uint32_t radius)
{
    long bytes, p, m;
    uint32_t i, j, b0, b1, n, r, r2;

    n = dict->n;
    m = (long) n * (n - 1) / 2;
    if (m > UINT32_MAX)
        return -1;

    r2 = resolution * 2;

    bytes = 0;
    bytes += sizeof(inter_link_mat_t);
    bytes += m * sizeof(inter_link_t);

    for (i = 0; i < n; ++i) {
        if (dict->s[i].len < r2)
            continue;

        b0 = MIN(radius, div_ceil(dict->s[i].len, r2));
        for (j = i + 1; j < n; ++j) {
            if (dict->s[j].len < r2)
                continue;

            b1 = MIN(radius, div_ceil(dict->s[j].len, r2));
            p = b0 * b1;
            if (p > UINT32_MAX)
                return -1;
            r = MIN(radius, (uint32_t) (b0 + b1 - 1));

            bytes += (p + r) * 4 * sizeof(double);
        }
    }

    return bytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0xc(%rsp)
movl (%rdi), %ebp
leal -0x1(%rbp), %eax
imulq %rbp, %rax
movq %rax, %rcx
shrq $0x21, %rcx
je 0x987b
pushq $-0x1
popq %rax
jmp 0x9966
movl %esi, %r14d
movq %rdi, %r15
addl %r14d, %r14d
shlq $0x6, %rax
movabsq $0x7fffffff80, %rcx     # imm = 0x7FFFFFFF80
andq %rax, %rcx
orq $0x18, %rcx
movq %rcx, 0x10(%rsp)
xorl %r12d, %r12d
cmpq %rbp, %r12
je 0x9961
movq 0x8(%r15), %rax
imulq $0x58, %r12, %rbx
movq 0x8(%rax,%rbx), %rdi
cmpq %r14, %rdi
jae 0x98c1
incq %r12
jmp 0x98a1
movl %r14d, %esi
callq 0x28ff
movl 0xc(%rsp), %ecx
movl %ecx, %esi
cmpl %ecx, %eax
ja 0x98e6
movq 0x8(%r15), %rax
movq 0x8(%rax,%rbx), %rdi
movl %r14d, %esi
callq 0x28ff
movl %eax, %esi
leal -0x1(%rsi), %r8d
movl %r12d, %r13d
incl %r13d
cmpl %ebp, %r13d
jae 0x98bc
movq 0x8(%r15), %rax
movl %r13d, %ecx
imulq $0x58, %rcx, %rbx
movq 0x8(%rax,%rbx), %rdi
cmpq %r14, %rdi
jb 0x98ed
movq %r8, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movl %r14d, %esi
callq 0x28ff
movl %eax, %ecx
movl 0xc(%rsp), %edx
movl %edx, %eax
cmpl %edx, %ecx
ja 0x9939
movq 0x8(%r15), %rax
movq 0x8(%rax,%rbx), %rdi
movl %r14d, %esi
callq 0x28ff
movq 0x18(%rsp), %r8
leal (%r8,%rax), %ecx
movq 0x20(%rsp), %rsi
imull %esi, %eax
movl 0xc(%rsp), %edx
cmpl %edx, %ecx
cmovael %edx, %ecx
addq %rax, %rcx
shlq $0x5, %rcx
addq %rcx, 0x10(%rsp)
jmp 0x98ed
movq 0x10(%rsp), %rax
addq $0x28, %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/link.c
// Function: intra_link_mat_init
intra_link_mat_t *intra_link_mat_init(void *dict, uint32_t resolution, int use_gap_seq)
{
    intra_link_mat_t *link_mat;
    intra_link_t *link;
    uint32_t i, n, b, p;
    uint64_t len;

    n = use_gap_seq? ((asm_dict_t *) dict)->n : ((sdict_t *) dict)->n;
    link_mat = (intra_link_mat_t *) malloc(sizeof(intra_link_mat_t));
    link_mat->n = n;
    link_mat->links = (intra_link_t *) calloc(n, sizeof(intra_link_t));

    for (i = 0; i < n; ++i) {
        link = &link_mat->links[i];
        link->c = i;
        len = use_gap_seq? ((asm_dict_t *) dict)->s[i].len : ((sdict_t *) dict)->s[i].len;
        if (len < resolution) {
            link->n = 0;
            continue;
        }
        b = div_ceil(len, resolution);
        link->n = b;
        p = (long) b * (b + 1) / 2;
        link->link = (double *) calloc(p, sizeof(double));
        if (!link->link) {
            fprintf(stderr, "[E::%s] memory allocation failure\n", __func__);
            exit(EXIT_FAILURE);
        }

#ifdef DEBUG_INTRA
        fprintf(stderr, "[DEBUG_INTRA::%s] %s bins: %d\n", __func__, use_gap_seq? ((asm_dict_t *) dict)->s[i].name : ((sdict_t *) dict)->s[i].name, link->n);
#endif
    }

    return link_mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movl %esi, %ebx
movq %rdi, 0x10(%rsp)
movl (%rdi), %r15d
pushq $0x10
popq %r12
movq %r12, %rdi
callq 0x2330
movq %rax, %r14
movl %r15d, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2290
movq %rax, %r13
movq %r14, 0x8(%rsp)
movq %rax, 0x8(%r14)
movl %ebx, (%rsp)
movl %ebx, %ebp
addq $0x8, %r13
pushq $0x8
popq %r14
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x9a33
movl %ebx, -0x8(%r13)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rsp)
je 0x99e8
movq (%rax,%r14), %rdi
jmp 0x99ec
movl (%rax,%r12), %edi
cmpq %rbp, %rdi
jae 0x99f8
andl $0x0, -0x4(%r13)
jmp 0x9a22
movl (%rsp), %esi
callq 0x28ff
movl %eax, -0x4(%r13)
movl %eax, %ecx
incl %eax
imulq %rcx, %rax
shrq %rax
movl %eax, %edi
pushq $0x8
popq %rsi
callq 0x2290
movq %rax, (%r13)
testq %rax, %rax
je 0x9a47
incq %rbx
addq $0x10, %r13
addq $0x18, %r12
addq $0x58, %r14
jmp 0x99c9
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1e5aa(%rip), %rax     # 0x27ff8
movq (%rax), %rdi
leaq 0x14c5b(%rip), %rsi     # 0x1e6b3
leaq 0x14c8b(%rip), %rdx     # 0x1e6ea
xorl %eax, %eax
callq 0x22c0
pushq $0x1
popq %rdi
callq 0x24b0