LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: copy_ug_node(ma_ug_t*, asg_t*, unsigned int)
uint32_t copy_ug_node(ma_ug_t *ug, asg_t* nsg, uint32_t v)
{
    ma_utg_t *p;
    ma_utg_t *o = &(ug->u.a[v]);
    uint32_t n_node = nsg->n_seq;
    asg_seq_set(nsg, n_node, nsg->seq[v].len, 0);
    kv_pushp(ma_utg_t, ug->u, &p);

    p->s = 0, p->start = o->start, p->end = o->end, p->len = o->len;
    p->n = o->n, p->circ = o->circ, p->m = o->m;
    p->a = (uint64_t*)malloc(8 * p->m);
    memcpy(p->a, o->a, (8*p->m));

    return n_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %r15
movq 0x10(%rdi), %r12
movl %edx, %r13d
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movl 0x14(%rsi), %esi
andl %ebp, %esi
movq 0x20(%rcx), %rax
movl (%rax,%r13,8), %edx
andl %ebp, %edx
movq %rcx, %rdi
movl %esi, 0x4(%rsp)
xorl %ecx, %ecx
callq 0xa0887
movq (%r15), %rax
movq 0x10(%r15), %r14
cmpq 0x8(%r15), %rax
jne 0xf0018
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x2, %eax
cmovneq %rcx, %rax
movq %rax, 0x8(%r15)
shlq $0x3, %rax
leaq (%rax,%rax,4), %rsi
movq %r14, %rdi
callq 0x2370
movq %rax, %r14
movq %rax, 0x10(%r15)
movq (%r15), %rax
leaq (%r13,%r13,4), %r13
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
leaq (%rax,%rax,4), %rbx
movq $0x0, 0x20(%r14,%rbx,8)
movq 0x4(%r12,%r13,8), %rax
movq %rax, 0x4(%r14,%rbx,8)
andl (%r12,%r13,8), %ebp
movl $0x80000000, %eax       # imm = 0x80000000
movl (%r14,%rbx,8), %ecx
andl %eax, %ecx
orl %ebp, %ecx
movl %ecx, (%r14,%rbx,8)
movl 0x10(%r12,%r13,8), %ecx
movl %ecx, 0x10(%r14,%rbx,8)
andl (%r12,%r13,8), %eax
orl %ebp, %eax
movl %eax, (%r14,%rbx,8)
movl 0xc(%r12,%r13,8), %r15d
movl %r15d, 0xc(%r14,%rbx,8)
shll $0x3, %r15d
movq %r15, %rdi
callq 0x2280
movq %rax, 0x18(%r14,%rbx,8)
movq 0x18(%r12,%r13,8), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2160
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: collect_ma_utg_ts(ma_ug_t*, unsigned int, unsigned int, ma_utg_t*)
uint32_t collect_ma_utg_ts(ma_ug_t *ug, uint32_t v, uint32_t w, ma_utg_t* result)
{
    uint32_t des_dir = w&1;
    long long i;
    uint64_t* aim = NULL;
    ma_utg_t *ma_w = &(ug->u.a[w>>1]);

    if(v == (uint32_t)-1)
    {
        result->start = ma_w->start;
        result->circ = ma_w->circ;
        result->end = ma_w->end;
        result->len = ma_w->len;
        result->n = 0;
    }

    
    if(result->m < (result->n + ma_w->n))
    {
        result->m = (result->n + ma_w->n);
        result->a = (uint64_t*)realloc(result->a, result->m * sizeof(uint64_t));
    }

    aim = result->a + result->n;

    if(des_dir == 1)
    {
        for (i = 0; i < (long long)ma_w->n; i++)
        {
            aim[ma_w->n - i - 1] = (ma_w->a[i])^(uint64_t)(0x100000000);
        }
    }
    else
    {
        for (i = 0; i < (long long)ma_w->n; i++)
        {
            aim[i] = ma_w->a[i];
        }
    }

    result->n = result->n + ma_w->n;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %edx, %eax
shrl %eax
leaq (%rax,%rax,4), %r14
shlq $0x3, %r14
addq 0x10(%rdi), %r14
cmpl $-0x1, %esi
je 0xf00c5
movl 0x10(%rbx), %ecx
jmp 0xf00f8
movl 0x4(%r14), %eax
movl %eax, 0x4(%rbx)
movl $0x80000000, %eax       # imm = 0x80000000
andl (%r14), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl (%rbx), %edx
andl %ecx, %edx
orl %eax, %edx
movl %edx, (%rbx)
movl 0x8(%r14), %edx
movl %edx, 0x8(%rbx)
andl (%r14), %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
movl $0x0, 0x10(%rbx)
xorl %ecx, %ecx
movl 0x10(%r14), %eax
addl %ecx, %eax
cmpl %eax, 0xc(%rbx)
jae 0xf011e
movl %eax, 0xc(%rbx)
movq 0x18(%rbx), %rdi
movl %eax, %esi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x18(%rbx)
movl 0x10(%rbx), %ecx
jmp 0xf0122
movq 0x18(%rbx), %rax
movl %ecx, %ecx
movl 0x10(%r14), %edx
testb $0x1, %bpl
jne 0xf014e
testl %edx, %edx
je 0xf0180
leaq (%rax,%rcx,8), %rax
movq 0x18(%r14), %rsi
xorl %edi, %edi
movq (%rsi,%rdi,8), %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0xf013c
jmp 0xf0182
testl %edx, %edx
je 0xf0180
movq 0x18(%r14), %rsi
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
movabsq $0x100000000, %rdi      # imm = 0x100000000
movq %rdx, %r8
movq (%rsi), %r9
xorq %rdi, %r9
movq %r9, (%rax,%r8,8)
addq $0x8, %rsi
decq %r8
jne 0xf016b
jmp 0xf0182
xorl %edx, %edx
addl %edx, %ecx
movl %ecx, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_arc_t(Edge_iter*, asg_arc_t*)
int get_arc_t(Edge_iter* x, asg_arc_t* get)
{
    for (; x->av_i < x->nv; x->av_i++)
    {
        if(x->av[x->av_i].del) continue;
        get = &(x->av[x->av_i]);
        x->av_i++;
        return 1;
    }


    for (; x->new_edges_i < x->new_edges_n; x->new_edges_i++)
    {
        if(x->new_edges[x->new_edges_i].del) continue;
        get = &(x->new_edges[x->new_edges_i]);
        x->new_edges_i++;
        return 1;
    }

    return 0;
}

// Assembly:
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
cmpl %edx, %ecx
jae 0xf1413
leaq 0x14(%rdi), %rax
movq 0x8(%rdi), %rsi
leaq (%rcx,%rcx,2), %r8
leaq (%rsi,%r8,8), %rsi
addq $0xc, %rsi
negl %edx
leal 0x1(%rcx), %r8d
cmpl $0x0, (%rsi)
jns 0xf145c
incq %rcx
movl %r8d, (%rax)
addq $0x18, %rsi
leal (%rdx,%r8), %r9d
incl %r9d
incl %r8d
cmpl $0x1, %r9d
jne 0xf13f4
movl 0x20(%rdi), %edx
movl 0x24(%rdi), %ecx
xorl %eax, %eax
cmpl %edx, %ecx
jae 0xf1458
movq 0x18(%rdi), %rsi
addq $0x24, %rdi
leaq (%rcx,%rcx,2), %r8
leaq (%rsi,%r8,8), %rsi
addq $0xc, %rsi
negl %edx
leal 0x1(%rcx), %r8d
cmpl $0x0, (%rsi)
jns 0xf1459
incq %rcx
movl %r8d, (%rdi)
addq $0x18, %rsi
leal (%rdx,%r8), %r9d
incl %r9d
incl %r8d
cmpl $0x1, %r9d
jne 0xf1439
retq
movq %rdi, %rax
incl %ecx
movl %ecx, (%rax)
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: load_coverage_cut(ma_sub_t**, char*)
int load_coverage_cut(ma_sub_t** coverage_cut, char* read_file_name)
{
    char* index_name = (char*)malloc(strlen(read_file_name)+15);
    sprintf(index_name, "%s.bin", read_file_name);
    FILE* fp = fopen(index_name, "r");
    if(!fp)
    {
        return 0;
    }
    int f_flag = 0;
    uint64_t n_read;
    f_flag += fread(&n_read, sizeof(n_read), 1, fp);
    (*coverage_cut) = (ma_sub_t*)malloc(sizeof(ma_sub_t)*n_read);

    // uint64_t i = 0, tmp;
    // for (i = 0; i < n_read; i++)
    // {
    //     f_flag += fread(&tmp, sizeof(tmp), 1, fp);
    //     (*coverage_cut)[i].c = tmp;
    //     f_flag += fread(&tmp, sizeof(tmp), 1, fp);
    //     (*coverage_cut)[i].del = tmp;
    //     f_flag += fread(&tmp, sizeof(tmp), 1, fp);
    //     (*coverage_cut)[i].e = tmp;
    //     f_flag += fread(&tmp, sizeof(tmp), 1, fp);
    //     (*coverage_cut)[i].s = tmp;
    // }
    fread((*coverage_cut), sizeof((*((*coverage_cut)))), n_read, fp);

    free(index_name);    
    fflush(fp);
    fclose(fp);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2090
leaq 0xf(%rax), %rdi
callq 0x2280
movq %rax, %r14
leaq 0x13e1f3(%rip), %rsi    # 0x23064b
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x14d389(%rip), %rsi    # 0x23f7f7
movq %r14, %rdi
callq 0x2210
testq %rax, %rax
je 0xf24e0
movq %rax, %r15
leaq 0x8(%rsp), %r12
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rax, %rcx
callq 0x22f0
movq (%r12), %r12
leaq (,%r12,4), %rax
leaq (%rax,%rax,2), %rdi
callq 0x2280
movq %rax, (%rbx)
movl $0xc, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x22f0
movq %r14, %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2200
movq %r15, %rdi
callq 0x2190
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_coverage_cut(ma_sub_t*, char*, unsigned long)
int write_coverage_cut(ma_sub_t* coverage_cut, char* read_file_name, uint64_t n_read)
{
    char* index_name = (char*)malloc(strlen(read_file_name)+15);
    sprintf(index_name, "%s.bin", read_file_name);
    FILE* fp = fopen(index_name, "w");
    fwrite(&n_read, sizeof(n_read), 1, fp);
    // uint64_t i = 0, tmp;
    // for (i = 0; i < n_read; i++)
    // {
    //     tmp = coverage_cut[i].c;
    //     fwrite(&tmp, sizeof(tmp), 1, fp);
    //     tmp = coverage_cut[i].del;
    //     fwrite(&tmp, sizeof(tmp), 1, fp);
    //     tmp = coverage_cut[i].e;
    //     fwrite(&tmp, sizeof(tmp), 1, fp);
    //     tmp = coverage_cut[i].s;
    //     fwrite(&tmp, sizeof(tmp), 1, fp);
    // }
    fwrite(coverage_cut, sizeof((*(coverage_cut))), n_read, fp);
    free(index_name);    
    fflush(fp);
    fclose(fp);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r14
movq %rdx, (%r14)
movq %rsi, %rdi
callq 0x2090
leaq 0xf(%rax), %rdi
callq 0x2280
movq %rax, %r15
leaq 0x13e12d(%rip), %rsi    # 0x23064b
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x1561b0(%rip), %rsi    # 0x2486e2
movq %r15, %rdi
callq 0x2210
movq %rax, %r12
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x2410
movq (%r14), %rdx
movl $0xc, %esi
movq %rbx, %rdi
movq %r12, %rcx
callq 0x2410
movq %r15, %rdi
callq 0x2220
movq %r12, %rdi
callq 0x2200
movq %r12, %rdi
callq 0x2190
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_ruIndex(R_to_U*, char*)
int write_ruIndex(R_to_U* ruIndex, char* read_file_name)
{
    char* index_name = (char*)malloc(strlen(read_file_name)+15);
    sprintf(index_name, "%s.bin", read_file_name);
    FILE* fp = fopen(index_name, "w");
    fwrite(&ruIndex->len, sizeof(ruIndex->len), 1, fp);
    fwrite(ruIndex->index, sizeof(ruIndex->index[0]), ruIndex->len, fp);
    fwrite(R_INF.trio_flag, sizeof(R_INF.trio_flag[0]), ruIndex->len, fp);
    // fwrite(ruIndex->is_het, 1, ruIndex->len, fp);
    fwrite(&(asm_opt.hom_global_coverage_set), sizeof(asm_opt.hom_global_coverage_set), 1, fp);
    fwrite(&(asm_opt.hom_global_coverage), sizeof(asm_opt.hom_global_coverage), 1, fp);
    free(index_name);    
    fflush(fp);
    fclose(fp);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2090
leaq 0xf(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x13e097(%rip), %rsi    # 0x23064b
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x15611a(%rip), %rsi    # 0x2486e2
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x2410
movq (%r15), %rdx
movq 0x8(%r15), %rdi
movl $0x4, %esi
movq %r14, %rcx
callq 0x2410
leaq 0x1a3c2d(%rip), %rax    # 0x296230
movq 0x28(%rax), %rdi
movq (%r15), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x2410
leaq 0x1a313a(%rip), %r15    # 0x295758
leaq 0x148(%r15), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2410
addq $0x144, %r15            # imm = 0x144
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2410
movq %rbx, %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2190
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: load_ruIndex(R_to_U*, char*)
int load_ruIndex(R_to_U* ruIndex, char* read_file_name)
{
    char* index_name = (char*)malloc(strlen(read_file_name)+15);
    sprintf(index_name, "%s.bin", read_file_name);
    FILE* fp = fopen(index_name, "r");
    if(!fp)
    {
        return 0;
    }
    int f_flag = 0;
    f_flag += fread(&(ruIndex)->len, sizeof((ruIndex)->len), 1, fp);
    (ruIndex)->index = (uint32_t*)malloc(sizeof(uint32_t)*(ruIndex)->len);
    f_flag += fread((ruIndex)->index, sizeof((*((ruIndex)->index))), (ruIndex)->len, fp);

    if(!(asm_opt.ar)) {
        R_INF.trio_flag = (uint8_t*)malloc(sizeof(uint8_t)*(ruIndex)->len);
        f_flag += fread(R_INF.trio_flag, sizeof((*(R_INF.trio_flag))), (ruIndex)->len, fp);
    } else {
        fseek(fp, sizeof((*(R_INF.trio_flag)))*(ruIndex)->len, SEEK_CUR);
    }

    // CALLOC(ruIndex->is_het, ruIndex->len);
    // f_flag += fread(ruIndex->is_het, 1, ruIndex->len, fp);

    f_flag += fread(&(asm_opt.hom_global_coverage_set), sizeof(asm_opt.hom_global_coverage_set), 1, fp);
    f_flag += fread(&(asm_opt.hom_global_coverage), sizeof(asm_opt.hom_global_coverage), 1, fp);

    free(index_name);    
    fflush(fp);
    fclose(fp);

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2090
leaq 0xf(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x13dfac(%rip), %rsi    # 0x23064b
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x14d142(%rip), %rsi    # 0x23f7f7
movq %rbx, %rdi
callq 0x2210
testq %rax, %rax
je 0xf27a2
movq %rax, %r14
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x22f0
movq (%r15), %r12
leaq (,%r12,4), %rdi
callq 0x2280
movq %rax, 0x8(%r15)
movl $0x4, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0x1a304c(%rip), %r12    # 0x295758
cmpq $0x0, 0x68(%r12)
movq (%r15), %r15
je 0xf2729
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x21b0
jmp 0xf274f
movq %r15, %rdi
callq 0x2280
leaq 0x1a3af8(%rip), %rcx    # 0x296230
movq %rax, 0x28(%rcx)
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0x148(%r12), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22f0
addq $0x144, %r12            # imm = 0x144
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x22f0
movq %rbx, %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2190
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: set_r_het_status(unsigned char*, kv_gg_status*, ma_ug_t*, unsigned int)
void set_r_het_status(uint8_t* r_het, kv_gg_status *sa, ma_ug_t *ug, uint32_t hapN)
{
    uint32_t i, k, o, f;
    ma_utg_t *u;
    mcg_node_t s;
    for (i = 0; i < sa->n; i++)
    {
        u = &(ug->u.a[i]);
        s = sa->a[i].s; o = 0;
        while (s) {
            o += (s&1); s>>=1;
        }

        f = N_HET;
        if(o < hapN) f = C_HET;
        for (k = 0; k < u->n; k++) r_het[u->a[k]>>33] = f;
    }
}

// Assembly:
movq 0x8(%rsi), %r8
testq %r8, %r8
je 0xf3992
pushq %rbx
xorl %eax, %eax
movq (%rsi), %r9
movq %rax, %r10
shlq $0x5, %r10
movl (%r9,%r10), %r10d
movl $0x0, %r9d
testl %r10d, %r10d
je 0xf394d
xorl %r9d, %r9d
movl %r10d, %r11d
movl %r10d, %ebx
andl $0x1, %ebx
addl %ebx, %r9d
shrl %r11d
cmpl $0x1, %r10d
movl %r11d, %r10d
ja 0xf3938
leaq (%rax,%rax,4), %r10
shlq $0x3, %r10
addq 0x10(%rdx), %r10
cmpl $0x0, 0x10(%r10)
je 0xf398a
cmpl %ecx, %r9d
setb %r8b
xorl %r9d, %r9d
movq 0x18(%r10), %r11
movq (%r11,%r9,8), %r11
shrq $0x21, %r11
movb %r8b, (%rdi,%r11)
incq %r9
movl 0x10(%r10), %r11d
cmpq %r11, %r9
jb 0xf396a
movq 0x8(%rsi), %r8
incl %eax
cmpq %rax, %r8
ja 0xf3919
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: output_tips(asg_t*, All_reads const*)
int output_tips(asg_t *g, const All_reads *RNF)
{
	uint32_t v, n_vtx = g->n_seq * 2;
    for (v = 0; v < n_vtx; ++v)
    {
        if (g->seq[v>>1].del) continue;

        if(asg_arc_n(g, v) == 0)
        {
            fprintf(stderr, "%.*s\n",
             (int)Get_NAME_LENGTH((*RNF), v>>1), 
             Get_NAME((*RNF), v>>1));
        }
    }

    return 1;
}

// Assembly:
movl 0x14(%rdi), %eax
addl %eax, %eax
je 0xf39f1
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsi), %r15
addq $0x8, %rbx
movl %eax, %r12d
xorl %r13d, %r13d
movq 0x20(%r14), %rax
movl %r13d, %esi
shrl %esi
cmpl $0x0, (%rax,%rsi,8)
js 0xf39d1
movq 0x28(%r14), %rax
cmpl $0x0, (%rax,%r13,8)
je 0xf39db
incq %r13
cmpq %r13, %r12
jne 0xf39b7
jmp 0xf39e8
movq %r15, %rdi
movq %rbx, %rdx
callq 0x11984
jmp 0xf39d1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_coverage(ma_hit_t_alloc*, ma_sub_t*, unsigned long)
long long get_coverage(ma_hit_t_alloc* sources, ma_sub_t* coverage_cut, uint64_t n_read)
{
    uint64_t i, j;
    ma_hit_t *h;
    long long R_bases = 0, C_bases = 0;
    for (i = 0; i < n_read; ++i) 
    {
        R_bases += coverage_cut[i].e - coverage_cut[i].s;
        for (j = 0; j < (uint64_t)(sources[i].length); j++)
        {
            h = &(sources[i].buffer[j]);
            C_bases += Get_qe((*h)) - Get_qs((*h));
        }
    }

    return C_bases/R_bases;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %r9d, %r9d
leaq (%r9,%r9,2), %r10
movl 0xc(%rdi,%r10,8), %ebx
testq %rbx, %rbx
je 0xf3f27
leaq (%rdi,%r10,8), %r11
movq (%r11), %r11
shlq $0x3, %rbx
leaq (%rbx,%rbx,4), %rbx
xorl %r14d, %r14d
movl 0x8(%r11,%r14), %r15d
subl (%r11,%r14), %r15d
addq %r15, %rax
addq $0x28, %r14
cmpq %r14, %rbx
jne 0xf3f12
movl 0x4(%rsi,%r10,4), %r11d
movl (%rsi,%r10,4), %r10d
andl %r8d, %r10d
subl %r10d, %r11d
addq %r11, %rcx
incq %r9
cmpq %rdx, %r9
jne 0xf3ef2
cqto
idivq %rcx
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: pre_clean(ma_hit_t_alloc*, ma_sub_t*, asg_t*, unsigned int)
void pre_clean(ma_hit_t_alloc* sources, ma_sub_t* coverage_cut, asg_t *sg, uint32_t pop_s_node)
{
    int tri_flag = 0;
    while(1)
    {
        tri_flag = 0;
        ///remove very simple circle
        tri_flag += asg_arc_del_simple_circle_untig(sources, coverage_cut, sg, 100, 0);

        ///remove isoloated single read
        if(pop_s_node)
        {
            tri_flag += asg_arc_del_single_node_directly(sg, asm_opt.max_short_tip, sources);///remove very small bubbles
        } 
        
        // if ((!ha_opt_triobin(&asm_opt))&&(!ha_opt_hic(&asm_opt)))
        // {
        //     tri_flag += asg_arc_del_triangular_advance(sg, bubble_dist);
        //     ///remove the cross at the bubble carefully, just remove inexact cross
        //     tri_flag += asg_arc_del_cross_bubble(sg, bubble_dist);
        // }
        // tri_flag += asg_arc_del_single_node_directly(sg, asm_opt.max_short_tip, sources);

        if(tri_flag == 0)
        {
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x1a17f4(%rip), %r13    # 0x295758
movl $0x64, %ecx
movq %r14, %rdx
xorl %r8d, %r8d
callq 0xe96a2
movq %rax, %r12
testl %ebx, %ebx
je 0xf3f93
movslq 0x11c(%r13), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xa9594
addl %r12d, %eax
movl %eax, %r12d
testl %r12d, %r12d
jne 0xf3f64
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_delete_node_by_trio(asg_t*, unsigned char)
void asg_delete_node_by_trio(asg_t* sg, uint8_t flag)
{
    uint32_t v, n_vtx = sg->n_seq;
    for (v = 0; v < n_vtx; ++v) 
    {
        if (sg->seq[v].del) continue;
        if (R_INF.trio_flag[v] == AMBIGU) continue;
        if(R_INF.trio_flag[v] != flag) asg_seq_del(sg, v);
    }
    asg_cleanup(sg);
}

// Assembly:
movl 0x14(%rdi), %eax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
je 0xa0a7d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ecx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq 0x20(%rdi), %r9
movl (%r9,%rcx,8), %r10d
testl %r10d, %r10d
js 0xf40d9
leaq 0x1a2230(%rip), %rdx    # 0x296230
movq 0x28(%rdx), %r11
movb (%r11,%rcx), %r11b
testb %r11b, %r11b
sete %bl
cmpb %sil, %r11b
sete %r11b
orb %bl, %r11b
jne 0xf40d9
orl $0x80000000, %r10d      # imm = 0x80000000
movl %r10d, (%r9,%rcx,8)
leaq (%rcx,%rcx), %r9
movb $0x1, %r10b
xorl %r11d, %r11d
orq %r9, %r11
movq 0x28(%rdi), %rbx
movq (%rbx,%r11,8), %r14
movq %r14, %rbx
andq %r8, %rbx
je 0xf40c3
shrq $0x20, %r14
leaq (%r14,%r14,2), %r14
shlq $0x3, %r14
addq 0x8(%rdi), %r14
xorl %r15d, %r15d
leaq (%r15,%r15,2), %r12
orb $-0x80, 0xf(%r14,%r12,8)
movl 0x8(%r14,%r12,8), %r12d
xorq $0x1, %r12
movq 0x28(%rdi), %r13
movq (%r13,%r12,8), %r13
movq %r13, %r12
andq %r8, %r12
je 0xf40bb
movq 0x8(%rdi), %rbp
shrq $0x20, %r13
shlq $0x3, %r12
leaq (%r12,%r12,2), %r12
leaq (%r13,%r13,2), %r13
leaq 0xc(,%r13,8), %r13
addq %rbp, %r13
xorl %ebp, %ebp
movl -0x4(%r13,%rbp), %edx
xorl %r11d, %edx
cmpl $0x1, %edx
jne 0xf40b2
orb $-0x80, 0x3(%r13,%rbp)
addq $0x18, %rbp
cmpq %rbp, %r12
jne 0xf409f
incq %r15
cmpq %rbx, %r15
jne 0xf4059
movl $0x1, %r11d
testb $0x1, %r10b
movl $0x0, %r10d
jne 0xf4033
incq %rcx
cmpq %rax, %rcx
jne 0xf3fe8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa0a7d
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: renew_graph_init(ma_hit_t_alloc*, ma_hit_t_alloc*, asg_t*, ma_sub_t*, R_to_U*, unsigned long)
void renew_graph_init(ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, asg_t *sg, ma_sub_t *coverage_cut, R_to_U* ruIndex, uint64_t n_read)
{
    if(sg != NULL) asg_destroy(sg);
    sg = NULL;
    
    if(coverage_cut != NULL) free(coverage_cut);
    coverage_cut = NULL;

    memset(ruIndex->index, -1, sizeof(uint32_t)*(ruIndex->len));


    uint64_t i = 0, j = 0;
    for (i = 0; i < n_read; i++) {
        for (j = 0; j < sources[i].length; j++) {
            sources[i].buffer[j].del = 0;
        }

        for (j = 0; j < reverse_sources[i].length; j++) {
            reverse_sources[i].buffer[j].del = 0;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xf4119
movq %rdx, %rdi
callq 0xa0494
testq %r13, %r13
je 0xf4126
movq %r13, %rdi
callq 0x2220
movq (%r12), %rdx
movq 0x8(%r12), %rdi
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x20e0
testq %rbx, %rbx
je 0xf41af
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdx
cmpl $0x0, 0xc(%r15,%rdx,8)
je 0xf417d
leaq (%r15,%rdx,8), %rsi
movl $0x18, %edi
xorl %r8d, %r8d
movq (%rsi), %r9
andq %rax, (%r9,%rdi)
incq %r8
movl 0xc(%rsi), %r9d
addq $0x28, %rdi
cmpq %r9, %r8
jb 0xf4166
cmpl $0x0, 0xc(%r14,%rdx,8)
je 0xf41a7
leaq (%r14,%rdx,8), %rdx
movl $0x18, %esi
xorl %edi, %edi
movq (%rdx), %r8
andq %rax, (%r8,%rsi)
incq %rdi
movl 0xc(%rdx), %r8d
addq $0x28, %rsi
cmpq %r8, %rdi
jb 0xf4190
incq %rcx
cmpq %rbx, %rcx
jne 0xf414e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_corresponding_uId(ma_ug_t*, R_to_U*, unsigned int)
uint32_t get_corresponding_uId(ma_ug_t *ug, R_to_U* ruIndex, uint32_t t)
{
    uint32_t w, uId, is_Unitig;
    get_R_to_U(ruIndex, t>>1, &uId, &is_Unitig);
    /****************************may have bugs********************************/
    if(uId == ((uint32_t)(-1)) || is_Unitig == 0) return ((uint32_t)(-1));
    if(ug->g->seq[uId].del) return ((uint32_t)(-1));
    /****************************may have bugs********************************/
    w = (uint32_t)-1;
    if(t == ug->u.a[uId].start) w = uId<<1;
    if(t == ug->u.a[uId].end) w = (uId<<1)^1;
    return w;
}

// Assembly:
movl %edx, %ecx
shrl %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, (%rsi)
jbe 0xf48ad
movq 0x8(%rsi), %rsi
movl (%rsi,%rcx,4), %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rsi, %rcx
je 0xf48ad
testl %ecx, %ecx
js 0xf48ae
retq
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq 0x18(%rdi), %rsi
movq 0x20(%rsi), %rsi
cmpl $0x0, (%rsi,%rcx,8)
js 0xf48ad
movq 0x10(%rdi), %rax
leaq (%rcx,%rcx,4), %rsi
leal (%rcx,%rcx), %edi
cmpl %edx, 0x4(%rax,%rsi,8)
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmovel %edi, %r8d
cmpl %edx, 0x8(%rax,%rsi,8)
leal 0x1(%rcx,%rcx), %eax
cmovnel %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: minor_transitive_reduction(ma_ug_t*, R_to_U*, asg_arc_t*, unsigned int)
void minor_transitive_reduction(ma_ug_t *ug, R_to_U* ruIndex, asg_arc_t* rbub_edges, uint32_t num)
{
    asg_t* nsg = ug->g;
    uint32_t i, j, k, uId, nv, w;
    asg_arc_t* t = NULL;
    asg_arc_t* p = NULL;
    asg_arc_t *av = NULL;
    ///here all edges from v are saved in rbub_edges
    ///for edges already in graph, need to check del
    ///but for edges in rbub_edges, don't check del
    for (i = 0; i < num; i++)
    {
        t = &rbub_edges[i];
        ///if(t->del) continue;
        uId = get_corresponding_uId(ug, ruIndex, t->v);
        if(uId == ((uint32_t)(-1))) continue;

        nv = asg_arc_n(nsg, uId);
        av = asg_arc_a(nsg, uId);
        for (j = 0; j < nv; j++)
        {
            if(av[j].del) continue;
            w = av[j].v;

            ///note w is the unitig ID
            for (k = 0; k < num; k++)
            {
                p = &rbub_edges[k];
                ///if(p->del) continue;
                ///this line is not necessary at all
                if(k==i) continue;
                ///w is the unitig ID, p->v is the read ID
                if(get_corresponding_uId(ug, ruIndex, p->v) == w) p->del = 1;
            }
        }   
    }    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, (%rsp)
testl %ecx, %ecx
je 0xf4a05
movq %rdx, %rbx
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movl %ecx, %eax
movq %rax, 0x20(%rsp)
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rbp
xorl %r12d, %r12d
xorl %eax, %eax
movq %rax, 0x28(%rsp)
leaq (%rax,%rax,2), %rax
movl 0x8(%rbx,%rax,8), %edx
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf488a
cmpl $-0x1, %eax
je 0xf49ee
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
testl %eax, %eax
je 0xf49ee
movq %rax, %rcx
shrq $0x20, %rcx
leaq (%rcx,%rcx,2), %rdx
shlq $0x3, %rdx
movq 0x8(%rsp), %rcx
addq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movl %eax, %eax
movq %rax, 0x30(%rsp)
xorl %r13d, %r13d
leaq (,%r13,2), %rax
addq %r13, %rax
movq 0x10(%rsp), %rcx
cmpl $0x0, 0xc(%rcx,%rax,8)
js 0xf49e4
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movl 0x8(%rax), %r14d
xorl %r15d, %r15d
cmpq %r15, %r12
je 0xf49db
movl 0x8(%rbx,%r15), %edx
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf488a
cmpl %r14d, %eax
jne 0xf49db
orb $-0x80, 0xf(%rbx,%r15)
addq $0x18, %r15
cmpq %r15, %rbp
jne 0xf49b8
incq %r13
cmpq 0x30(%rsp), %r13
jne 0xf4991
movq 0x28(%rsp), %rax
incq %rax
addq $0x18, %r12
cmpq 0x20(%rsp), %rax
jne 0xf492f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: minor_transitive_reduction_r_g(asg_t*, asg_arc_t*, unsigned int)
void minor_transitive_reduction_r_g(asg_t *r_g, asg_arc_t* rbub_edges, uint32_t num)
{
    uint32_t i, j, k, rId, nv, w;
    asg_arc_t* t = NULL;
    asg_arc_t* p = NULL;
    asg_arc_t *av = NULL;
    ///here all edges from v are saved in rbub_edges
    ///for edges already in graph, need to check del
    ///but for edges in rbub_edges, don't check del
    for (i = 0; i < num; i++)
    {
        t = &rbub_edges[i];
        rId = t->v;

        nv = asg_arc_n(r_g, rId);
        av = asg_arc_a(r_g, rId);
        for (j = 0; j < nv; j++)
        {
            if(av[j].del) continue;
            w = av[j].v;
            for (k = 0; k < num; k++)
            {
                p = &rbub_edges[k];
                ///this line is not necessary at all
                if(k==i) continue;
                if(p->v == w) p->del = 1;
            }
        }
    }
}

// Assembly:
testl %edx, %edx
je 0xf7d25
pushq %r14
pushq %rbx
movl %edx, %eax
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
xorl %r8d, %r8d
leaq (%r8,%r8,2), %r9
movl 0x8(%rsi,%r9,8), %r9d
movq 0x28(%rdi), %r10
movq (%r10,%r9,8), %r10
testl %r10d, %r10d
je 0xf7d16
movq %r10, %r9
shrq $0x20, %r9
leaq (%r9,%r9,2), %r9
shlq $0x3, %r9
addq 0x8(%rdi), %r9
movl %r10d, %r10d
xorl %r11d, %r11d
leaq (%r11,%r11,2), %rbx
cmpl $0x0, 0xc(%r9,%rbx,8)
js 0xf7d0e
leaq (%r9,%rbx,8), %rbx
movl 0x8(%rbx), %ebx
xorl %r14d, %r14d
cmpq %r14, %rdx
je 0xf7d05
cmpl %ebx, 0x8(%rsi,%r14)
jne 0xf7d05
orb $-0x80, 0xf(%rsi,%r14)
addq $0x18, %r14
cmpq %r14, %rcx
jne 0xf7cf3
incq %r11
cmpq %r10, %r11
jne 0xf7cdd
incq %r8
addq $0x18, %rdx
cmpq %rax, %r8
jne 0xf7cae
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: reset_bub(bubble_type*, ma_ug_t*, trans_chain*, kvec_asg_arc_t_warp*)
void reset_bub(bubble_type* bub, ma_ug_t *ug, trans_chain* back_ug_chain, kvec_asg_arc_t_warp* new_rtg_edges)
{
    destory_bubbles(bub);
    memset(bub, 0, sizeof(bubble_type));

    if(new_rtg_edges) new_rtg_edges->a.n = 0;
    ///classify_untigs(ug, sg, coverage_cut, sources, reverse_sources, ruIndex, new_rtg_edges, max_hang, min_ovlp);
    identify_bubbles(ug, bub, back_ug_chain->ir_het, NULL);
    // update_bubble_chain(ug, bub, 0, 1);
    // resolve_bubble_chain_tangle(ug, bub);
    // fprintf(stderr, "bub.f_bub: %lu, bub.b_bub: %lu, bub.b_end_bub: %lu, bub.tangle_bub: %lu, bub.cross_bub: %lu\n", 
    // bub->f_bub, bub->b_bub, bub->b_end_bub, bub->tangle_bub, bub->cross_bub);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13dea7
movl $0x110, %edx            # imm = 0x110
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20e0
testq %r12, %r12
je 0xfcf03
movq $0x0, (%r12)
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13e8a1
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: check_if_no_coverage(asg_t*, asg_arc_t*, unsigned int)
uint32_t check_if_no_coverage(asg_t *r_g, asg_arc_t* list, uint32_t list_n)
{
    if(list_n < 2) return 0;
    uint32_t i, v, w, u_n = list_n - 1, nv, l, k;
    long long totalLen = 0;
    asg_arc_t *av = NULL;
    for (i = 0; i < u_n - 1; i++)
    {
        v = list[i].v;
        w = list[i+1].v; 
        av = asg_arc_a(r_g, v);
        nv = asg_arc_n(r_g, v);
        l = 0;
        
        for (k = 0; k < nv; k++)
        {
            if(av[k].del) continue;
            if(av[k].v == w) 
            {
                l = asg_arc_len(av[k]);
                break;
            }
        }

        if(k == nv) fprintf(stderr, "####ERROR\n");
        totalLen += l;
    }

    if(i < u_n)
    {
        v = list[i].v;
        l = r_g->seq[v>>1].len;
        totalLen += l;
    }

    if(totalLen > list[0].ol + list[list_n - 1].ol) return 1;

    return 0;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, %edx
jb 0x1010b4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leal -0x1(%rdx), %esi
addl $-0x2, %edx
je 0x101064
movl %esi, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movl %edx, %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
leaq (,%rbp,2), %rcx
addq %rbp, %rcx
movl 0x8(%rbx,%rcx,8), %eax
movq 0x28(%r14), %rdx
movq (%rdx,%rax,8), %rax
testl %eax, %eax
je 0x101036
movl 0x20(%rbx,%rcx,8), %edx
movq 0x8(%r14), %rcx
movq %rax, %rdi
shrq $0x20, %rdi
movl %eax, %esi
leaq (%rdi,%rdi,2), %rdi
leaq (%rcx,%rdi,8), %rdi
addq $0xc, %rdi
xorl %ecx, %ecx
cmpl $0x0, (%rdi)
js 0x101026
cmpl %edx, -0x4(%rdi)
je 0x10103d
incq %rcx
addq $0x18, %rdi
cmpq %rcx, %rsi
jne 0x10101c
movl %eax, %ecx
jmp 0x101038
xorl %ecx, %ecx
xorl %r15d, %r15d
jmp 0x101041
movl -0xc(%rdi), %r15d
cmpl %eax, %ecx
je 0x101052
incq %rbp
addq %r15, %r12
cmpq %r13, %rbp
jne 0x100fe2
jmp 0x101059
callq 0x11a96
jmp 0x101045
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
jmp 0x101069
xorl %eax, %eax
xorl %r12d, %r12d
cmpl %esi, %eax
jae 0x101088
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%rbx,%rax,8), %eax
movq 0x20(%r14), %rcx
shrl %eax
movl (%rcx,%rax,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r12
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl 0xc(%rbx), %eax
andl %ecx, %eax
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
andl 0xc(%rbx,%rdx,8), %ecx
addl %eax, %ecx
xorl %eax, %eax
cmpq %rcx, %r12
setg %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_binned_reads(ma_hit_t_alloc*, unsigned long, ma_sub_t*)
void print_binned_reads(ma_hit_t_alloc* paf, uint64_t n_read, ma_sub_t* coverage_cut)
{
    uint64_t i, j, binned_flag;

    for (i = 0; i < n_read; ++i)
    {
        if(coverage_cut!=NULL && coverage_cut[i].del) continue;
        binned_flag = R_INF.trio_flag[i];
        fprintf(stdout, "\n***i: %u, binned_flag: %u\n", (uint32_t)i, (uint32_t)binned_flag);
        if(coverage_cut!=NULL)
        {
            fprintf(stdout, "coverage_cut[i].c: %u, coverage_cut[i].s: %u, coverage_cut[i].e: %u, coverage_cut[i].e: %u\n",
            coverage_cut[i].c, coverage_cut[i].s, coverage_cut[i].e, coverage_cut[i].del);
        }
        for (j = 0; j < paf[i].length; j++)
        {
            if(paf[i].buffer[j].del) continue;
            ///fprintf(stdout, "j: %u\n", (uint32_t)j);
            fprintf(stdout, "qn: %u, qs: %u, qe: %u, tn: %u, ts: %u, te: %u\n", 
            (uint32_t)Get_qn(paf[i].buffer[j]), (uint32_t)Get_qs(paf[i].buffer[j]), (uint32_t)Get_qe(paf[i].buffer[j]),
            (uint32_t)Get_tn(paf[i].buffer[j]), (uint32_t)Get_ts(paf[i].buffer[j]), (uint32_t)Get_te(paf[i].buffer[j]));
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0x102d4b
movq 0x19239c(%rip), %r12    # 0x294fb8
leaq 0x136332(%rip), %r13    # 0x238f55
xorl %ebp, %ebp
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0x102c9c
leaq (,%rbp,2), %rax
addq %rbp, %rax
cmpl $0x0, (%rdx,%rax,4)
js 0x102d38
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,4), %rbx
leaq 0x1935dc(%rip), %rax    # 0x296230
movq 0x28(%rax), %rax
movzbl (%rax,%rbp), %ecx
movq (%r12), %rdi
leaq 0x136276(%rip), %rsi    # 0x238edd
movl %ebp, %edx
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
movzbl 0x8(%rbx), %edx
movl (%rbx), %r9d
movl 0x4(%rbx), %r8d
movl %r9d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shrl $0x1f, %r9d
leaq 0x136266(%rip), %rsi    # 0x238ef9
xorl %eax, %eax
callq 0x22b0
jmp 0x102cbf
leaq 0x19358d(%rip), %rax    # 0x296230
movq 0x28(%rax), %rax
movzbl (%rax,%rbp), %ecx
movq (%r12), %rdi
leaq 0x136227(%rip), %rsi    # 0x238edd
movl %ebp, %edx
xorl %eax, %eax
callq 0x22b0
leaq (,%rbp,2), %rcx
addq %rbp, %rcx
movq (%rsp), %rax
movl 0xc(%rax,%rcx,8), %eax
testl %eax, %eax
je 0x102d38
movq (%rsp), %rdx
leaq (%rdx,%rcx,8), %r14
movl $0x18, %r15d
xorl %ebx, %ebx
movq (%r14), %rsi
cmpq $0x0, (%rsi,%r15)
js 0x102d2a
movq (%r12), %rdi
movq -0x18(%rsi,%r15), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movl -0x10(%rsi,%r15), %r8d
movl -0xc(%rsi,%r15), %r9d
movl -0x8(%rsi,%r15), %r10d
movl -0x4(%rsi,%r15), %r11d
movq %r13, %rsi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x22b0
addq $0x10, %rsp
movl 0xc(%r14), %eax
incq %rbx
movl %eax, %ecx
addq $0x28, %r15
cmpq %rcx, %rbx
jb 0x102ce6
incq %rbp
cmpq 0x10(%rsp), %rbp
movq 0x8(%rsp), %rdx
jne 0x102c2a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: set_hom_global_coverage(hifiasm_opt_t*, asg_t*, ma_sub_t*, ma_hit_t_alloc*, ma_hit_t_alloc*, R_to_U*, int, int)
void set_hom_global_coverage(hifiasm_opt_t *opt, asg_t *sg, ma_sub_t* coverage_cut, 
ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, R_to_U* ruIndex, int max_hang, int min_ovlp)
{
    if(opt->hom_global_coverage_set == 0)
    {
        ma_ug_t *ug = NULL;
        ug = ma_ug_gen(sg);

        hap_cov_t *cov = init_hap_cov_t(ug, sg, sources, ruIndex, reverse_sources, coverage_cut, max_hang, min_ovlp, 0);
        purge_dups(ug, sg, coverage_cut, sources, reverse_sources, ruIndex, NULL, 
        opt->purge_simi_thres, opt->purge_overlap_len, max_hang, min_ovlp, 0, 0, 1, cov, 0, 0);
        destory_hap_cov_t(&cov);

        ma_ug_destroy(ug);
    } 
}

// Assembly:
cmpl $0x0, 0x148(%rdi)
je 0x102d64
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb10cd
movq %rax, 0x8(%rsp)
subq $0x8, %rsp
xorl %r10d, %r10d
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %r13, %r9
pushq %r10
movl 0x68(%rsp), %eax
pushq %rax
movl 0x68(%rsp), %eax
pushq %rax
callq 0xd74eb
addq $0x20, %rsp
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movss 0x16c(%rbx), %xmm0
movl 0x138(%rbx), %r10d
subq $0x8, %rsp
xorps %xmm1, %xmm1
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
xorl %r11d, %r11d
pushq %r11
pushq %r11
xorl %r11d, %r11d
pushq %rax
pushq $0x1
pushq %r11
movl 0x88(%rsp), %eax
pushq %rax
movl 0x88(%rsp), %eax
pushq %rax
pushq %r10
pushq $0x0
callq 0x12943
addq $0x50, %rsp
leaq 0x10(%rsp), %rdi
callq 0xc9bdb
movq %rbx, %rdi
callq 0xa0761
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_primary_path_len(asg_t*, ma_ug_t*, unsigned int, buf_t*)
uint64_t get_primary_path_len(asg_t *sg, ma_ug_t *ug, uint32_t v0, buf_t *b)
{
    uint32_t v, u, k;
    uint64_t len;
    ma_utg_t *p = NULL; 

    v = b->S.a[0];
    len = 0;
    while (1)
    {
        u = b->a[v].p; // u->v
        if(u == v0) break;

        p = &(ug->u.a[u>>1]);

        for (k = 0; k < p->n; k++)
        {
            len += sg->seq[p->a[k]>>33].len;
        } 
        
        v = u;
    }

    return len;
}

// Assembly:
pushq %r14
pushq %rbx
movq (%rcx), %r8
movq 0x18(%rcx), %rax
movl (%rax), %eax
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
movl (%r8,%rcx), %r9d
cmpl %edx, %r9d
jne 0x103aee
xorl %eax, %eax
jmp 0x103b4a
movq 0x10(%rsi), %rcx
xorl %eax, %eax
movl %r9d, %esi
shrl %esi
leaq (%rsi,%rsi,4), %r10
movl 0x10(%rcx,%r10,8), %esi
testq %rsi, %rsi
je 0x103b33
leaq (%rcx,%r10,8), %r11
movq 0x20(%rdi), %r10
movq 0x18(%r11), %r11
xorl %ebx, %ebx
movq (%r11,%rbx,8), %r14
shrq $0x21, %r14
movl (%r10,%r14,8), %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
addq %r14, %rax
incq %rbx
cmpq %rbx, %rsi
jne 0x103b15
movl %r9d, %esi
leaq (%rsi,%rsi,8), %r9
leaq (%r9,%r9,2), %r9
addq %rsi, %r9
movl (%r8,%r9), %r9d
cmpl %edx, %r9d
jne 0x103af4
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: flat_soma_v(asg_t*, ma_hit_t_alloc*, R_to_U*)
void flat_soma_v(asg_t *sg, ma_hit_t_alloc* sources, R_to_U* ruIndex)
{
    uint64_t dip_thre_max;
    if(asm_opt.somatic_cov >= 0) {
        dip_thre_max = asm_opt.somatic_cov;
    } else {
        if(asm_opt.hom_global_coverage_set) {
            dip_thre_max = asm_opt.hom_global_coverage;
        } else {
            dip_thre_max = ((double)asm_opt.hom_global_coverage)/((double)HOM_PEAK_RATE);
        }
        dip_thre_max = (((double)(dip_thre_max)*1.15)/asm_opt.polyploidy);
    }
    flat_bubbles_advance(sg, sources, ruIndex, dip_thre_max);
}

// Assembly:
leaq 0x1915ce(%rip), %rax    # 0x295758
movq 0x280(%rax), %rcx
testq %rcx, %rcx
jns 0x103b4e
movslq 0x144(%rax), %rcx
cvtsi2sd %ecx, %xmm0
divsd 0x131bb3(%rip), %xmm0   # 0x235d60
movsd 0x12d153(%rip), %xmm1   # 0x231308
cvttsd2si %xmm0, %r8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %r9
movq %r8, %r10
sarq $0x3f, %r10
andq %r9, %r10
orq %r8, %r10
cmpl $0x0, 0x148(%rax)
cmovneq %rcx, %r10
movq %r10, %xmm0
punpckldq 0x12d098(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x12d0a0(%rip), %xmm0   # 0x231290
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0x131ba4(%rip), %xmm2   # 0x235da8
xorps %xmm0, %xmm0
cvtsi2sdl 0x1bc(%rax), %xmm0
divsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %r8
sarq $0x3f, %r8
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %rcx
andq %r8, %rcx
orq %rax, %rcx
jmp 0x103b4e
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_outfile_name(char*)
char *get_outfile_name(char* output_file_name)
{
    char *buf = NULL;
    CALLOC(buf, strlen(output_file_name) + 25);
    if(ha_opt_triobin(&asm_opt) && ha_opt_hic(&asm_opt))
    {
        sprintf(buf, "%s.hic.bench", output_file_name);
    }
    else if(ha_opt_triobin(&asm_opt))
    {
        sprintf(buf, "%s.dip", output_file_name);
    }
    else if(ha_opt_hic(&asm_opt))
    {
        sprintf(buf, "%s.hic", output_file_name);
    }
    else if(asm_opt.flag & HA_F_PARTITION)
    {
        sprintf(buf, "%s.bp", output_file_name);
    }
    else
    {
        sprintf(buf, "%s", output_file_name);
    }

    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2090
leaq 0x19(%rax), %rdi
movl $0x1, %esi
callq 0x2120
leaq 0x191504(%rip), %rcx    # 0x295758
cmpq $0x0, 0x20(%rcx)
sete %dl
cmpq $0x0, 0x28(%rcx)
movq %rax, %rbx
sete %al
orb %dl, %al
cmpb $0x1, %al
jne 0x1042b2
cmpq $0x0, 0x30(%rcx)
je 0x10429b
cmpq $0x0, 0x38(%rcx)
je 0x10429b
cmpq $0x0, 0x50(%rcx)
je 0x104289
cmpq $0x0, 0x58(%rcx)
jne 0x1042c0
testb %al, %al
je 0x1042c9
cmpq $0x0, 0x30(%rcx)
je 0x10429b
cmpq $0x0, 0x38(%rcx)
jne 0x1042c9
cmpq $0x0, 0x50(%rcx)
je 0x1042e8
cmpq $0x0, 0x58(%rcx)
je 0x1042e8
leaq 0x134d55(%rip), %rsi    # 0x239005
jmp 0x1042d0
cmpq $0x0, 0x50(%rcx)
je 0x1042c9
cmpq $0x0, 0x58(%rcx)
je 0x1042c9
leaq 0x134d2a(%rip), %rsi    # 0x238ff1
jmp 0x1042d0
leaq 0x134d2e(%rip), %rsi    # 0x238ffe
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x8, 0x1(%rcx)
jne 0x104300
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
leaq 0x134d05(%rip), %rsi    # 0x23900c
jmp 0x1042d0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: rescue_src_ul(ma_hit_t_alloc*, unsigned long, unsigned long)
void rescue_src_ul(ma_hit_t_alloc* src, uint64_t n_read, uint64_t occ)
{
    uint64_t k, i;
    for (k = 0; k < n_read; k++) {
        for (i = 0; i < src[k].length; i++) {
            if(!src[k].buffer[i].del) continue;
            if(src[k].buffer[i].bl>=occ) src[k].buffer[i].del = 0;
        }
    }
}

// Assembly:
testq %rsi, %rsi
je 0x1044b3
pushq %r14
pushq %rbx
xorl %eax, %eax
leaq (%rax,%rax,2), %r8
movl 0xc(%rdi,%r8,8), %ecx
testl %ecx, %ecx
je 0x1044a8
leaq (%rdi,%r8,8), %r8
movl $0x18, %r9d
xorl %r10d, %r10d
movq (%r8), %r11
movq (%r11,%r9), %rbx
testq %rbx, %rbx
jns 0x104499
movq %rbx, %r14
shrq $0x20, %r14
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
cmpq %rdx, %r14
jb 0x104499
btrq $0x3f, %rbx
movq %rbx, (%r11,%r9)
movl 0xc(%r8), %ecx
incq %r10
movl %ecx, %r11d
addq $0x28, %r9
cmpq %r11, %r10
jb 0x10446d
incq %rax
cmpq %rsi, %rax
jne 0x104453
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: prt_dbg_rid_ovlp(ma_hit_t_alloc*, long, char*, char const*)
void prt_dbg_rid_ovlp(ma_hit_t_alloc *ov, int64_t rid, char *rn, const char *cmd)
{
    uint64_t k; ma_hit_t *h = NULL;
    if(rid < 0) {
        for (k = 0; k < R_INF.total_reads; k++) {
            if (memcmp(rn, Get_NAME((R_INF), k), Get_NAME_LENGTH((R_INF), k)) == 0) break;
        }
        if(k >= R_INF.total_reads) return;
        rid = k;
    }

    fprintf(stderr, "\n[M::%s::%s::id::%ld]\n", __func__, cmd, rid);
    for (k = 0; k < ov[rid].length; k++) {
        h = &(ov[rid].buffer[k]);
        if(h->del) continue;
        fprintf(stderr, "%.*s(qn::%u)\t%u\t%u\t%u\t%c\t%.*s(tn::%u)\t%u\t%u\t%u\t%u\t%u\t255\n", (int)Get_NAME_LENGTH(R_INF, Get_qn(*h)), Get_NAME((R_INF), Get_qn(*h)), Get_qn(*h), (uint32_t)Get_READ_LENGTH(R_INF, Get_qn(*h)), Get_qs(*h), Get_qe(*h), "+-"[h->rev], 
        (int)Get_NAME_LENGTH(R_INF, Get_tn(*h)), Get_NAME((R_INF), Get_tn(*h)), Get_tn(*h), (uint32_t)Get_READ_LENGTH(R_INF, Get_tn(*h)), Get_ts(*h), Get_te(*h), h->ml, h->bl);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
testq %rsi, %rsi
jns 0x104517
movq %rdx, %r15
leaq 0x191d58(%rip), %rax    # 0x296230
movq 0x8(%rax), %r13
movq 0x40(%rax), %rbp
xorl %ebx, %ebx
subq 0x50(%rax), %rbx
movq $-0x1, %r12
leaq (%rbx,%r12), %rax
cmpq $-0x1, %rax
je 0x104526
movq 0x8(%rbp,%r12,8), %rax
movq 0x10(%rbp,%r12,8), %rdx
leaq (%rax,%r13), %rsi
subq %rax, %rdx
movq %r15, %rdi
callq 0x21a0
incq %r12
testl %eax, %eax
jne 0x1044ed
movq (%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x11ab2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: renew_g(ma_hit_t_alloc**, ma_hit_t_alloc**, long long*, unsigned long**, ma_sub_t**, R_to_U*, asg_t**, long, long, ug_opt_t*, long, double, double, long, bub_label_t*, unsigned int, char*, char const*, unsigned long, unsigned long, unsigned long)
void renew_g(ma_hit_t_alloc **sources, ma_hit_t_alloc **reverse_sources, long long *n_read, 
uint64_t **readLen, ma_sub_t **coverage_cut, R_to_U *ruIndex, asg_t **sg, int64_t mini_overlap_length, 
int64_t max_hang_length, ug_opt_t *uopt, int64_t clean_round, double min_ovlp_drop_ratio, 
double max_ovlp_drop_ratio, int64_t max_tip, bub_label_t *b_mask_t, uint32_t is_trio, 
char *o_file, const char *bin_file, uint64_t free_uld, uint64_t is_bridg, uint64_t deep_clean)
{
    ul_renew_t nopt; memset(&nopt, 0, sizeof(nopt));
    nopt.src = sources; nopt.r_src = reverse_sources; nopt.ruIndex = ruIndex;
    nopt.n_read = n_read; nopt.readLen = readLen; nopt.sg = sg;
    nopt.cov = coverage_cut; nopt.b_mask_t = b_mask_t;
    nopt.max_hang = max_hang_length; nopt.mini_ovlp = mini_overlap_length;
    ul_realignment_gfa(uopt, *sg, clean_round, min_ovlp_drop_ratio, max_ovlp_drop_ratio, 
        asm_opt.max_short_tip, asm_opt.max_short_ul_tip, b_mask_t, ha_opt_triobin(&asm_opt), o_file, &nopt, bin_file, free_uld, is_bridg, deep_clean);
    // ma_ug_t *iug = ul_realignment_gfa(uopt, *sg, clean_round, min_ovlp_drop_ratio, max_ovlp_drop_ratio, 
    //                                                                 asm_opt.max_short_tip, b_mask_t, ha_opt_triobin(&asm_opt), o_file);
    // asg_t *ng = gen_ng(iug, *sg, uopt, coverage_cut, ruIndex, 256);
    // ma_ug_destroy(iug); asg_destroy(*sg);
    // (*sources) = R_INF.paf; 
    // (*reverse_sources) = R_INF.reverse_paf;
    // (*n_read) = R_INF.total_reads;
    // (*readLen) = R_INF.read_length;
    // (*sg) = ng; 
    // ma_hit_contained_advance(*sources, *n_read, *coverage_cut, ruIndex, max_hang_length, mini_overlap_length);
    // post_rescue(uopt, *sg, (*sources), (*reverse_sources), ruIndex, b_mask_t, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rax
movq %rdx, %r10
movq 0xe0(%rsp), %r12
movq 0xd8(%rsp), %r15
movq 0xd0(%rsp), %r14
movq 0xc8(%rsp), %rbx
movq 0xc0(%rsp), %r11
movq 0xb0(%rsp), %r9
movq %rdi, 0x8(%rsp)
movq 0xa0(%rsp), %rdx
movq %rsi, 0x10(%rsp)
movq 0x98(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq %r10, 0x18(%rsp)
movq 0x90(%rsp), %rsi
movq %rcx, 0x20(%rsp)
movq 0x80(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x40(%rsp)
movq %rsi, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq (%rcx), %rsi
leaq 0x190eb6(%rip), %r10    # 0x295758
movslq 0x11c(%r10), %rcx
movslq 0x120(%r10), %r8
cmpq $0x0, 0x20(%r10)
je 0x1048c3
movl $0x1, %eax
cmpq $0x0, 0x28(%r10)
jne 0x1048d8
cmpq $0x0, 0x30(%r10)
je 0x1048d6
xorl %eax, %eax
cmpq $0x0, 0x38(%r10)
setne %al
jmp 0x1048d8
xorl %eax, %eax
subq $0x8, %rsp
leaq 0x10(%rsp), %r10
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r10
pushq %r11
pushq %rax
callq 0x2e548
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq