LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: copy_read_graph(asg_t*)
asg_t* copy_read_graph(asg_t *src)
{
    asg_t *dest = NULL;
    dest = asg_init();

    dest->r_seq = src->r_seq;
    dest->m_seq = dest->n_seq = src->n_seq;
    dest->seq = (asg_seq_t*)malloc(dest->n_seq * sizeof(asg_seq_t));
    memcpy(dest->seq, src->seq, sizeof(asg_seq_t)*dest->n_seq);

    dest->m_arc = dest->n_arc = src->n_arc;
    dest->arc = (asg_arc_t*)malloc(dest->n_arc*sizeof(asg_arc_t));
    memcpy(dest->arc, src->arc, sizeof(asg_arc_t)*dest->n_arc);

    dest->is_srt = src->is_srt;
    dest->is_symm = src->is_symm;
    dest->idx = NULL;
    // dest->idx = (uint64_t*)malloc(dest->n_seq*2*8);
    // memcpy(dest->idx, src->idx, dest->n_seq*2*8); 
    asg_cleanup(dest);

    if(src->seq_vis)
    {
        dest->seq_vis = (uint8_t*)malloc(dest->n_seq*2*sizeof(uint8_t));
        memcpy(dest->seq_vis, src->seq_vis, dest->n_seq*2*sizeof(uint8_t));
    }

    if(src->n_F_seq > 0 && src->F_seq)
    {
        dest->n_F_seq = src->n_F_seq;
        dest->F_seq = (ma_utg_t*)malloc(dest->n_F_seq*sizeof(ma_utg_t));
        memcpy(dest->F_seq, src->F_seq, dest->n_F_seq*sizeof(ma_utg_t));
    }
    return dest;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x68f5d
movq %rax, %rbx
movq 0x14(%r14), %r12
movl %r12d, %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movl %r15d, 0x10(%rax)
shlq $0x3, %r15
movq %r15, %rdi
callq 0x2280
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2160
movl 0x4(%r14), %r13d
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rbx)
imulq $0x18, %rax, %r15
movq %r15, %rdi
callq 0x2280
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2160
movl %r13d, 0x4(%rbx)
movq %r12, 0x14(%rbx)
andq $0x0, 0x28(%rbx)
movq %rbx, %rdi
callq 0x694eb
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x8c95a
movl 0x14(%rbx), %r12d
addl %r12d, %r12d
movq %r12, %rdi
callq 0x2280
movq %rax, 0x30(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2160
movl 0x38(%r14), %eax
testq %rax, %rax
je 0x8c98d
movq 0x40(%r14), %r14
testq %r14, %r14
je 0x8c98d
movl %eax, 0x38(%rbx)
imulq $0x28, %rax, %r15
movq %r15, %rdi
callq 0x2280
movq %rax, 0x40(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2160
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: destory_hap_cov_t(hap_cov_t**)
void destory_hap_cov_t(hap_cov_t **x)
{
    if(*x)
    {
        free((*x)->cov);
        free((*x)->pos_idx);
        free((*x)->is_r_het);
        kv_destroy((*x)->u_buffer.a);
        kv_destroy((*x)->tailIndex.a);
        kv_destroy((*x)->prevIndex.a);
        if((*x)->t_ch) destory_trans_chain(&((*x)->t_ch));
        free((*x));
    }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x8d2bc
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0xa0(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x50(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x70(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x90(%rax), %rdi
callq 0x2220
movq (%rbx), %rdi
cmpq $0x0, 0xa8(%rdi)
je 0x8d2b6
addq $0xa8, %rdi
callq 0x83bb0
movq (%rbx), %rdi
popq %rbx
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: dump_trans_ovlp(trans_chain*, char const*, ma_ug_t*)
uint64_t dump_trans_ovlp(trans_chain* t_ch, const char *fn, ma_ug_t *ug)
{
    char* gfa_name = NULL; MALLOC(gfa_name, strlen(fn)+50);
    sprintf(gfa_name, "%s.trans.bin", fn);
    FILE* fp = fopen(gfa_name, "w"); free(gfa_name);
    if (!fp) return 0;
    if(ug) write_dbug(ug, fp);

    fwrite(&t_ch->r_num, sizeof(t_ch->r_num), 1, fp);
    fwrite(t_ch->ir_het, sizeof(uint8_t), t_ch->r_num, fp);
    uint64_t i;
    fwrite(&t_ch->bed.n, sizeof(t_ch->bed.n), 1, fp);
    for (i = 0; i < t_ch->bed.n; i++) {
        fwrite(&t_ch->bed.a[i].n, sizeof(t_ch->bed.a[i].n), 1, fp);
        fwrite(t_ch->bed.a[i].a, sizeof(bed_interval), t_ch->bed.a[i].n, fp);
    }

    fwrite(&t_ch->k_trans.n, sizeof(t_ch->k_trans.n), 1, fp);
    fwrite(t_ch->k_trans.a, sizeof(u_trans_t), t_ch->k_trans.n, fp);

    fwrite(&t_ch->k_trans.idx.n, sizeof(t_ch->k_trans.idx.n), 1, fp);
    fwrite(t_ch->k_trans.idx.a, sizeof(uint64_t), t_ch->k_trans.idx.n, fp);

    fclose(fp);
    fprintf(stderr, "[M::%s] Dump trans overlaps\n", __func__);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
callq 0x2280
movq %rax, %r13
leaq 0x15b539(%rip), %rsi    # 0x1e8e12
movq $0x0, (%rsp)
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x16cdac(%rip), %rsi    # 0x1fa6a1
movq %r13, %rdi
callq 0x2210
movq %rax, %r15
movq %r13, %rdi
callq 0x2220
testq %r15, %r15
jne 0x8d920
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r12, %r12
je 0x8d930
movq %r12, %rdi
movq %r15, %rsi
callq 0x873f8
leaq 0x18(%r14), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2410
movq 0x10(%r14), %rdi
movl 0x18(%r14), %edx
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2410
leaq 0x20(%r14), %r12
pushq $0x8
popq %rsi
movq %r12, %rdi
movq %rbx, (%rsp)
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2410
xorl %ebx, %ebx
pushq $0x10
popq %rbp
xorl %r13d, %r13d
jmp 0x8d9af
movq 0x30(%r14), %rdi
addq %rbx, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x2410
movq 0x30(%r14), %rax
movq (%rax,%rbx), %rdx
movq 0x10(%rax,%rbx), %rdi
movq %rbp, %rsi
movq %r15, %rcx
callq 0x2410
incq %r13
addq $0x18, %rbx
cmpq (%r12), %r13
jb 0x8d97b
leaq 0x138(%r14), %rdi
pushq $0x8
popq %r12
movq %r12, %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2410
movq 0x138(%r14), %rdx
movq 0x148(%r14), %rdi
pushq $0x30
popq %rsi
movq %r15, %rcx
callq 0x2410
leaq 0x150(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x2410
movq 0x150(%r14), %rdx
movq 0x160(%r14), %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x2410
movq %r15, %rdi
callq 0x2190
movq 0x1c55b9(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x15b3ee(%rip), %rsi    # 0x1e8e1f
leaq 0x15b404(%rip), %rdx    # 0x1e8e3c
xorl %eax, %eax
callq 0x22b0
jmp 0x8d90d
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: update_trio_mmhap(unsigned int, ma_ug_t*, mmhap_t*, asg_t*, unsigned int)
void update_trio_mmhap(uint32_t hapid, ma_ug_t *mm_ug, mmhap_t *rh, asg_t *sg, uint32_t n_hap)
{
    uint64_t k, z, m, rid; ma_utg_t *u;
    for (k = 0; k < sg->n_seq; k++) {
        if(R_INF.trio_flag[k] == DROP) continue;
        R_INF.trio_flag[k] = AMBIGU;
    }
    
    for (k = 0; k < mm_ug->u.n; k++) { 
        if(rh->h.a[k].m == n_hap || rh->h.a[k].n == 0) {
            m = AMBIGU;
        } else {
            for (z = 0, m = MOTHER; z < rh->h.a[k].n; z++) {
                if(rh->a.a[rh->h.a[k].a+z] == hapid) {m = FATHER; break;}
            }
        }
        
        u = &(mm_ug->u.a[k]);
        for (z = 0; z < u->n; z++) {
            rid = u->a[z]>>33;
            if(R_INF.trio_flag[rid] == DROP) continue;
            R_INF.trio_flag[rid] = m;
        }
        fprintf(stderr, "utg%.6lu%c\tm::%lu\n", k+1, "lc"[mm_ug->u.a[k].circ], m);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %eax, %eax
leaq 0x1c659c(%rip), %r12    # 0x254230
movl 0x14(%rcx), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpq %rdx, %rax
jae 0x8dcb6
movq 0x28(%r12), %rdx
cmpb $0x5, (%rdx,%rax)
je 0x8dcb1
movb $0x0, (%rdx,%rax)
incq %rax
jmp 0x8dc94
xorl %r13d, %r13d
cmpq (%r15), %r13
jae 0x8dd72
movq 0x10(%r14), %rax
imulq $0xc, %r13, %rcx
cmpl %ebx, 0x4(%rax,%rcx)
je 0x8dcda
addq %rcx, %rax
movl (%rax), %ecx
testq %rcx, %rcx
jne 0x8dcdf
xorl %r8d, %r8d
jmp 0x8dd05
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x8dd01
movl 0x8(%rax), %esi
shlq $0x2, %rsi
addq 0x28(%r14), %rsi
leaq 0x1(%rdx), %rdi
cmpl %ebp, (%rsi,%rdx,4)
movq %rdi, %rdx
jne 0x8dce1
pushq $0x1
jmp 0x8dd03
pushq $0x2
popq %r8
imulq $0x28, %r13, %rax
movq 0x10(%r15), %rcx
addq %rax, %rcx
xorl %edx, %edx
movl 0x10(%rcx), %esi
cmpq %rsi, %rdx
jae 0x8dd3a
movq 0x18(%rcx), %rsi
movq (%rsi,%rdx,8), %rsi
shrq $0x21, %rsi
movq 0x28(%r12), %rdi
cmpb $0x5, (%rdi,%rsi)
je 0x8dd35
movb %r8b, (%rdi,%rsi)
incq %rdx
jmp 0x8dd12
movq 0x1c529f(%rip), %rcx    # 0x252fe0
movq (%rcx), %rdi
incq %r13
movq 0x10(%r15), %rcx
movl (%rcx,%rax), %eax
shrl $0x1f, %eax
leaq 0x158933(%rip), %rcx    # 0x1e668b
movsbl (%rax,%rcx), %ecx
leaq 0x15b146(%rip), %rsi    # 0x1e8ea9
movq %r13, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x8dcb9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: dbg_prt_trio_mmhap_label(ma_ug_t*, mmhap_t*, char const*)
void dbg_prt_trio_mmhap_label(ma_ug_t *ug, mmhap_t *rh, const char *o_n)
{
    char* gfa_name = (char*)malloc(strlen(o_n)+100); 
    FILE *fn = NULL; sprintf(gfa_name, "%s.mmhap.binning.log", o_n);
    uint32_t i, z; fn = fopen(gfa_name, "w");
    for (i = 0; i < ug->g->n_seq; i++) {
        fprintf(fn, "utg%.6u%c\tm::%u\tn::%u", i+1, "lc"[ug->u.a[i].circ], rh->h.a[i].m, rh->h.a[i].n);
        for (z = 0; z < rh->h.a[i].n; z++) {
            fprintf(fn, "\t%u", rh->a.a[rh->h.a[i].a+z]);
        }
        fprintf(fn, "\n");
    }
    fclose(fn); free(gfa_name); fprintf(stderr, "[M::%s::] done\n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2090
leaq 0x64(%rax), %rdi
callq 0x2280
movq %rax, %r12
leaq 0x15b109(%rip), %rsi    # 0x1e8ebc
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x16c8da(%rip), %rsi    # 0x1fa6a1
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x2210
movq %rax, %r12
leaq 0x15b109(%rip), %rbp    # 0x1e8ee7
xorl %eax, %eax
movq %r14, 0x10(%rsp)
movq 0x18(%r14), %rcx
movl 0x14(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpq %rcx, %rax
jae 0x8de84
leaq 0x1(%rax), %r13
movq 0x10(%r14), %rcx
imulq $0x28, %rax, %rdx
movl (%rcx,%rdx), %ecx
shrl $0x1f, %ecx
leaq 0x158877(%rip), %rdx    # 0x1e668b
movsbl (%rcx,%rdx), %ecx
movq 0x10(%rbx), %rdx
imulq $0xc, %rax, %r15
movl (%rdx,%r15), %r9d
movl 0x4(%rdx,%r15), %r8d
xorl %r14d, %r14d
movq %r12, %rdi
leaq 0x15b09b(%rip), %rsi    # 0x1e8ed1
movl %r13d, %edx
xorl %eax, %eax
callq 0x22b0
movq 0x10(%rbx), %rax
cmpl (%rax,%r15), %r14d
jae 0x8de6c
addq %r15, %rax
movq 0x28(%rbx), %rcx
movl 0x8(%rax), %eax
addl %r14d, %eax
movl (%rcx,%rax,4), %edx
movq %r12, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x22b0
incl %r14d
jmp 0x8de40
pushq $0xa
popq %rdi
movq %r12, %rsi
callq 0x2270
movq %r13, %rax
movq 0x10(%rsp), %r14
jmp 0x8dde5
movq %r12, %rdi
callq 0x2190
movq 0x8(%rsp), %rdi
callq 0x2220
movq 0x1c5143(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x15ad46(%rip), %rsi    # 0x1e8bed
leaq 0x15b03d(%rip), %rdx    # 0x1e8eeb
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: output_trio_mmhap(asg_t*, ma_sub_t*, char*, ma_hit_t_alloc*, ma_hit_t_alloc*, long long, float, long long, R_to_U*, float, float, int, int, long long, bub_label_t*, ug_opt_t*, ma_ug_t*, mmhap_t*, unsigned int)
void output_trio_mmhap(asg_t *sg, ma_sub_t* coverage_cut, char* output_file_name, ma_hit_t_alloc* sources, 
ma_hit_t_alloc* reverse_sources, long long tipsLen, float tip_drop_ratio, long long stops_threshold, R_to_U* ruIndex, 
float chimeric_rate, float drop_ratio, int max_hang, int min_ovlp, long long gap_fuzz, bub_label_t* b_mask_t, ug_opt_t *opt, 
ma_ug_t *mm_ug, mmhap_t *rh, uint32_t n_hap)
{
    uint32_t i; char *fp = NULL; MALLOC(fp, 100);
    memset(R_INF.trio_flag, 0, sizeof((*(R_INF.trio_flag)))*sg->n_seq);
    for (i = 0; i < n_hap; i++){
        sprintf(fp, "hap%u", i+1);
        update_trio_mmhap(i, mm_ug, rh, sg, n_hap);
        output_trio_unitig_graph(sg, coverage_cut, output_file_name, FATHER, sources, reverse_sources, tipsLen, tip_drop_ratio, 
        stops_threshold, ruIndex, chimeric_rate, drop_ratio, max_hang, min_ovlp, gap_fuzz, 0, b_mask_t, fp, NULL, NULL);
    }
    free(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movss %xmm2, 0x74(%rsp)
movss %xmm1, 0x70(%rsp)
movss %xmm0, 0x6c(%rsp)
movq %r9, 0xc0(%rsp)
movq %r8, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdi, %rbp
movl 0x148(%rsp), %r15d
movq 0x140(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x88(%rsp)
movl 0x118(%rsp), %eax
movl %eax, 0x68(%rsp)
movl 0x110(%rsp), %eax
movl %eax, 0x64(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0x120(%rsp), %eax
movl %eax, 0x60(%rsp)
pushq $0x64
popq %rdi
callq 0x2280
movq %rax, %r12
leaq 0x1c6297(%rip), %rax    # 0x254230
movq 0x28(%rax), %rdi
movl 0x14(%rbp), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
callq 0x20e0
movl %r15d, %ebx
xorl %r14d, %r14d
subl $0x1, %r15d
jb 0x8e092
leal 0x1(%r14), %r13d
movq %r12, %rdi
leaq 0x15aa8e(%rip), %rsi    # 0x1e8a59
movl %r13d, %edx
xorl %eax, %eax
callq 0x2050
movl %r14d, %edi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq %rbp, %rcx
movl %ebx, %r8d
callq 0x8dc75
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movq %r12, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
andl $0x0, 0x30(%rsp)
movq %rbp, %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
pushq $0x1
popq %rcx
movq 0xb0(%rsp), %r8
movq 0xb8(%rsp), %r9
movss 0x6c(%rsp), %xmm0
movss 0x70(%rsp), %xmm1
movss 0x74(%rsp), %xmm2
callq 0x86cbc
movl %r13d, %r14d
jmp 0x8dfb3
movq %r12, %rdi
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_debug_gfa(ma_ug_t*, asg_t*, ma_sub_t*, char*, ma_hit_t_alloc*, R_to_U*)
void print_debug_gfa(ma_ug_t *ug, asg_t *sg, ma_sub_t* coverage_cut, char* output_file_name, 
ma_hit_t_alloc* sources, R_to_U* ruIndex)
{
    char* gfa_name = (char*)malloc(strlen(output_file_name)+50);
    sprintf(gfa_name, "%s.after.clean_d_utg.gfa", output_file_name);
    FILE* output_file = fopen(gfa_name, "w");
    ma_ug_print(ug, sg, coverage_cut, sources, ruIndex, "utg", output_file);
    fclose(output_file);

    sprintf(gfa_name, "%s.after.clean_d_utg.noseq.gfa", output_file_name);
    output_file = fopen(gfa_name, "w");
    ma_ug_print_simple(ug, sg, coverage_cut, sources, ruIndex, "utg", output_file);
    fclose(output_file);
    
    free(gfa_name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, 0x20(%rsp)
movq %rdi, %r15
movq %rdi, 0x18(%rsp)
movq %rcx, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
callq 0x2280
movq %rax, %r13
leaq 0x15a96f(%rip), %rsi    # 0x1e8f04
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x16c0f8(%rip), %rsi    # 0x1fa6a1
movq %r13, %rdi
callq 0x2210
movq %rax, %r14
movq %rax, (%rsp)
leaq 0x15f6bc(%rip), %r9     # 0x1edc7b
movq %r15, %rdi
movq 0x20(%rsp), %r15
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq 0x10(%rsp), %r8
callq 0x7cd23
movq %r14, %rdi
callq 0x2190
leaq 0x15a934(%rip), %rsi    # 0x1e8f1d
movq %r13, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq %r13, %rdi
leaq 0x16c0a1(%rip), %rsi    # 0x1fa6a1
callq 0x2210
movq %rax, %rbx
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq 0x10(%rsp), %r8
leaq 0x15f655(%rip), %r9     # 0x1edc7b
callq 0x7de8f
movq %rbx, %rdi
callq 0x2190
movq %r13, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_poly_ug(asg_t*, ma_sub_t*, ma_hit_t_alloc*, ma_hit_t_alloc*, int, int, R_to_U*, bub_label_t*)
ma_ug_t *get_poly_ug(asg_t *sg, ma_sub_t* coverage_cut, ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, 
int max_hang, int min_ovlp, R_to_U* ruIndex, bub_label_t* b_mask_t)
{
    kvec_asg_arc_t_warp new_rtg_edges, d_edges;
    kv_init(new_rtg_edges.a); kv_init(d_edges.a);

    ma_ug_t *ug = ma_ug_gen_primary(sg, PRIMARY_LABLE);

    uint8_t* is_r_het = NULL;
    CALLOC(is_r_het, sg->n_seq);
    set_r_het_flag(ug, sg, coverage_cut, sources, ruIndex, is_r_het);

    adjust_utg_advance(sg, ug, reverse_sources, ruIndex, b_mask_t, is_r_het);
    asg_t* nsg = (*ug).g;
    uint32_t v, n_vtx = nsg->n_seq;
    for (v = 0; v < n_vtx; ++v)
    {
        if(nsg->seq[v].del) continue;
        nsg->seq[v].c = PRIMARY_LABLE;
    }
    delete_useless_nodes(&ug);
    renew_utg(&ug, sg, NULL); 

    ma_ug_seq(ug, sg, coverage_cut, sources, &new_rtg_edges, max_hang, min_ovlp, &d_edges, 1);

    kv_destroy(new_rtg_edges.a);  kv_destroy(d_edges.a);
    horder_clean_sg_by_utg(sg, ug);
    free(is_r_het);
    return ug;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x20(%rsp)
movl %r8d, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
andq $0x0, 0x60(%rsp)
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x781bd
movq %rax, %rbp
movq %rax, 0x28(%rsp)
movl 0x14(%rbx), %edi
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rdi
pushq $0x1
popq %rsi
callq 0x2120
movq %rax, %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %r14, 0x10(%rsp)
movq %r14, %rdx
movq %r12, 0x18(%rsp)
movq %r12, %rcx
movq 0xb0(%rsp), %r14
movq %r14, %r8
movq %rax, %r9
callq 0x83811
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rcx
movq 0xb8(%rsp), %r8
movq %r13, %r9
callq 0x8e9c7
movq 0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andq %rdx, %rcx
cmpq %r15, %rcx
je 0x8e948
movq 0x20(%rax), %rdx
cmpl $0x0, (%rdx,%r15,8)
js 0x8e943
movb $0x0, 0x4(%rdx,%r15,8)
incq %r15
jmp 0x8e92d
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x8ea44
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x80328
movq (%r14), %r14
subq $0x8, %rsp
leaq 0x38(%rsp), %r15
leaq 0x58(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl 0xc(%rsp), %r9d
pushq $0x1
pushq %r15
pushq 0x38(%rsp)
callq 0x7b888
addq $0x20, %rsp
movq 0x10(%r15), %rdi
callq 0x2220
movq %rbx, %rdi
movq %r14, %rsi
callq 0x132def
movq %r13, %rdi
callq 0x2220
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: adjust_utg_advance(asg_t*, ma_ug_t*, ma_hit_t_alloc*, R_to_U*, bub_label_t*, unsigned char*)
void adjust_utg_advance(asg_t *sg, ma_ug_t *ug, ma_hit_t_alloc* reverse_sources, R_to_U* ruIndex, bub_label_t* b_mask_t, uint8_t* is_r_het)
{
    double startTime = Get_T();
    asg_t* nsg = ug->g;
    unroll_simple_case_advance(ug, sg, reverse_sources, ruIndex, b_mask_t, is_r_het, 2.5);
    drop_semi_circle(ug, ug->g, sg, reverse_sources, ruIndex, is_r_het);
    asg_cleanup(nsg);
    asg_symm(nsg);
    // fprintf(stderr, "[M::%s]-4-\n", __func__); dbg_spec_edge(ug->g, 7536, 28129);
    ///debug_utg_graph(ug, sg, 0, 0);
    if(VERBOSE >= 1)
    {
        fprintf(stderr, "[M::%s] takes %0.2f s\n", __func__, Get_T()-startTime);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x251c
movq 0x18(%r13), %r14
movsd 0x159292(%rip), %xmm0   # 0x1e7c88
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq (%rsp), %r8
movq %rbx, %r9
callq 0xb1978
movq 0x18(%r13), %rsi
movq %r13, %rdi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x97ac1
movq %r14, %rdi
callq 0x694eb
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x69638
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: delete_useless_nodes(ma_ug_t**)
void delete_useless_nodes(ma_ug_t **ug)
{
    asg_t* nsg = (*ug)->g;
    uint32_t v, n_vtx = nsg->n_seq;
    for (v = 0; v < n_vtx; ++v) 
    {
        if(nsg->seq[v].del) continue;
        if(nsg->seq[v].c == ALTER_LABLE)
        {
            asg_seq_del(nsg, v);
            if((*ug)->u.a[v].m!=0)
            {
                (*ug)->u.a[v].m = (*ug)->u.a[v].n = 0;
                free((*ug)->u.a[v].a);
                (*ug)->u.a[v].a = NULL;
            }

            continue;
        }

        //note: after cleaning, some cirle might be gone, or we have some new circles
        //so need to renew .circ
        /**
        if(get_unitig(nsg, NULL, (v<<1), &convex, &nodeLen, &baseLen, 
                                        &max_stop_nodeLen, &max_stop_baseLen, 1, NULL)==LOOP)
        {
            (*ug)->u.a[v].circ = 1;
            (*ug)->u.a[v].start = (*ug)->u.a[v].end = UINT32_MAX;
        }
        else
        {
            (*ug)->u.a[v].circ = 0;

            (*ug)->u.a[v].start = (*ug)->u.a[v].a[0]>>32;
            (*ug)->u.a[v].end = ((*ug)->u.a[v].a[(*ug)->u.a[v].n-1]>>32)^1;
        }
        **/        
    }

    asg_cleanup(nsg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rax), %r14
movl 0x14(%r14), %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x8eac0
movq 0x20(%r14), %rax
cmpl $0x0, (%rax,%r15,8)
js 0x8eab7
cmpb $0x1, 0x4(%rax,%r15,8)
jne 0x8eab7
movq %r14, %rdi
movl %r15d, %esi
callq 0x6f8da
movq (%rbx), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0xc(%rax,%r13)
je 0x8eab7
andq $0x0, 0xc(%rax,%r13)
movq 0x18(%rax,%r13), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x10(%rax), %rax
andq $0x0, 0x18(%rax,%r13)
incq %r15
addq $0x28, %r13
jmp 0x8ea68
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x694eb
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_hic_polyploid_trans_chain(ma_ug_t*, asg_t*, ma_sub_t*, ma_hit_t_alloc*, ma_hit_t_alloc*, int, int, R_to_U*, bub_label_t*)
trans_chain* get_hic_polyploid_trans_chain(ma_ug_t *ug, asg_t *sg, ma_sub_t* coverage_cut, ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, 
int max_hang, int min_ovlp, R_to_U* ruIndex, bub_label_t* b_mask_t)
{
    uint32_t k;
    trans_chain* p = NULL; CALLOC(p, 1);
    p->r_num = sg->n_seq; p->u_num = ug->u.n;
    kv_malloc(p->bed, p->u_num); p->bed.n = p->u_num;
    for (k = 0; k < p->bed.n; k++) kv_init(p->bed.a[k]);
    CALLOC(p->ir_het, p->r_num);
    kv_u_trans_t *ta = get_utg_ovlp(&ug, sg, sources, reverse_sources, coverage_cut, ruIndex, max_hang, min_ovlp, NULL, b_mask_t, p->ir_het);
    p->k_trans = *ta; free(ta);
    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %rcx, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq %rdi, 0x40(%rsp)
pushq $0x1
popq %rdi
movl $0x1d0, %esi            # imm = 0x1D0
callq 0x2120
movq %rax, %rbx
movl 0x14(%r13), %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl %r12d, 0x18(%rax)
movq (%r14), %r14
movl %r14d, %r15d
movl %r14d, 0x1c(%rax)
movq %r15, 0x28(%rax)
imulq $0x18, %r15, %rdi
callq 0x2280
movq %rax, 0x30(%rbx)
movq %r15, 0x20(%rbx)
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cmpl %r14d, %ecx
jae 0x8eb4f
incl %ecx
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
addq $0x18, %rax
jmp 0x8eb3a
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x10(%rbx)
movq %rax, 0x20(%rsp)
andq $0x0, 0x10(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x8(%rsp)
movl %ebp, (%rsp)
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %r8
movq 0x88(%rsp), %r9
callq 0x8ebd0
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, 0x138(%rbx)
movups %xmm1, 0x148(%rbx)
movups %xmm2, 0x158(%rbx)
movq %rax, %rdi
callq 0x2220
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_utg_ovlp(ma_ug_t**, asg_t*, ma_hit_t_alloc*, ma_hit_t_alloc*, ma_sub_t*, R_to_U*, int, int, kvec_asg_arc_t_warp*, bub_label_t*, unsigned char*)
kv_u_trans_t *get_utg_ovlp(ma_ug_t **ug, asg_t* read_g, ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, ma_sub_t* coverage_cut, 
R_to_U* ruIndex, int max_hang, int min_ovlp, kvec_asg_arc_t_warp* new_rtg_edges, bub_label_t* b_mask_t, uint8_t* r_het)
{
    ///print_debug_gfa(read_g, *ug, coverage_cut, "init", sources, ruIndex, asm_opt.max_hang_Len, asm_opt.min_overlap_Len);
    kv_u_trans_t *ta = pt_pdist(*ug, read_g,coverage_cut, sources, new_rtg_edges, max_hang, min_ovlp, 5);
    kv_gg_status *sa = init_mc_gg_status(*ug, read_g, coverage_cut, sources, ruIndex, 
    asm_opt.hom_global_coverage_set?asm_opt.hom_global_coverage:((double)asm_opt.hom_global_coverage)/((double)HOM_PEAK_RATE), 
    asm_opt.polyploidy);
    mc_solve_general(ta, (*ug)->u.n, sa, asm_opt.polyploidy, 1, 1);
    if(r_het) set_r_het_status(r_het, sa, *ug, asm_opt.polyploidy);
    free(sa->a); free(sa);
    return ta;
    // ma_ug_seq(*ug, read_g, coverage_cut, sources, new_rtg_edges, max_hang, min_ovlp, 0, 0);
    // ug_idx_build(*ug, asm_opt.polyploidy);
    // topo_ovlp_collect(*ug, read_g, sources, reverse_sources, coverage_cut, tipsLen, tip_drop_ratio, 
    // stops_threshold, ruIndex, chimeric_rate, drop_ratio, max_hang, min_ovlp, cov);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %rbp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsp), %r8
movl 0x40(%rsp), %r9d
movl 0x48(%rsp), %eax
movq (%rdi), %rdi
movq %rbp, %rdx
movq %r13, %rcx
pushq $0x5
pushq %rax
callq 0x155d8b
popq %rcx
popq %rdx
movq %rax, %r15
movq (%r14), %rdi
leaq 0x1c4b3f(%rip), %r12    # 0x253758
cmpl $0x0, 0x148(%r12)
cvtsi2sdl 0x144(%r12), %xmm0
jne 0x8ec36
divsd 0x15902a(%rip), %xmm0   # 0x1e7c60
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x154652(%rip), %xmm0   # 0x1e3298
cvttsd2si %xmm0, %r9
sarq $0x3f, %rcx
andq %rcx, %r9
orq %rax, %r9
movzwl 0x1bc(%r12), %eax
subq $0x8, %rsp
movq %rbx, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq 0x8(%rsp), %r8
pushq %rax
callq 0x12bd8d
popq %rcx
popq %rdx
movq %rax, %rbx
movq (%r14), %rax
movl (%rax), %esi
movzwl 0x1bc(%r12), %ecx
pushq $0x1
popq %r8
movq %r15, %rdi
movq %rbx, %rdx
movl %r8d, %r9d
callq 0x12d800
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x8ecb8
movq (%r14), %rdx
movl 0x1bc(%r12), %ecx
movq %rbx, %rsi
callq 0xb3d09
movq (%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2220
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_u_trans_spec(kv_u_trans_t*, unsigned int, unsigned int, u_trans_t**, unsigned int*)
uint32_t get_u_trans_spec(kv_u_trans_t *ta, uint32_t qn, uint32_t tn, u_trans_t **r_a, uint32_t *occ)
{
    if(r_a) (*r_a) = NULL; 
    if(occ) (*occ) = 0;
    u_trans_t *a = NULL;
    uint32_t n, st, i;
    a = u_trans_a(*ta, qn);
    n = u_trans_n(*ta, qn);
    for (st = 0, i = 1; i <= n; ++i)
    {
        if (i == n || a[i].tn != a[st].tn)
        {
            if(a[st].tn == tn)
            {
                if(r_a) (*r_a) = a + st;
                if(occ) (*occ) = i - st;
                return 1;
            }
            st = i;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rcx, %rcx
je 0x8fefc
andq $0x0, (%rcx)
testq %r8, %r8
je 0x8ff05
andl $0x0, (%r8)
movq 0x28(%rdi), %rax
movl %esi, %esi
movq (%rax,%rsi,8), %r10
movq %r10, %rax
shrq $0x20, %rax
imulq $0x30, %rax, %r9
addq 0x10(%rdi), %r9
movl $0x1, %esi
xorl %eax, %eax
xorl %edi, %edi
cmpl %r10d, %esi
ja 0x8ff80
movl %edi, %r11d
jne 0x8ff3c
imulq $0x30, %r11, %rbx
movl 0x14(%r9,%rbx), %ebx
jmp 0x8ff56
movl %esi, %ebx
imulq $0x30, %rbx, %r14
imulq $0x30, %r11, %rbx
movl 0x14(%r9,%rbx), %ebx
cmpl %ebx, 0x14(%r9,%r14)
jne 0x8ff56
movl %edi, %ebp
jmp 0x8ff5c
movl %esi, %ebp
cmpl %edx, %ebx
je 0x8ff62
incl %esi
movl %ebp, %edi
jmp 0x8ff27
testq %rcx, %rcx
je 0x8ff71
imulq $0x30, %r11, %rax
addq %rax, %r9
movq %r9, (%rcx)
movl $0x1, %eax
testq %r8, %r8
je 0x8ff80
subl %edi, %esi
movl %esi, (%r8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: gen_bp_phasing(ug_opt_t*, kv_u_trans_t*, ma_ug_t*, asg_t*)
void gen_bp_phasing(ug_opt_t *opt, kv_u_trans_t *ta, ma_ug_t *ug, asg_t *sg)
{
    uint8_t *bf = NULL;
    bubble_type *bub = gen_bubble_chain(sg, ug, opt, &bf, 0); free(bf);
    filter_u_trans(ta, asm_opt.is_bub_trans, asm_opt.is_topo_trans, asm_opt.is_read_trans, asm_opt.is_base_trans);
    // dbg_prt_utg_trans(ta, ug, "pre");
    if(asm_opt.is_base_trans) {
        trans_base_infer(ug, sg, opt, ta, bub);
    } 
    // dbg_prt_utg_trans(ta, ug, "after");
    clean_u_trans_t_idx_filter_adv(ta, ug, sg, 0.95, 0);
    
    
    bp_solve(opt, ta, ug, sg, bub, asm_opt.trans_base_rate);
    
    destory_bubbles(bub); free(bub); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq %rsp, %rbp
andq $0x0, (%rbp)
movq %rcx, %rdi
movq %rdx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
callq 0x1afe25
movq %rax, %r15
movq (%rbp), %rdi
callq 0x2220
leaq 0x1c2263(%rip), %rbp    # 0x253758
movzbl 0x24d(%rbp), %esi
movzbl 0x24c(%rbp), %edx
movzbl 0x24b(%rbp), %ecx
movzbl 0x24a(%rbp), %r8d
movq %r12, %rdi
callq 0x874f8
cmpb $0x0, 0x24a(%rbp)
je 0x91537
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x1a028d
movsd 0x151fa9(%rip), %xmm0   # 0x1e34e8
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x8922a
cvtss2sd 0x170(%rbp), %xmm0
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x11c5a2
movq %r15, %rdi
callq 0xf6a60
movq %r15, %rdi
callq 0x2220
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_unitig(ma_utg_t*, ma_ug_t*)
void print_unitig(ma_utg_t* collection, ma_ug_t* ug)
{
    if(collection->m == 0) return;
    uint32_t i, index = 0, uId, ori, l;
    ma_utg_t* query = NULL;
    for (i = 0; i < collection->n; i++)
    {
        uId = collection->a[i]>>33;
        ori = collection->a[i]>>32&1;
        l = (uint32_t)(collection->a[i]);
        fprintf(stderr, "i: %u, uId: %u, ori: %u, l: %u\n", i, uId, ori, l);
        if(ug)
        {
            query = &(ug->u.a[uId]);
            index += query->n;
        }
    }
    fprintf(stderr, "index: %u\n", index);
}

// Assembly:
cmpl $0x0, 0xc(%rdi)
jne 0x9244b
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x156b82(%rip), %r15    # 0x1e8fe5
xorl %r12d, %r12d
xorl %ebp, %ebp
movl 0x10(%r14), %eax
cmpq %rax, %r12
jae 0x924bb
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %r9
movq %r9, %r13
shrq $0x21, %r13
movq %r9, %r8
shrq $0x20, %r8
andl $0x1, %r8d
movq 0x1c0b4e(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x22b0
testq %rbx, %rbx
je 0x924b6
movq 0x10(%rbx), %rax
imulq $0x28, %r13, %rcx
addl 0x10(%rax,%rcx), %ebp
incq %r12
jmp 0x92468
movq 0x1c0b1e(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x156b39(%rip), %rsi    # 0x1e9005
movl %ebp, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: reset_untig_hap_label(ma_ug_t*, unsigned int, unsigned char, unsigned char*)
void reset_untig_hap_label(ma_ug_t *g, uint32_t uId, uint8_t trio_flag, uint8_t* bin_res)
{
	uint32_t k;
    ma_utg_t *u = &g->u.a[uId];
    for (k = 0; k < u->n; k++) {
        if(bin_res[u->a[k]>>33] == AMBIGU) bin_res[u->a[k]>>33] = trio_flag;
    }
}

// Assembly:
movl %esi, %eax
imulq $0x28, %rax, %rax
addq 0x10(%rdi), %rax
xorl %esi, %esi
movl 0x10(%rax), %edi
cmpq %rdi, %rsi
jae 0x92d12
movq 0x18(%rax), %rdi
movq (%rdi,%rsi,8), %rdi
shrq $0x21, %rdi
cmpb $0x0, (%rcx,%rdi)
jne 0x92d0d
movb %dl, (%rcx,%rdi)
incq %rsi
jmp 0x92cf0
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_graph_statistic(asg_t*)
long long get_graph_statistic(asg_t *g)
{
    long long num_arc = 0;
	uint32_t n_vtx = g->n_seq * 2, v;
    
	for (v = 0; v < n_vtx; ++v) 
    {
		if (g->seq[v>>1].del || g->seq[v>>1].c == ALTER_LABLE) continue;
        ///num_arc += asg_arc_n(g, v);
        num_arc += get_real_length(g, v, NULL);
    }

    return num_arc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %r15d
addl %r15d, %r15d
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpl %ebp, %r15d
je 0x92dd2
movq 0x20(%rbx), %rax
movl %ebp, %ecx
shrl %ecx
cmpl $0x0, (%rax,%rcx,8)
js 0x92dce
cmpb $0x1, 0x4(%rax,%rcx,8)
je 0x92dce
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xc2e7a
cltq
addq %rax, %r14
incl %ebp
jmp 0x92da3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: cal_trio_vec(buf_t*, ma_ug_t*, float)
uint32_t cal_trio_vec(buf_t* b, ma_ug_t *ug, float thres)
{
    uint32_t i, father_occ = 0, mother_occ = 0, v, k, rId;
    if(ug == NULL)
    {
        for (i = 0; i < b->b.n; ++i)
        {
            if(R_INF.trio_flag[b->b.a[i]>>1]==FATHER)
            {
                father_occ++;
            }
            else if(R_INF.trio_flag[b->b.a[i]>>1]==MOTHER)
            {
                mother_occ++;
            }
        }
    }
    else
    {
        ma_utg_t* u = NULL;
        for (i = 0; i < b->b.n; ++i)
        {
            v = b->b.a[i]>>1;
            u = &(ug->u.a[v]);
            if(u->m == 0) continue;
            for (k = 0; k < u->n; k++)
            {
                rId = u->a[k]>>33;
                if(R_INF.trio_flag[rId]==FATHER)
                {
                    father_occ++;
                }
                else if(R_INF.trio_flag[rId]==MOTHER)
                {
                    mother_occ++;
                }
            }
        }
    }
    
    

    if(father_occ >= thres*(father_occ+mother_occ)) return FATHER;
    if(mother_occ >= thres*(father_occ+mother_occ)) return MOTHER;
    return AMBIGU;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x38(%rdi), %rdx
leaq 0x1c1308(%rip), %rax    # 0x254230
testq %rsi, %rsi
je 0x92f98
movq 0x28(%rax), %r8
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r9d, %r9d
movl %r9d, %r9d
cmpq %r9, %rdx
jbe 0x92fd2
movq 0x48(%rdi), %r10
movl (%r10,%r9,4), %r11d
shrl %r11d
movq 0x10(%rsi), %r10
imulq $0x28, %r11, %r11
cmpl $0x0, 0xc(%r10,%r11)
je 0x92f93
addq %r11, %r10
movl 0x10(%r10), %r11d
xorl %ebx, %ebx
cmpq %rbx, %r11
je 0x92f93
movq 0x18(%r10), %r14
movq (%r14,%rbx,8), %r14
shrq $0x21, %r14
movzbl (%r8,%r14), %ebp
cmpl $0x2, %ebp
je 0x92f8c
cmpl $0x1, %ebp
jne 0x92f8e
incl %eax
jmp 0x92f8e
incl %ecx
incq %rbx
jmp 0x92f68
incl %r9d
jmp 0x92f38
movq 0x28(%rax), %rsi
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r8d, %r8d
movl %r8d, %r8d
cmpq %r8, %rdx
jbe 0x92fd2
movq 0x48(%rdi), %r9
movl (%r9,%r8,4), %r9d
shrl %r9d
movzbl (%rsi,%r9), %r9d
cmpl $0x2, %r9d
je 0x92fcb
cmpl $0x1, %r9d
jne 0x92fcd
incl %eax
jmp 0x92fcd
incl %ecx
incl %r8d
jmp 0x92fa3
movl %eax, %edx
cvtsi2ss %rdx, %xmm1
addl %ecx, %eax
cvtsi2ss %rax, %xmm2
movl %ecx, %eax
cvtsi2ss %rax, %xmm3
mulss %xmm0, %xmm2
xorl %ecx, %ecx
ucomiss %xmm2, %xmm3
setae %cl
addl %ecx, %ecx
ucomiss %xmm2, %xmm1
movl $0x1, %eax
cmovbl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: label_r_set(buf_t*, R_to_U*, ma_ug_t*, unsigned int)
void label_r_set(buf_t* b, R_to_U* ruIndex, ma_ug_t *ug, uint32_t flag)
{
    uint32_t uid, rid, qn;
    ma_utg_t *u = NULL;
    for (uid = 0; uid < b->b.n;uid++)
    {
        u = &(ug->u.a[b->b.a[uid]>>1]);
        ///each read
        for (rid = 0; rid < u->n; rid++)
        {
            qn = (u->a[rid]>>33);
            if(flag != (uint32_t)-1)
            {
                set_R_to_U(ruIndex, qn, b->b.a[uid]>>1, 1, NULL);
            }
            else
            {
                ruIndex->index[qn] = (uint32_t)-1;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movl %r13d, %r13d
cmpq %r13, 0x38(%r12)
jbe 0x93420
movq 0x48(%r12), %rax
movl (%rax,%r13,4), %eax
shrl %eax
imulq $0x28, %rax, %r14
movq (%rsp), %rax
addq 0x10(%rax), %r14
xorl %ebp, %ebp
movl 0x10(%r14), %eax
cmpq %rax, %rbp
jae 0x9341b
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rsi
shrq $0x21, %rsi
cmpl $-0x1, %ebx
je 0x9340e
movq 0x48(%r12), %rax
movl (%rax,%r13,4), %edx
shrl %edx
movq %r15, %rdi
pushq $0x1
popq %rcx
xorl %r8d, %r8d
callq 0x6ab56
jmp 0x93416
movq 0x8(%r15), %rax
orl $-0x1, (%rax,%rsi,4)
incq %rbp
jmp 0x933d9
incl %r13d
jmp 0x933b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_unitig_trio_flag(ma_utg_t*, unsigned int, unsigned int*, unsigned int*, unsigned int*)
void get_unitig_trio_flag(ma_utg_t* nsu, uint32_t flag, uint32_t* require, 
uint32_t* non_require, uint32_t* ambigious)
{
    uint32_t k, rId;
    (*require) = (*non_require) = (*ambigious) = 0;
    for (k = 0; k < nsu->n; k++)
    {
        rId = nsu->a[k]>>33;
        if(R_INF.trio_flag[rId] == AMBIGU || R_INF.trio_flag[rId] == DROP)
        {
            (*ambigious)++;
            continue;
        } 
        if(R_INF.trio_flag[rId] == flag)
        {
            (*require)++;
            continue;
        } 
        if(R_INF.trio_flag[rId] != flag)
        {
            (*non_require)++;
            continue;
        } 
    }
}

// Assembly:
andl $0x0, (%r8)
andl $0x0, (%rcx)
andl $0x0, (%rdx)
leaq 0x1bf749(%rip), %rax    # 0x254230
movq 0x28(%rax), %rax
xorl %r9d, %r9d
movl 0x10(%rdi), %r10d
cmpq %r10, %r9
jae 0x94b2c
movq 0x18(%rdi), %r10
movq (%r10,%r9,8), %r10
shrq $0x21, %r10
movzbl (%rax,%r10), %r11d
movq %r8, %r10
testl %r11d, %r11d
je 0x94b24
movq %r8, %r10
cmpl $0x5, %r11d
je 0x94b24
movq %rdx, %r10
cmpl %esi, %r11d
je 0x94b24
movq %rcx, %r10
incl (%r10)
incq %r9
jmp 0x94aee
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: gen_rd_hamming_fly_t(ma_ug_t*, asg_t*)
rd_hamming_fly_t* gen_rd_hamming_fly_t(ma_ug_t *ug, asg_t *sg)
{
    rd_hamming_fly_t *p; CALLOC(p, 1);
    MALLOC(p->o2n, sg->n_seq); 
    memset(p->o2n, -1, sizeof((*(p->o2n)))*sg->n_seq);
    MALLOC(p->ugh, ug->g->n_seq);
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x2120
movq %rax, %rbx
movl 0x14(%r14), %r14d
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
andq %r12, %r14
shlq $0x2, %r14
movq %r14, %rdi
callq 0x2280
movq %rax, 0x18(%rbx)
movq %rax, %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x20e0
movq 0x18(%r15), %rax
movl 0x14(%rax), %edi
andq %r12, %rdi
shlq $0x3, %rdi
callq 0x2280
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: gen_rd_hamming_fly_simp_t(ma_ug_t*, asg_t*, ma_hit_t_alloc*, ma_sub_t*, int, int, int, kvec_asg_arc_t_warp*)
rd_hamming_fly_simp_t* gen_rd_hamming_fly_simp_t(ma_ug_t *ug, asg_t *rg, ma_hit_t_alloc* src, ma_sub_t *cov, int32_t max_hang, int32_t min_ovlp, int32_t gap_fuzz, kvec_asg_arc_t_warp *ae)
{
    rd_hamming_fly_simp_t *p; CALLOC(p, 1);
    // p->ng = asg_init();
    // p->ng->n_seq = p->ng->m_seq = ug->g->n_seq; 
    // MALLOC(p->ng->seq, p->ng->n_seq);
    // memcpy(p->ng->seq, ug->g->seq, (sizeof((*(p->ng->seq)))*p->ng->n_seq));
    p->src = src; p->cov = cov; p->max_hang = max_hang; p->min_ovlp = min_ovlp; p->gap_fuzz = gap_fuzz;
    p->fg = gen_fg(ug, rg, src, cov, max_hang, min_ovlp, gap_fuzz); p->n_insert = 0;
    CALLOC(p->vs, (ug->g->n_seq<<1)); CALLOC(p->srt, 1); p->ae = ae;
    // p->fg = gen_fg();
    // p->rg = rg; MALLOC(p->rs, rg->n_seq<<1); 
    // memset(p->rs, -1, sizeof((*(p->rs)))*(rg->n_seq<<1));
    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movl %r8d, %r15d
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x2120
movq %rax, %rbx
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movl %r15d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movl 0x50(%rsp), %eax
movl %eax, 0x18(%rbx)
movl %eax, (%rsp)
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %r15d, %r8d
movl %ebp, %r9d
callq 0x95f98
movq %rax, 0x30(%rbx)
movq 0x18(%r14), %rax
movl 0x14(%rax), %eax
addl %eax, %eax
movslq %eax, %rdi
pushq $0x1
popq %r14
movq %r14, %rsi
callq 0x2120
movq %rax, 0x28(%rbx)
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, 0x20(%rbx)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: destroy_rd_hamming_fly_simp_t(rd_hamming_fly_simp_t*)
void destroy_rd_hamming_fly_simp_t(rd_hamming_fly_simp_t *p)
{
    ///asg_destroy(p->ng); ///free(p->rs);
    ma_ug_destroy(p->fg); 
    free(p->vs); 
    free(p->srt->a); 
    free(p->srt); 
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x6921d
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x2220
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: dbg_asys_gfa0(void*, long, int)
static void dbg_asys_gfa0(void *data, long i, int tid) // callback for kt_for()
{
	asg_t *g = (asg_t *)data; asg_arc_t *s = &(g->arc[i]), *ra; 
    if(s->del) return;
    uint64_t rn, ri, v, w;
    ra = asg_arc_a(g, (s->v^1)); rn = asg_arc_n(g, (s->v^1));
    for (ri = 0; ri < rn; ri++) {
        if(ra[ri].del) continue;
        if(ra[ri].v == ((s->ul>>32)^1)) break;
    }
    if(ri >= rn) {
        v = s->ul>>32; w = s->v;
        fprintf(stderr, "[M::%s] v::utg%.6lul(%c)\tw::utg%.6lul(%c)\n", __func__, (v>>1) + 1, "+-"[(v&1)], (w>>1) + 1, "+-"[(w&1)]);
        exit(1);
    }
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %r8
imulq $0x18, %rsi, %rcx
cmpl $0x0, 0xc(%r8,%rcx)
js 0x96a80
addq %r8, %rcx
movq 0x28(%rdi), %rdx
movl 0x8(%rcx), %eax
movq %rax, %rsi
xorq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
movl %edx, %esi
movq %rdx, %rdi
shrq $0x20, %rdi
imulq $0x18, %rsi, %rdx
imulq $0x18, %rdi, %rsi
addq %r8, %rsi
addq $0xc, %rsi
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x96a82
cmpl $0x0, (%rsi,%rdi)
js 0x96a7a
movl 0x4(%rcx), %r8d
xorl -0x4(%rsi,%rdi), %r8d
cmpl $0x1, %r8d
je 0x96a80
addq $0x18, %rdi
jmp 0x96a60
popq %rax
retq
movq (%rcx), %rdx
movq 0x1bc554(%rip), %rcx    # 0x252fe0
movq (%rcx), %rdi
movq %rdx, %rcx
shrq $0x21, %rcx
incq %rcx
leaq 0x14d783(%rip), %rsi    # 0x1e4223
btq $0x20, %rdx
movq %rsi, %rdx
adcq $0x0, %rdx
movsbl (%rdx), %r8d
movl %eax, %r9d
shrl %r9d
incq %r9
andl $0x1, %eax
movsbl (%rax,%rsi), %eax
movl %eax, (%rsp)
leaq 0x154605(%rip), %rsi    # 0x1eb0cf
leaq 0x154629(%rip), %rdx    # 0x1eb0fa
xorl %eax, %eax
callq 0x22b0
pushq $0x1
popq %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_graph_statistic(asg_t*, char const*)
void print_graph_statistic(asg_t *g, const char* cmd)
{
    uint64_t n_arc = 0, n_node = 0, size = 0;
    uint32_t n_vtx = g->n_seq, v;

    for (v = 0; v < n_vtx; ++v)
    {
        if (g->seq[v].del || g->seq[v].c == ALTER_LABLE) continue;
        n_arc += get_real_length(g, v<<1, NULL) + get_real_length(g, (v<<1)+1, NULL);
        n_node++;
        size += g->seq[v].len;
    }

    fprintf(stderr, "%s->n_node: %lu, n_arc: %lu, size: %lu\n", cmd, n_node, n_arc, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movl 0x14(%rdi), %ebx
addl %ebx, %ebx
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq %rbp, %rbx
je 0x98117
movq 0x20(%r13), %rax
cmpl $0x0, (%rax,%rbp,4)
js 0x98111
cmpb $0x1, 0x4(%rax,%rbp,4)
je 0x98111
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xc2e7a
movl %eax, 0xc(%rsp)
leal 0x1(%rbp), %esi
movq %r13, %rdi
xorl %edx, %edx
callq 0xc2e7a
addl 0xc(%rsp), %eax
cltq
addq %rax, %r14
incq %r12
movq 0x20(%r13), %rax
movl (%rax,%rbp,4), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r15
addq $0x2, %rbp
jmp 0x980c3
movq 0x1baec2(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x15142d(%rip), %rsi    # 0x1e9555
movq 0x10(%rsp), %rdx
movq %r12, %rcx
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: set_drop_trio_flag(ma_ug_t*)
void set_drop_trio_flag(ma_ug_t *ug)
{
    ma_utg_t* u = NULL;
    asg_t* nsg = ug->g;
    uint32_t k, rId;
    uint32_t v, n_vtx = nsg->n_seq;
    for (v = 0; v < n_vtx; ++v) 
    {
        if(nsg->seq[v].del) continue;
        if(nsg->seq[v].c == ALTER_LABLE) continue;
        u = &(ug->u.a[v]);
        if(u->m == 0) continue;
        for (k = 0; k < u->n; k++)
        {
            rId = u->a[k]>>33;
            if(R_INF.trio_flag[rId] != AMBIGU) continue;
            R_INF.trio_flag[rId] = DROP;
        }
    }
}

// Assembly:
movq 0x18(%rdi), %rax
movl 0x14(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
leaq 0x1bb94d(%rip), %rsi    # 0x254230
cmpq %rcx, %rdx
je 0x98940
movq 0x20(%rax), %r8
cmpl $0x0, (%r8,%rdx,8)
js 0x9893b
cmpb $0x1, 0x4(%r8,%rdx,8)
je 0x9893b
movq 0x10(%rdi), %r8
imulq $0x28, %rdx, %r9
cmpl $0x0, 0xc(%r8,%r9)
je 0x9893b
addq %r9, %r8
xorl %r9d, %r9d
movl 0x10(%r8), %r10d
cmpq %r10, %r9
jae 0x9893b
movq 0x18(%r8), %r10
movq (%r10,%r9,8), %r10
shrq $0x21, %r10
movq 0x28(%rsi), %r11
cmpb $0x0, (%r11,%r10)
jne 0x98936
movb $0x5, (%r11,%r10)
incq %r9
jmp 0x98911
incq %rdx
jmp 0x988e3
retq