LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: load_trans_ovlp(char const*, ma_ug_t*)
trans_chain* load_trans_ovlp(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, "r"); free(gfa_name);
    if (!fp) return NULL;
    if(ug && (!test_dbug(ug, fp))) {
        fprintf(stderr, "[M::%s] Renew trans overlaps\n", __func__);
        fclose(fp);
        return NULL;
    }

    uint64_t flag = 0;
    trans_chain *t_ch = NULL;
    CALLOC(t_ch, 1);

    flag += fread(&t_ch->r_num, sizeof(t_ch->r_num), 1, fp);
    MALLOC(t_ch->ir_het, t_ch->r_num);
    flag += fread(t_ch->ir_het, sizeof(uint8_t), t_ch->r_num, fp);

    uint64_t i;
    flag += fread(&t_ch->bed.n, sizeof(t_ch->bed.n), 1, fp);
    MALLOC(t_ch->bed.a, t_ch->bed.n); t_ch->bed.m = t_ch->bed.n;
    for (i = 0; i < t_ch->bed.n; i++) {
        flag += fread(&t_ch->bed.a[i].n, sizeof(t_ch->bed.a[i].n), 1, fp);
        MALLOC(t_ch->bed.a[i].a, t_ch->bed.a[i].n); t_ch->bed.a[i].m = t_ch->bed.a[i].n;
        flag += fread(t_ch->bed.a[i].a, sizeof(bed_interval), t_ch->bed.a[i].n, fp);
    }

    flag += fread(&t_ch->k_trans.n, sizeof(t_ch->k_trans.n), 1, fp);
    MALLOC(t_ch->k_trans.a, t_ch->k_trans.n); t_ch->k_trans.m = t_ch->k_trans.n;
    flag += fread(t_ch->k_trans.a, sizeof(u_trans_t), t_ch->k_trans.n, fp);

    flag += fread(&t_ch->k_trans.idx.n, sizeof(t_ch->k_trans.idx.n), 1, fp);
    MALLOC(t_ch->k_trans.idx.a, t_ch->k_trans.idx.n); t_ch->k_trans.idx.m = t_ch->k_trans.idx.n;
    flag += fread(t_ch->k_trans.idx.a, sizeof(uint64_t), t_ch->k_trans.idx.n, fp);

    fclose(fp);
    fprintf(stderr, "[M::%s::] ==> Trans overlaps have been loaded\n", __func__);
    return t_ch;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2090
leaq 0x32(%rax), %rdi
callq 0x2280
movq %rax, %r12
leaq 0x1622c0(%rip), %rsi    # 0x22ad22
xorl %r14d, %r14d
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x16ab2e(%rip), %rsi    # 0x2335a7
movq %r12, %rdi
callq 0x2210
movq %rax, %r15
movq %r12, %rdi
callq 0x2220
testq %r15, %r15
jne 0xc8aa0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rbx, %rbx
je 0xc8ac1
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc270e
testl %eax, %eax
jne 0xc8ac1
movq %r15, %rdi
callq 0x10a4e
xorl %r14d, %r14d
jmp 0xc8a91
movq %rsp, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10a7a
movq (%rbx), %r14
jmp 0xc8a91
// File: /workspace/github_cpp_makefile_star2_O1/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), %ebx
movq 0x140(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x80(%rsp)
movl 0x118(%rsp), %eax
movl %eax, 0x68(%rsp)
movl 0x110(%rsp), %eax
movl %eax, 0x64(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x100(%rsp), %r15
movl $0x64, %edi
callq 0x2280
movq %rax, %r12
leaq 0x1c2639(%rip), %rax    # 0x28b230
movq 0x28(%rax), %rdi
movl 0x14(%rbp), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
callq 0x20e0
testl %ebx, %ebx
je 0xc8cf0
xorl %r14d, %r14d
leal 0x1(%r14), %r13d
movq %r12, %rdi
leaq 0x161d45(%rip), %rsi    # 0x22a969
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 0xc8ad4
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movq %r12, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rax
movl %eax, 0x28(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x30(%rsp)
movq %rbp, %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movl $0x1, %ecx
movq 0xb0(%rsp), %r8
movq 0xb8(%rsp), %r9
movss 0x6c(%rsp), %xmm0
movss 0x70(%rsp), %xmm1
movss 0x74(%rsp), %xmm2
callq 0xc21cc
movl %r13d, %r14d
cmpl %r13d, %ebx
jne 0xc8c16
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_O1/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 $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r13
movq %rdi, 0x10(%rsp)
movq %rcx, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
callq 0x2280
movq %rax, %r15
leaq 0x161c0a(%rip), %rsi    # 0x22ae14
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x1731e0(%rip), %rsi    # 0x23c3fe
movq %r15, %rdi
callq 0x2210
movq %rax, %r14
subq $0x8, %rsp
leaq 0x166907(%rip), %rax    # 0x22fb3b
leaq 0x1c1ff5(%rip), %rsi    # 0x28b230
movq %r13, %rdi
movq %r12, %rdx
movq %rbp, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
pushq %r14
pushq %rax
movq %rax, %r13
pushq $0x1
callq 0xb688e
addq $0x20, %rsp
movq %r14, %rdi
callq 0x2190
leaq 0x161bbf(%rip), %rsi    # 0x22ae2d
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
leaq 0x173179(%rip), %rsi    # 0x23c3fe
callq 0x2210
movq %rax, %rbx
subq $0x8, %rsp
movq 0x18(%rsp), %rdi
leaq 0x1c1f93(%rip), %rsi    # 0x28b230
movq %r12, %rdx
movq %rbp, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
pushq %rax
pushq %r13
pushq $0x0
callq 0xb688e
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x2190
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xc(%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
xorl %eax, %eax
movq %rax, 0x60(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %rax, 0x40(%rsp)
xorl %esi, %esi
callq 0xb1a83
movq %rax, %rbp
movq %rax, 0x28(%rsp)
movl 0x14(%rbx), %edi
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rdi
movl $0x1, %esi
callq 0x2120
movq %rax, %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, 0x10(%rsp)
movq %r15, %rdx
movq %r12, 0x18(%rsp)
movq %r12, %rcx
movq 0xb0(%rsp), %r15
movq %r15, %r8
movq %rax, %r9
callq 0xbe271
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq 0xb8(%rsp), %r8
movq %r13, %r9
callq 0xc9692
movq 0x18(%rbp), %rcx
movl 0x14(%rcx), %eax
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andq %rdx, %rax
je 0xc9613
movq 0x20(%rcx), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,8)
js 0xc960b
movb $0x0, 0x4(%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xc9600
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xc971c
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xba760
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 0x14(%rsp), %r9d
pushq $0x1
pushq %r15
pushq 0x38(%rsp)
callq 0xb5778
addq $0x20, %rsp
movq 0x10(%r15), %rdi
callq 0x2220
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16fe2e
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_O1/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, %r14
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
callq 0x300fc
movq 0x18(%rbp), %rbx
movsd 0x1604cf(%rip), %xmm0   # 0x229b90
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
movq %r14, %r9
callq 0xef57a
movq 0x18(%rbp), %rsi
movq %rbp, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %r14, %r9
callq 0xd2f0d
movq %rbx, %rdi
callq 0xa02fa
movq %rbx, %rdi
callq 0xa0333
movq %rbx, %rdi
callq 0xa03e9
orb $-0x80, 0x17(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x18(%rax), %r14
movl 0x14(%r14), %r15d
andq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
je 0xc986e
movq %rdi, %rbx
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movq 0x20(%r14), %rax
movl (%rax,%rbp,8), %ecx
testl %ecx, %ecx
js 0xc9862
cmpb $0x1, 0x4(%rax,%rbp,8)
jne 0xc9862
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, (%rax,%rbp,8)
leaq (,%rbp,2), %rax
xorl %ecx, %ecx
leaq (%rcx,%rax), %rdx
movq 0x28(%r14), %rsi
movq (%rsi,%rdx,8), %rdi
movq %rdi, %rsi
andq %r13, %rsi
je 0xc9805
shrq $0x20, %rdi
leaq (%rdi,%rdi,2), %rdi
shlq $0x3, %rdi
addq 0x8(%r14), %rdi
xorl %r8d, %r8d
leaq (%r8,%r8,2), %r9
orb $-0x80, 0xf(%rdi,%r9,8)
movl 0x8(%rdi,%r9,8), %r9d
xorq $0x1, %r9
movq 0x28(%r14), %r10
movq (%r10,%r9,8), %r10
movq %r10, %r9
andq %r13, %r9
je 0xc97fd
movq 0x8(%r14), %r11
shrq $0x20, %r10
shlq $0x3, %r9
leaq (%r9,%r9,2), %r9
leaq (%r10,%r10,2), %r10
leaq (%r11,%r10,8), %r10
addq $0xc, %r10
xorl %r11d, %r11d
movl -0x4(%r10,%r11), %r12d
xorl %edx, %r12d
cmpl $0x1, %r12d
jne 0xc97f4
orb $-0x80, 0x3(%r10,%r11)
addq $0x18, %r11
cmpq %r11, %r9
jne 0xc97e0
incq %r8
cmpq %rsi, %r8
jne 0xc979e
leaq 0x1(%rcx), %rdx
testq %rcx, %rcx
movq %rdx, %rcx
je 0xc9777
movq (%rbx), %rax
movq 0x10(%rax), %rax
leaq (,%rbp,4), %rcx
addq %rbp, %rcx
cmpl $0x0, 0xc(%rax,%rcx,8)
je 0xc9862
leaq (%rax,%rcx,8), %rcx
xorl %edx, %edx
movl %edx, 0x10(%rcx)
leaq (,%rbp,8), %rcx
leaq (%rcx,%rcx,4), %r12
movl %edx, 0xc(%rax,%r12)
movq 0x18(%rax,%r12), %rdi
callq 0x2220
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x18(%rax,%r12)
incq %rbp
cmpq %r15, %rbp
jne 0xc974a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa02fa
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0x1, %edi
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), %rax
movl %eax, %r15d
movl %eax, 0x1c(%rbx)
movq $0x0, 0x20(%rbx)
movq %r15, 0x28(%rbx)
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r14
movq %r14, %rdi
callq 0x2280
movq %rax, 0x30(%rbx)
movq %r15, 0x20(%rbx)
testq %r15, %r15
je 0xc990e
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20e0
movl $0x1, %esi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x10(%rbx)
movq %rax, 0x20(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x8(%rsp)
movl %ebp, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %r8
movq 0x88(%rsp), %r9
callq 0xc9994
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_O1/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 0x1941f6
addq $0x10, %rsp
movq %rax, %r15
movq (%r14), %rdi
leaq 0x1c0d79(%rip), %r12    # 0x28a758
cmpl $0x0, 0x148(%r12)
cvtsi2sdl 0x144(%r12), %xmm0
jne 0xc99fc
divsd 0x16016c(%rip), %xmm0   # 0x229b68
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x15b85c(%rip), %xmm0   # 0x225268
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 0x1f135
addq $0x10, %rsp
movq %rax, %rbx
movq (%r14), %rax
movl (%rax), %esi
movzwl 0x1bc(%r12), %ecx
movq %r15, %rdi
movq %rbx, %rdx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x16ae05
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xc9a85
movq (%r14), %rdx
movl 0x1bc(%r12), %ecx
movq %rbx, %rsi
callq 0xf159d
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_O1/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 %rbx
testq %rcx, %rcx
je 0xca7a9
movq $0x0, (%rcx)
testq %r8, %r8
je 0xca7b5
movl $0x0, (%r8)
movq 0x28(%rdi), %rax
movl %esi, %esi
movq (%rax,%rsi,8), %r9
testl %r9d, %r9d
je 0xca826
movq %r9, %rax
shrq $0x20, %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq 0x10(%rdi), %rax
xorl %edi, %edi
movl $0x1, %esi
movl %edi, %r10d
cmpl %esi, %r9d
je 0xca80a
movl %esi, %r11d
leaq (%r11,%r11,2), %r11
shlq $0x4, %r11
movl 0x14(%rax,%r11), %r11d
leaq (%r10,%r10,2), %rbx
shlq $0x4, %rbx
cmpl 0x14(%rax,%rbx), %r11d
jne 0xca80a
movl %edi, %r11d
jmp 0xca81c
leaq (%r10,%r10,2), %r10
shlq $0x4, %r10
movl %esi, %r11d
cmpl %edx, 0x14(%rax,%r10)
je 0xca82a
incl %esi
movl %r11d, %edi
cmpl %r9d, %esi
jbe 0xca7de
xorl %eax, %eax
popq %rbx
retq
testq %rcx, %rcx
je 0xca835
addq %r10, %rax
movq %rax, (%rcx)
movl $0x1, %eax
testq %r8, %r8
je 0xca828
subl %edi, %esi
movl %esi, (%r8)
jmp 0xca828
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, (%rbp)
movq %rcx, %rdi
movq %rdx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
callq 0x1f04d1
movq %rax, %r15
movq (%rbp), %rdi
callq 0x2220
leaq 0x1be70e(%rip), %rbp    # 0x28a758
movzbl 0x24d(%rbp), %esi
movzbl 0x24c(%rbp), %edx
movzbl 0x24b(%rbp), %ecx
movzbl 0x24a(%rbp), %r8d
movq %r12, %rdi
callq 0xc2a5f
cmpb $0x0, 0x24a(%rbp)
je 0xcc08c
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x1e0907
movsd 0x159404(%rip), %xmm0   # 0x225498
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xc476d
xorps %xmm0, %xmm0
cvtss2sd 0x170(%rbp), %xmm0
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x15b3de
movq %r15, %rdi
callq 0x1380d4
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_O1/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 0xcc612
retq
pushq %rbx
subq $0x10, %rsp
xorl %edx, %edx
cmpl $0x0, 0x10(%rdi)
je 0xcc632
leaq 0x10(%rdi), %rdx
leaq 0xc(%rsp), %rbx
movq %rbx, %rcx
callq 0x10e03
movl (%rbx), %edx
movq 0x1bd9a7(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x15e8d2(%rip), %rsi    # 0x22af15
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x10(%rdi), %rax
movl %esi, %esi
leaq (%rsi,%rsi,4), %rsi
cmpl $0x0, 0x10(%rax,%rsi,8)
je 0xcc8b7
leaq (%rax,%rsi,8), %rax
xorl %esi, %esi
movq 0x18(%rax), %rdi
movq (%rdi,%rsi,8), %rdi
shrq $0x21, %rdi
cmpb $0x0, (%rcx,%rdi)
jne 0xcc8ac
movb %dl, (%rcx,%rdi)
incq %rsi
movl 0x10(%rax), %edi
cmpq %rdi, %rsi
jb 0xcc897
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x14(%rdi), %eax
addl %eax, %eax
je 0xcc945
pushq %rbp
pushq %rbx
movq 0x20(%rdi), %rcx
movl %eax, %edx
xorl %esi, %esi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %esi, %r9d
shrl %r9d
cmpl $0x0, (%rcx,%r9,8)
js 0xcc93a
cmpb $0x1, 0x4(%rcx,%r9,8)
je 0xcc93a
movq 0x28(%rdi), %r9
movq (%r9,%rsi,8), %r9
movq %r9, %r10
andq %r8, %r10
je 0xcc934
movq 0x8(%rdi), %r11
shrq $0x20, %r9
leaq (%r9,%r9,2), %r9
leaq (%r11,%r9,8), %r9
addq $0xc, %r9
shlq $0x3, %r10
leaq (%r10,%r10,2), %r10
xorl %r11d, %r11d
xorl %ebx, %ebx
movl (%r9,%r11), %ebp
notl %ebp
shrl $0x1f, %ebp
addl %ebp, %ebx
addq $0x18, %r11
cmpq %r11, %r10
jne 0xcc91b
movslq %ebx, %r9
jmp 0xcc937
xorl %r9d, %r9d
addq %r9, %rax
incq %rsi
cmpq %rdx, %rsi
jne 0xcc8d5
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
testq %rsi, %rsi
je 0xccaf9
testq %rax, %rax
je 0xccb3f
movq 0x48(%rdi), %rdi
movq 0x10(%rsi), %rsi
leaq 0x1be79a(%rip), %rcx    # 0x28b230
movq 0x28(%rcx), %r8
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %edx, %edx
movl (%rdi,%r9,4), %r10d
shrl %r10d
leaq (%r10,%r10,4), %r10
cmpl $0x0, 0xc(%rsi,%r10,8)
je 0xccaec
leaq (%rsi,%r10,8), %r11
movl 0x10(%r11), %r10d
testq %r10, %r10
je 0xccaec
movq 0x18(%r11), %r11
xorl %ebx, %ebx
movq (%r11,%rbx,8), %r14
shrq $0x21, %r14
movzbl (%r8,%r14), %ebp
cmpl $0x2, %ebp
je 0xccae2
cmpl $0x1, %ebp
jne 0xccae4
incl %edx
jmp 0xccae4
incl %ecx
incq %rbx
cmpq %rbx, %r10
jne 0xccac7
incq %r9
movl %r9d, %r10d
cmpq %r10, %rax
ja 0xccaa1
jmp 0xccb43
testq %rax, %rax
je 0xccb3f
leaq 0x1be72b(%rip), %rcx    # 0x28b230
movq 0x28(%rcx), %rsi
movq 0x48(%rdi), %rdi
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %edx, %edx
movl (%rdi,%r8,4), %r9d
shrl %r9d
movzbl (%rsi,%r9), %r9d
cmpl $0x2, %r9d
je 0xccb30
cmpl $0x1, %r9d
jne 0xccb32
incl %edx
jmp 0xccb32
incl %ecx
incq %r8
movl %r8d, %r9d
cmpq %r9, %rax
ja 0xccb14
jmp 0xccb43
xorl %edx, %edx
xorl %ecx, %ecx
movl %edx, %eax
cvtsi2ss %rax, %xmm1
addl %ecx, %edx
cvtsi2ss %rdx, %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_O1/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
movq %rdx, (%rsp)
cmpq $0x0, 0x38(%rdi)
je 0xcd18e
movl %ecx, %ebx
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x48(%r12), %rcx
movl (%rcx,%r13,4), %ecx
shrl %ecx
leaq (%rcx,%rcx,4), %rcx
cmpl $0x0, 0x10(%rax,%rcx,8)
je 0xcd184
leaq (%rax,%rcx,8), %rbp
xorl %r14d, %r14d
movq 0x18(%rbp), %rax
movq (%rax,%r14,8), %rsi
shrq $0x21, %rsi
cmpl $-0x1, %ebx
je 0xcd16e
movq 0x48(%r12), %rax
movl (%rax,%r13,4), %edx
shrl %edx
movq %r15, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xa1cd4
jmp 0xcd179
movq 0x8(%r15), %rax
movl $0xffffffff, (%rax,%rsi,4) # imm = 0xFFFFFFFF
incq %r14
movl 0x10(%rbp), %eax
cmpq %rax, %r14
jb 0xcd140
incl %r13d
cmpq %r13, 0x38(%r12)
ja 0xcd11b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movl %eax, (%r8)
movl %eax, (%rcx)
movl %eax, (%rdx)
cmpl %eax, 0x10(%rdi)
je 0xcf497
pushq %rbx
movq 0x18(%rdi), %rax
leaq 0x1bbdd6(%rip), %r9     # 0x28b230
movq 0x28(%r9), %r9
xorl %r10d, %r10d
movq (%rax,%r10,8), %r11
shrq $0x21, %r11
movzbl (%r9,%r11), %ebx
movq %r8, %r11
testl %ebx, %ebx
je 0xcf487
movq %r8, %r11
cmpl $0x5, %ebx
je 0xcf487
movq %rdx, %r11
cmpl %esi, %ebx
je 0xcf487
movq %rcx, %r11
incl (%r11)
incq %r10
movl 0x10(%rdi), %r11d
cmpq %r11, %r10
jb 0xcf461
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edi
movl $0x30, %esi
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_O1/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, %r14d
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movl $0x1, %edi
movl $0x48, %esi
callq 0x2120
movq %rax, %rbx
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movl %r14d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movl 0x50(%rsp), %eax
movl %eax, 0x18(%rbx)
movl %eax, (%rsp)
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0xd10de
movq %rax, 0x30(%rbx)
movl $0x0, 0x40(%rbx)
movq 0x18(%r13), %rax
movl 0x14(%rax), %eax
addl %eax, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2120
movq %rax, 0x28(%rbx)
movl $0x1, %edi
movl $0x18, %esi
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_O1/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 0xa0004
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_O1/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
leaq (%rsi,%rsi,2), %rcx
cmpl $0x0, 0xc(%r8,%rcx,8)
js 0xd1da3
movq %rdi, %rax
leaq (%r8,%rcx,8), %rdi
movq 0x28(%rax), %rax
movl 0x8(%rdi), %esi
movq %rsi, %rcx
xorq $0x1, %rcx
movq (%rax,%rcx,8), %r9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
andq %r9, %rax
setne %cl
je 0xd1d99
shrq $0x20, %r9
movq %rax, %rdx
negq %rdx
leaq (%r9,%r9,2), %r9
leaq (%r8,%r9,8), %r8
addq $0xc, %r8
movl $0x1, %r9d
cmpl $0x0, (%r8)
js 0xd1d7f
movl 0x4(%rdi), %r10d
xorl -0x4(%r8), %r10d
cmpl $0x1, %r10d
je 0xd1d9e
cmpq %rax, %r9
setb %cl
leaq (%rdx,%r9), %r10
incq %r10
incq %r9
addq $0x18, %r8
cmpq $0x1, %r10
jne 0xd1d6b
callq 0x10efa
testb $0x1, %cl
je 0xd1d99
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
andq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
je 0xd407e
xorl %edx, %edx
leaq 0x1b7213(%rip), %rsi    # 0x28b230
movq 0x20(%rax), %r8
cmpl $0x0, (%r8,%rdx,8)
js 0xd4076
cmpb $0x1, 0x4(%r8,%rdx,8)
je 0xd4076
movq 0x10(%rdi), %r8
leaq (%rdx,%rdx,4), %r9
cmpl $0x0, 0xc(%r8,%r9,8)
je 0xd4076
leaq (%r8,%r9,8), %r8
cmpl $0x0, 0x10(%r8)
je 0xd4076
xorl %r9d, %r9d
movq 0x18(%r8), %r10
movq (%r10,%r9,8), %r10
shrq $0x21, %r10
movq 0x28(%rsi), %r11
cmpb $0x0, (%r11,%r10)
jne 0xd406a
movb $0x5, (%r11,%r10)
incq %r9
movl 0x10(%r8), %r10d
cmpq %r10, %r9
jb 0xd404e
incq %rdx
cmpq %rcx, %rdx
jne 0xd401d
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: update_hap_label(ma_ug_t*, asg_t*)
void update_hap_label(ma_ug_t *ug, asg_t* read_g)
{
    uint32_t v, n_vtx, k;
    uint64_t rId;

    if(ug == NULL)
    {
        n_vtx = read_g->n_seq;
        for (v = 0; v < n_vtx; ++v) 
        {
            if(read_g->seq[v].del) continue;
            if(read_g->seq[v].c != HAP_LABLE) continue;
            read_g->seq[v].c = PRIMARY_LABLE;
        }
        return;
    }


    asg_t* nsg = ug->g;
    n_vtx = nsg->n_seq;
    ma_utg_t* u = NULL;
    for (v = 0; v < n_vtx; ++v) 
    {
        if(nsg->seq[v].del) continue;
        if(nsg->seq[v].c != HAP_LABLE) continue;
        u = &((ug)->u.a[v]);
        if(u->m == 0) continue;
        for (k = 0; k < u->n; k++)
        {
            rId = u->a[k]>>33;
            read_g->seq[rId].c = HAP_LABLE;
        }
    }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xd5570
movq 0x18(%rdi), %rcx
movl 0x14(%rcx), %eax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
je 0xd559b
movq 0x20(%rcx), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,8)
js 0xd5566
cmpb $0x2, 0x4(%rcx,%rdx,8)
jne 0xd5566
movq 0x10(%rdi), %r8
leaq (%rdx,%rdx,4), %r9
cmpl $0x0, 0xc(%r8,%r9,8)
je 0xd5566
leaq (%r8,%r9,8), %r9
movl 0x10(%r9), %r8d
testq %r8, %r8
je 0xd5566
movq 0x18(%r9), %r9
movq 0x20(%rsi), %r10
xorl %r11d, %r11d
movq (%r9,%r11,8), %rbx
shrq $0x21, %rbx
movb $0x2, 0x4(%r10,%rbx,8)
incq %r11
cmpq %r11, %r8
jne 0xd5550
incq %rdx
cmpq %rax, %rdx
jne 0xd551b
jmp 0xd559b
movl 0x14(%rsi), %eax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
je 0xd559b
movq 0x20(%rsi), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,8)
js 0xd5593
cmpb $0x2, 0x4(%rcx,%rdx,8)
jne 0xd5593
movb $0x0, 0x4(%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xd5581
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: purge_dump(ma_ug_t*)
void purge_dump(ma_ug_t* ug)
{
    asg_t* nsg = ug->g;
    uint32_t v, n_vtx = nsg->n_seq, k, rId;
    ma_utg_t *u = NULL;
    for (v = 0; v < n_vtx; ++v) {
        if (nsg->seq[v].del) 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 && R_INF.trio_flag[rId] != DROP) break;
        }
        if(k >= u->n){
            if(u->m != 0){
                u->circ = u->end = u->len = u->m = u->n = u->start = 0;
                free(u->a);
                u->a = NULL;
            }
            asg_seq_del(nsg, v);
        }
    }
    asg_cleanup(nsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
movl 0x14(%rbx), %r15d
andq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
je 0xd5a05
movq %rdi, %r14
xorl %r12d, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x20(%rbx), %rax
cmpl $0x0, (%rax,%r12,8)
js 0xd59f9
movq 0x10(%r14), %rax
leaq (%r12,%r12,4), %rcx
cmpl $0x0, 0xc(%rax,%rcx,8)
je 0xd59f9
leaq (%rax,%rcx,8), %r13
movl 0x10(%r13), %eax
testq %rax, %rax
setne %cl
je 0xd5928
movq 0x18(%r13), %rdx
leaq 0x1b5952(%rip), %rsi    # 0x28b230
movq 0x28(%rsi), %rsi
movq %rax, %rdi
negq %rdi
movl $0x1, %r8d
movq -0x8(%rdx,%r8,8), %r9
shrq $0x21, %r9
movzbl (%rsi,%r9), %r9d
cmpl $0x5, %r9d
je 0xd5907
testl %r9d, %r9d
jne 0xd591f
cmpq %rax, %r8
setb %cl
leaq (%rdi,%r8), %r9
incq %r9
incq %r8
cmpq $0x1, %r9
jne 0xd58ee
jmp 0xd5928
testb $0x1, %cl
jne 0xd59f9
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r13)
movl $0x0, (%r13)
movq 0x18(%r13), %rdi
callq 0x2220
movq $0x0, 0x18(%r13)
movq 0x20(%rbx), %rax
orl $0x80000000, (%rax,%r12,8) # imm = 0x80000000
leaq (%r12,%r12), %rax
xorl %ecx, %ecx
leaq (%rcx,%rax), %rdx
movq 0x28(%rbx), %rsi
movq (%rsi,%rdx,8), %rdi
movq %rdi, %rsi
andq %rbp, %rsi
je 0xd59e9
shrq $0x20, %rdi
leaq (%rdi,%rdi,2), %rdi
shlq $0x3, %rdi
addq 0x8(%rbx), %rdi
xorl %r8d, %r8d
leaq (%r8,%r8,2), %r9
orb $-0x80, 0xf(%rdi,%r9,8)
movl 0x8(%rdi,%r9,8), %r9d
xorq $0x1, %r9
movq 0x28(%rbx), %r10
movq (%r10,%r9,8), %r10
movq %r10, %r9
andq %rbp, %r9
je 0xd59e1
movq 0x8(%rbx), %r11
shrq $0x20, %r10
shlq $0x3, %r9
leaq (%r9,%r9,2), %r9
leaq (%r10,%r10,2), %r10
leaq (%r11,%r10,8), %r10
addq $0xc, %r10
xorl %r11d, %r11d
movl -0x4(%r10,%r11), %r13d
xorl %edx, %r13d
cmpl $0x1, %r13d
jne 0xd59d8
orb $-0x80, 0x3(%r10,%r11)
addq $0x18, %r11
cmpq %r11, %r9
jne 0xd59c4
incq %r8
cmpq %rsi, %r8
jne 0xd5982
leaq 0x1(%rcx), %rdx
testq %rcx, %rcx
movq %rdx, %rcx
je 0xd595b
incq %r12
cmpq %r15, %r12
jne 0xd58a1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa02fa
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: discard_small_ctg(ma_ug_t**, asg_t*, kvec_asg_arc_t_warp*, int, unsigned int, unsigned int)
void discard_small_ctg(ma_ug_t **ug, asg_t* rg, kvec_asg_arc_t_warp* edge, int32_t max_rg_cut, uint32_t is_renew0, uint32_t is_renew1)
{
    if(is_renew0) renew_utg(ug, rg, edge);
    uint32_t i, cnt = 0; ma_utg_t* u = NULL;
    for (i = 0; i < (*ug)->u.n; i++) {
        if(((int32_t)(*ug)->u.a[i].n) > max_rg_cut) continue;
        u = &(((*ug))->u.a[i]);
        asg_seq_del((*ug)->g, i);
        if(u->m!=0) {
            u->m = u->n = 0; free(u->a); u->a = NULL; u->len = u->circ = 0; u->start = u->end = 0;
        }
        cnt++;
    }

    if(cnt && is_renew1) renew_utg(ug, rg, edge);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testl %r8d, %r8d
je 0xd5a4b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xba760
movq (%r15), %rax
cmpq $0x0, (%rax)
je 0xd5ba5
movl %ebp, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r13d, %r13d
xorl %r14d, %r14d
movl %r12d, 0xc(%rsp)
movq %r15, 0x20(%rsp)
movq 0x10(%rax), %rdx
leaq (%rcx,%rcx,4), %rsi
cmpl %r12d, 0x10(%rdx,%rsi,8)
jg 0xd5b7d
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
orl $0x80000000, (%rdi,%rcx,8) # imm = 0x80000000
leaq (%rdx,%rsi,8), %r12
leal (%r14,%r14), %ecx
xorl %edx, %edx
leaq (%rdx,%rcx), %rsi
movq 0x28(%rax), %rdi
movq (%rdi,%rsi,8), %r8
movq %r8, %rdi
andq %rbp, %rdi
je 0xd5b35
shrq $0x20, %r8
leaq (%r8,%r8,2), %r8
shlq $0x3, %r8
addq 0x8(%rax), %r8
xorl %r9d, %r9d
leaq (%r9,%r9,2), %r10
orb $-0x80, 0xf(%r8,%r10,8)
movl 0x8(%r8,%r10,8), %r10d
xorq $0x1, %r10
movq 0x28(%rax), %r11
movq (%r11,%r10,8), %r11
movq %r11, %r10
andq %rbp, %r10
je 0xd5b2d
movq 0x8(%rax), %r15
shrq $0x20, %r11
shlq $0x3, %r10
leaq (%r10,%r10,2), %r10
leaq (%r11,%r11,2), %r11
leaq (%r15,%r11,8), %r11
addq $0xc, %r11
xorl %r15d, %r15d
movl -0x4(%r11,%r15), %ebx
xorl %esi, %ebx
cmpl $0x1, %ebx
jne 0xd5b24
orb $-0x80, 0x3(%r11,%r15)
addq $0x18, %r15
cmpq %r15, %r10
jne 0xd5b12
incq %r9
cmpq %rdi, %r9
jne 0xd5ad0
leaq 0x1(%rdx), %rsi
testq %rdx, %rdx
movq %rsi, %rdx
je 0xd5aa9
cmpl $0x0, 0xc(%r12)
je 0xd5b70
xorl %ebx, %ebx
movq %rbx, 0xc(%r12)
movq 0x18(%r12), %rdi
callq 0x2220
movq %rbx, 0x18(%r12)
movq %rbx, (%r12)
movl $0x0, 0x8(%r12)
incl %r13d
movq 0x20(%rsp), %r15
movl 0xc(%rsp), %r12d
incl %r14d
movq (%r15), %rax
movq %r14, %rcx
cmpq %r14, (%rax)
ja 0xd5a7d
testl %r13d, %r13d
setne %cl
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movl 0x8(%rsp), %ebp
jmp 0xd5ba7
xorl %ecx, %ecx
testl %ebp, %ebp
sete %al
xorb $0x1, %cl
orb %al, %cl
jne 0xd5bcf
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xba760
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: debug_untig_length(ma_ug_t*, unsigned int, char const*)
int debug_untig_length(ma_ug_t *g, uint32_t tipsLen, const char* name)
{
	uint32_t i;

	for (i = 0; i < g->u.n; ++i) {
		ma_utg_t *u = &g->u.a[i];
        if(u->m == 0) continue;
        if(u->n <= tipsLen)
        {
            fprintf(stderr, "i: %u, u->n: %u, tipsLen: %u, %s\n", i, u->n, tipsLen, name);
        }
	}

	return 0;
}

// Assembly:
cmpq $0x0, (%rdi)
je 0xd8a3a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %r12d
movq 0x1b15ff(%rip), %r13    # 0x289fe0
leaq 0x152b20(%rip), %r15    # 0x22b508
xorl %eax, %eax
movq 0x10(%r14), %rcx
leaq (%rax,%rax,4), %rax
cmpl $0x0, 0xc(%rcx,%rax,8)
je 0xd8a04
leaq (%rcx,%rax,8), %rax
movl 0x10(%rax), %ecx
cmpl %ebp, %ecx
jbe 0xd8a11
movl %r12d, %eax
incl %r12d
cmpq %rax, (%r14)
ja 0xd89ea
jmp 0xd8a2c
leal -0x1(%r12), %edx
movq (%r13), %rdi
movq %r15, %rsi
movl %ebp, %r8d
movq %rbx, %r9
xorl %eax, %eax
callq 0x22b0
jmp 0xd8a04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: update_recover_atg_cov()
void update_recover_atg_cov()
{
    if(asm_opt.recover_atg_cov_min == -1024) {
        asm_opt.recover_atg_cov_max = (asm_opt.hom_global_coverage_set?
            (asm_opt.hom_global_coverage):(((double)asm_opt.hom_global_coverage)/((double)HOM_PEAK_RATE)));         
        asm_opt.recover_atg_cov_min = asm_opt.recover_atg_cov_max * 0.85;
        asm_opt.recover_atg_cov_max = INT32_MAX;
    }
}

// Assembly:
leaq 0x1b196c(%rip), %rax    # 0x28a758
cmpl $0xfffffc00, 0x13c(%rax) # imm = 0xFFFFFC00
jne 0xd8e35
cmpl $0x0, 0x148(%rax)
cvtsi2sdl 0x144(%rax), %xmm0
jne 0xd8e11
divsd 0x150d57(%rip), %xmm0   # 0x229b68
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
mulsd 0x150d67(%rip), %xmm0   # 0x229b88
cvttsd2si %xmm0, %ecx
movl %ecx, 0x13c(%rax)
movl $0x7fffffff, 0x140(%rax) # imm = 0x7FFFFFFF
retq