LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_num_trio_flag(ma_ug_t*, unsigned int, unsigned int)
uint32_t get_num_trio_flag(ma_ug_t *ug, uint32_t v, uint32_t flag)
{
    if(flag == (uint32_t)-1) return 0;
    ma_utg_t* u = NULL;
    asg_t* nsg = ug->g;
    uint32_t k, rId, flag_occ = 0;
    if (nsg->seq[v].del) return 0;
    u = &(ug->u.a[v]);
    if(u->m == 0) return 0;
    for (k = 0; k < u->n; k++)
    {
        rId = u->a[k]>>33;
        if(R_INF.trio_flag[rId] == flag) flag_occ++;
    }

    return flag_occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0xf7260
movl $0x0, -0x4(%rbp)
jmp 0xf7322
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0xf729d
movl $0x0, -0x4(%rbp)
jmp 0xf7322
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0xf72c6
movl $0x0, -0x4(%rbp)
jmp 0xf7322
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0xf731c
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
movl %eax, -0x30(%rbp)
leaq 0x2cdfda(%rip), %rax    # 0x3c52d0
movq 0x28(%rax), %rax
movl -0x30(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl -0x18(%rbp), %eax
jne 0xf730f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xf7311
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xf72cd
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_buf_t(ma_ug_t*, buf_t*, char const*)
void print_buf_t(ma_ug_t *ug, buf_t* x, const char* command)
{
    fprintf(stderr, "%s\n", command);
    uint32_t i, ori;
    ma_utg_t* u = NULL;
    for (i = 0; i < x->b.n; i++)
    {
        u = &(ug->u.a[x->b.a[i]>>1]);
        if(u->n == 0) continue;
        ori = x->b.a[i] & 1;
        fprintf(stderr, "utg%.6ul\tori:%u\tocc:%u\tlen:%u\n", (x->b.a[i]>>1)+1, ori, (uint32_t)u->n, u->len);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x2cc9e5(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2959a5(%rip), %rsi    # 0x38cfae
movb $0x0, %al
callq 0x22a0
movq $0x0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0xf76c7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
movl -0x1c(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xf7661
jmp 0xf76b9
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
andl $0x1, %eax
movl %eax, -0x20(%rbp)
movq 0x2cc964(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %edx
shrl %edx
addl $0x1, %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl 0x10(%rax), %r8d
movq -0x28(%rbp), %rax
movl (%rax), %r9d
andl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
leaq 0x28fd32(%rip), %rsi    # 0x3873e4
movb $0x0, %al
callq 0x22a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf761f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: reset_u_trans_hit_idx(u_trans_hit_idx*, unsigned int*, unsigned int, ma_ug_t*, asg_t*, trans_chain*, unsigned int, unsigned int)
void reset_u_trans_hit_idx(u_trans_hit_idx *t, uint32_t* i_x_a, uint32_t i_x_n, ma_ug_t *i_ug, 
asg_t *i_read_sg, trans_chain* i_t_ch, uint32_t i_cBeg, uint32_t i_cEnd)
{
    t->a = i_x_a;
    t->an = i_x_n;
    t->ug = i_ug;
    t->read_sg = i_read_sg;
    t->t_ch = i_t_ch;
    t->cBeg = i_cBeg;
    t->cEnd = i_cEnd;
    t->u_i = t->r_i = t->len = t->s_pos_cur = t->s_pre_v = t->s_pre_w = 0;
    t->p_v = t->p_uId = t->p_idx = (uint32_t)-1; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movl 0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl 0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: destory_hc_links(hc_links*)
void destory_hc_links(hc_links* link)
{
    uint64_t i;
    for (i = 0; i < link->a.n; i++)
    {
        kv_destroy(link->a.a[i].e);
        kv_destroy(link->a.a[i].f);
    }
    kv_destroy(link->a);
    kv_destroy(link->enzymes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xfcd41
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xfccf4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_trans_chain(trans_chain*, char const*)
void write_trans_chain(trans_chain* t_ch, const char *fn)
{
    char *buf = (char*)calloc(strlen(fn) + 25, 1);
    sprintf(buf, "%s.hic.trans.bin", fn);
    FILE* fp = fopen(buf, "w");

    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);
    
    uint32_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);
    free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x19, %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x28a400(%rip), %rsi    # 0x3874bd
movb $0x0, %al
callq 0x2050
movq -0x18(%rbp), %rdi
leaq 0x29c303(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2400
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x2400
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2400
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0xfd1aa
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x24(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2400
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x24(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x24(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x10, %esi
callq 0x2400
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xfd134
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq -0x20(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2400
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x30, %esi
callq 0x2400
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
addq $0x18, %rdi
movq -0x20(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2400
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x8, %esi
callq 0x2400
movq -0x20(%rbp), %rdi
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: update_poly_trio(unsigned int, unsigned int*, unsigned int)
void update_poly_trio(uint32_t mm, uint32_t *hapS, uint32_t rn)
{
    uint32_t i;
    for (i = 0; i < rn; i++) {
        if(R_INF.trio_flag[i] == DROP) continue;
        R_INF.trio_flag[i] = AMBIGU;
        if(!hapS[i]) continue;
        R_INF.trio_flag[i] = (hapS[i]&mm?FATHER:MOTHER);
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x100922
leaq 0x2c4a1c(%rip), %rax    # 0x3c52d0
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x5, %eax
jne 0x1008c6
jmp 0x100917
leaq 0x2c4a03(%rip), %rax    # 0x3c52d0
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1008e7
jmp 0x100917
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %edx
andl -0x4(%rbp), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %dl
leaq 0x2c49c3(%rip), %rax    # 0x3c52d0
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1008a5
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: output_poly_trio(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, int, int, bub_label_t*, unsigned int)
void output_poly_trio(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, int gap_fuzz, int is_bench, 
bub_label_t* b_mask_t, uint32_t hapN)
{
    uint32_t i;
    uint32_t *hapS = ha_polybin_list(&asm_opt);
    // debug_hapS(hapS, sg->n_seq);
    char *fp = NULL; MALLOC(fp, 100);
    for (i = 0; i < hapN; i++){
        update_poly_trio(1<<i, hapS, sg->n_seq);
        sprintf(fp, "hap%u", i+1);
        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, is_bench, b_mask_t, fp, NULL, NULL);
    }
    free(fp); free(hapS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl 0x48(%rbp), %eax
movq 0x40(%rbp), %rax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
movss %xmm0, -0x5c(%rbp)
movss %xmm1, -0x60(%rbp)
movss %xmm2, -0x64(%rbp)
leaq 0x2c3c4b(%rip), %rdi    # 0x3c47f8
callq 0x16a250
movq %rax, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movl $0x64, %edi
callq 0x2270
movq %rax, -0x78(%rbp)
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl 0x48(%rbp), %eax
jae 0x100cca
movl -0x68(%rbp), %ecx
movl $0x1, %edi
shll %cl, %edi
movq -0x70(%rbp), %rsi
movq -0x30(%rbp), %rax
movl 0x14(%rax), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x100890
movq -0x78(%rbp), %rdi
movl -0x68(%rbp), %edx
addl $0x1, %edx
leaq 0x286977(%rip), %rsi    # 0x387587
movb $0x0, %al
callq 0x2050
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %r8
movq -0x50(%rbp), %r9
movq -0x58(%rbp), %rax
movq %rax, -0x88(%rbp)
movss -0x5c(%rbp), %xmm0
movq 0x10(%rbp), %r13
movq 0x18(%rbp), %r12
movss -0x60(%rbp), %xmm1
movss -0x64(%rbp), %xmm2
movl 0x20(%rbp), %r15d
movl 0x28(%rbp), %r14d
movl 0x30(%rbp), %ebx
movl 0x38(%rbp), %r11d
movq 0x40(%rbp), %r10
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x1, %ecx
xorl %eax, %eax
movq -0x88(%rbp), %rax
movq %rax, (%rsp)
movq -0x80(%rbp), %rax
movq %r13, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movl %r15d, 0x18(%rsp)
movl %r14d, 0x20(%rsp)
movl %ebx, 0x28(%rsp)
movl %r11d, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
callq 0x100cf0
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x100bd3
movq -0x78(%rbp), %rdi
callq 0x2210
movq -0x70(%rbp), %rdi
callq 0x2210
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_dbug(ma_ug_t*, _IO_FILE*)
void write_dbug(ma_ug_t* ug, FILE* fp)
{
    ma_utg_t *u = NULL;
    uint32_t t, i;
    fwrite(&(ug->u.n), sizeof(ug->u.n), 1, fp);
    for (i = 0; i < ug->u.n; i++)
    {
        u = &(ug->u.a[i]);
        t = u->len;
        fwrite(&t, sizeof(t), 1, fp);
        t = u->circ;
        fwrite(&t, sizeof(t), 1, fp);
        fwrite(&(u->start), sizeof(u->start), 1, fp);
        fwrite(&(u->end), sizeof(u->end), 1, fp);
        fwrite(&(u->n), sizeof(u->n), 1, fp);
        fwrite(u->a, sizeof(uint64_t), u->n, fp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2400
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x101a02
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x20(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2400
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x1f, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2400
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2400
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2400
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2400
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x8, %esi
callq 0x2400
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x101916
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: filter_u_trans(kv_u_trans_t*, unsigned char, unsigned char, unsigned char, unsigned char)
void filter_u_trans(kv_u_trans_t *ta, uint8_t keep_bub, uint8_t keep_topo, uint8_t keep_read, uint8_t keep_base)
{
    if(keep_bub && keep_topo && keep_read && keep_base) return;
    uint32_t i, m;
    for (i = m = 0; i < ta->n; i++) {
        if((!keep_bub) && (ta->a[i].f == RC_0)) continue;
        if((!keep_topo) && (ta->a[i].f == RC_1)) continue;
        if((!keep_read) && (ta->a[i].f == RC_2)) continue;
        if((!keep_base) && (ta->a[i].f == RC_3)) continue;
        ta->a[m++] = ta->a[i];
    }
    ta->n = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
cmpb $0x0, -0x9(%rbp)
je 0x101a49
cmpb $0x0, -0xa(%rbp)
je 0x101a49
cmpb $0x0, -0xb(%rbp)
je 0x101a49
cmpb $0x0, -0xc(%rbp)
je 0x101a49
jmp 0x101b5b
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x101b4f
cmpb $0x0, -0x9(%rbp)
jne 0x101a91
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x28(%rax), %al
andb $0x3f, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x101a91
jmp 0x101b41
cmpb $0x0, -0xa(%rbp)
jne 0x101abb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x28(%rax), %al
andb $0x3f, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x101abb
jmp 0x101b41
cmpb $0x0, -0xb(%rbp)
jne 0x101ae2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x28(%rax), %al
andb $0x3f, %al
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x101ae2
jmp 0x101b41
cmpb $0x0, -0xc(%rbp)
jne 0x101b09
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x28(%rax), %al
andb $0x3f, %al
movzbl %al, %eax
cmpl $0x3, %eax
jne 0x101b09
jmp 0x101b41
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x10(%rbp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movl %eax, %eax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x30, %edx
callq 0x2180
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x101a57
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: kt_u_trans_t_idx(kv_u_trans_t*, unsigned int)
void kt_u_trans_t_idx(kv_u_trans_t *ta, uint32_t n)
{
    radix_sort_u_trans(ta->a, ta->a + ta->n);
    kv_resize(uint64_t, ta->idx, n);
    ta->idx.n = n;
    memset(ta->idx.a, 0, ta->idx.n*sizeof(uint64_t));
    uint32_t st, i;
    for (st = 0, i = 1; i <= ta->n; ++i)
    {
        if (i == ta->n || ta->a[i].qn != ta->a[st].qn)
        {
            ta->idx.a[ta->a[st].qn] = (uint64_t)st << 32 | (i - st);
            st = i;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
imulq $0x30, (%rax), %rax
addq %rax, %rsi
callq 0xc9ff0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x10464b
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x10464d
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2100
movl $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
ja 0x104716
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x1046cb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x10(%rbp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
je 0x104706
movl -0x10(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %eax
orq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x10(%rbp), %esi
imulq $0x30, %rsi, %rsi
addq %rsi, %rcx
movl 0x8(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x104708
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x104683
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: refine_hic_trans(ug_opt_t*, kv_u_trans_t*, asg_t*, ma_ug_t*)
void refine_hic_trans(ug_opt_t *opt, kv_u_trans_t *ta, asg_t *sg, ma_ug_t *ug)
{
    filter_u_trans(ta, asm_opt.is_bub_trans, asm_opt.is_topo_trans, asm_opt.is_read_trans, asm_opt.is_base_trans);
    if(asm_opt.is_base_trans) {
        trans_base_infer(ug, sg, opt, ta, NULL);
    } 
    // dbg_prt_utg_trans(ta, ug, "pre");
    clean_u_trans_t_idx_filter_adv(ta, ug, sg, 0.95, 0);
    // dbg_prt_utg_trans(ta, ug, "after");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2bd2f5(%rip), %rax    # 0x3c47f8
movb 0x24d(%rax), %sil
leaq 0x2bd2e7(%rip), %rax    # 0x3c47f8
movb 0x24c(%rax), %dl
leaq 0x2bd2da(%rip), %rax    # 0x3c47f8
movb 0x24b(%rax), %cl
leaq 0x2bd2cd(%rip), %rax    # 0x3c47f8
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl 0x24a(%rax), %r8d
callq 0x101a10
leaq 0x2bd2af(%rip), %rax    # 0x3c47f8
cmpb $0x0, 0x24a(%rax)
je 0x10756c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x307700
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd 0x27aca0(%rip), %xmm0   # 0x382220
xorl %eax, %eax
movl %eax, %ecx
callq 0x1054c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: check_nc_status(asg_t*, ma_hit_t_alloc*, unsigned char*, unsigned int)
uint32_t check_nc_status(asg_t *sg, ma_hit_t_alloc *src, uint8_t *ff, uint32_t id)
{
    uint32_t i, tn; ma_hit_t *h;
    for (i = 0; i < src[id].length; i++) {
        h = &(src[id].buffer[i]); tn = Get_tn((*h));
        if(sg->seq[tn].del) continue;
        if(!ff[tn]) continue;
        if((Get_qs((*h)) == 0) && (Get_qe((*h)) == sg->seq[id].len)) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x24(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jae 0x107918
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x28(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x1078c5
jmp 0x10790a
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x1078d4
jmp 0x10790a
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, %eax
jne 0x107908
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl -0x24(%rbp), %edx
movl (%rcx,%rdx,8), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jne 0x107908
movl $0x1, -0x4(%rbp)
jmp 0x10791f
jmp 0x10790a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x10786a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: fill_cov_arr(ma_ug_t*, asg_t*, ma_hit_t_alloc*, unsigned char*, unsigned long, unsigned long*)
void fill_cov_arr(ma_ug_t *ug, asg_t *sg, ma_hit_t_alloc *src, uint8_t *ff, uint64_t uid, uint64_t *res)
{
    ma_hit_t *h; ma_utg_t *u;
    uint64_t C_bases, k, j, rid, tn;
    set_rset(ug, uid, ff, 1);

    u = &(ug->u.a[uid]);
    for (k = 0; k < u->n; k++) {
        C_bases = 0; rid = u->a[k]>>33;
        for (j = 0; j < src[rid].length; j++) {
            h = &(src[rid].buffer[j]);
            tn = Get_tn((*h));
            if((!sg->seq[tn].del) && (!ff[tn])) continue;
            if((sg->seq[tn].del) && (!check_nc_status(sg, src, ff, tn))) continue;
            C_bases += (Get_qe((*h)) - Get_qs((*h)));
        }
        res[k] = C_bases;
    }

    set_rset(ug, uid, ff, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0x107590
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x107cca
movq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rcx
imulq $0x18, -0x60(%rbp), %rdx
addq %rdx, %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jae 0x107ca9
movq -0x18(%rbp), %rax
imulq $0x18, -0x60(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
imulq $0x28, -0x58(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x68(%rbp), %rcx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x107c49
movq -0x20(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x107c49
jmp 0x107c98
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x68(%rbp), %rcx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x107c7e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x68(%rbp), %rax
movl %eax, %ecx
callq 0x107850
cmpl $0x0, %eax
jne 0x107c7e
jmp 0x107c98
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subl %ecx, %eax
movl %eax, %eax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x107be0
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x107ba4
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x107590
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: trans_sec_cut_filter_mmhap_adv(kv_u_trans_t*, ma_ug_t*, asg_t*, ma_hit_t_alloc*, ug_rid_cov_t*)
void trans_sec_cut_filter_mmhap_adv(kv_u_trans_t *ta, ma_ug_t *ug, asg_t *sg, ma_hit_t_alloc* src, ug_rid_cov_t *in)
{
    uint64_t k; asg64_v b64; kv_init(b64);
    ug_rid_cov_t *cc = ((in)?(in):(gen_ug_rid_cov_t(ug, sg, src)));

    fprintf(stderr, "+[M::%s]\thom_cov::%lu\thet_cov::%lu\thom_cut::%lu\n", __func__, 
        cc->hom_cov, cc->het_cov, cc->hom_max);

    for (k = 0; k < ug->g->n_seq; k++) {
        purge_ovlp_cov_adv(k, ta, &b64, cc, cc->hom_max);
    }

    if(!in) {destory_ug_rid_cov_t(cc); free(cc);} kv_destroy(b64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x109ed5
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x109eea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x107f90
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x2ba0e7(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x50(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x50(%rbp), %rax
movq 0x48(%rax), %r8
movq -0x50(%rbp), %rax
movq 0x38(%rax), %r9
leaq 0x27db07(%rip), %rsi    # 0x387a22
leaq 0x27db4c(%rip), %rdx    # 0x387a6e
movb $0x0, %al
callq 0x22a0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0x14(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x109f7a
movq -0x30(%rbp), %rax
movl %eax, %edi
movq -0x8(%rbp), %rsi
movq -0x50(%rbp), %rcx
movq -0x50(%rbp), %rax
movq 0x38(%rax), %r8
leaq -0x48(%rbp), %rdx
callq 0x109ae0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x109f31
cmpq $0x0, -0x28(%rbp)
jne 0x109f93
movq -0x50(%rbp), %rdi
callq 0x108300
movq -0x50(%rbp), %rdi
callq 0x2210
movq -0x38(%rbp), %rdi
callq 0x2210
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Overlaps.cpp
// Function: gen_ug_rid_cov_t_by_ovlp(kv_u_trans_t*, ug_rid_cov_t*)
void gen_ug_rid_cov_t_by_ovlp(kv_u_trans_t *ta, ug_rid_cov_t *cc)
{
    uint64_t z, k, id, n; u_trans_t *a; 
    for (z = 0; z < cc->ug->g->n_seq; z++) {
        id = z; a = u_trans_a(*ta, id); n = u_trans_n(*ta, id); 
        for (k = 0; k < n; k++) {
            append_cov_line_ug_rid_cov_t(id, cc->cov.a+cc->idx[id], &(a[k]), cc, ((uint64_t)-1), -1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x18(%rcx), %rcx
movl 0x14(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x10a0aa
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x10a097
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x38(%rbp), %rdx
imulq $0x30, -0x20(%rbp), %rax
addq %rax, %rdx
movq -0x10(%rbp), %rcx
movq $-0x1, %r8
movsd 0x2781f4(%rip), %xmm0   # 0x382278
callq 0x108a40
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10a038
jmp 0x10a099
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x109fc8
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10ca10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x90(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0xa8(%rax)
je 0x10ca04
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0xa8, %rdi
callq 0xfc940
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x64, %rdi
callq 0x2270
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x27a1f3(%rip), %rsi    # 0x387ba7
movb $0x0, %al
callq 0x2050
movq -0x20(%rbp), %rdi
leaq 0x28ba0c(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0x14(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jae 0x10dadd
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %edx
addl $0x1, %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
shrl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2778e5(%rip), %rax    # 0x385303
movsbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %esi
imulq $0xc, %rsi, %rsi
addq %rsi, %rax
movl 0x4(%rax), %r8d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %esi
imulq $0xc, %rsi, %rsi
addq %rsi, %rax
movl (%rax), %r9d
leaq 0x27a168(%rip), %rsi    # 0x387bbc
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x2c(%rbp), %edx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jae 0x10dabd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x2c(%rbp), %edx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
addl -0x30(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
leaq 0x27a127(%rip), %rsi    # 0x387bd2
movb $0x0, %al
callq 0x22a0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x10da62
movq -0x28(%rbp), %rdi
leaq 0x278f60(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x10d9d6
movq -0x28(%rbp), %rdi
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2210
movq 0x2b64ea(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x279c1b(%rip), %rsi    # 0x38771b
leaq 0x27a0cf(%rip), %rdx    # 0x387bd6
movb $0x0, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x32, %rdi
callq 0x2270
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x279827(%rip), %rsi    # 0x387bef
movb $0x0, %al
callq 0x2050
movq -0x38(%rbp), %rdi
leaq 0x28aff8(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x40(%rbp), %rax
leaq 0x27e5a6(%rip), %r9     # 0x38c9a8
movq %rax, (%rsp)
callq 0xefa60
movq -0x40(%rbp), %rdi
callq 0x21a0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x2797e5(%rip), %rsi    # 0x387c08
movb $0x0, %al
callq 0x2050
movq -0x38(%rbp), %rdi
leaq 0x28af9d(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x40(%rbp), %rax
leaq 0x27e54b(%rip), %r9     # 0x38c9a8
movq %rax, (%rsp)
callq 0xf1c10
movq -0x40(%rbp), %rdi
callq 0x21a0
movq -0x38(%rbp), %rdi
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
callq 0x2510
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movsd 0x277e3a(%rip), %xmm0   # 0x386870
callq 0x14b740
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x11d700
movq -0x40(%rbp), %rdi
callq 0xcdd10
movq -0x40(%rbp), %rdi
callq 0xce020
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x10eb9d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x10ead8
jmp 0x10eb8f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl 0x4(%rax,%rcx,8), %eax
cmpl $0x1, %eax
jne 0x10eb8d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xd9510
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0xc(%rax)
je 0x10eb8b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
jmp 0x10eb8f
jmp 0x10eb8f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10eab1
movq -0x10(%rbp), %rdi
callq 0xcdd10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x110f08
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x110f19
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
ja 0x111003
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x110f9f
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
movq -0x30(%rbp), %rcx
movl -0x38(%rbp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x14(%rcx), %eax
je 0x110ff3
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x110fed
cmpq $0x0, -0x20(%rbp)
je 0x110fd1
movq -0x30(%rbp), %rcx
movl -0x38(%rbp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x110fe4
movl -0x3c(%rbp), %ecx
subl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x11100a
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x110ff5
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x110f67
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x28(%rbp), %rcx
xorl %r8d, %r8d
callq 0x322770
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2210
movq -0x10(%rbp), %rdi
leaq 0x2b0a78(%rip), %rax    # 0x3c47f8
movb 0x24d(%rax), %sil
leaq 0x2b0a6a(%rip), %rax    # 0x3c47f8
movb 0x24c(%rax), %dl
leaq 0x2b0a5d(%rip), %rax    # 0x3c47f8
movb 0x24b(%rax), %cl
leaq 0x2b0a50(%rip), %rax    # 0x3c47f8
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl 0x24a(%rax), %r8d
callq 0x101a10
leaq 0x2b0a32(%rip), %rax    # 0x3c47f8
cmpb $0x0, 0x24a(%rax)
je 0x113de8
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x307700
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movsd 0x26e424(%rip), %xmm0   # 0x382220
xorl %eax, %eax
movl %eax, %ecx
callq 0x1054c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0x2b09d8(%rip), %rax    # 0x3c47f8
movss 0x170(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x20a0a0
movq -0x30(%rbp), %rdi
callq 0x1c4a90
movq -0x30(%rbp), %rdi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)