LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: check_if_no_coverage(asg_t*, asg_arc_t*, unsigned int)
uint32_t check_if_no_coverage(asg_t *r_g, asg_arc_t* list, uint32_t list_n)
{
    if(list_n < 2) return 0;
    uint32_t i, v, w, u_n = list_n - 1, nv, l, k;
    long long totalLen = 0;
    asg_arc_t *av = NULL;
    for (i = 0; i < u_n - 1; i++)
    {
        v = list[i].v;
        w = list[i+1].v; 
        av = asg_arc_a(r_g, v);
        nv = asg_arc_n(r_g, v);
        l = 0;
        
        for (k = 0; k < nv; k++)
        {
            if(av[k].del) continue;
            if(av[k].v == w) 
            {
                l = asg_arc_len(av[k]);
                break;
            }
        }

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

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

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

    return 0;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, %edx
jb 0xbe689
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, (%rsp)
leal -0x2(%rdx), %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq %r13, %rbp
je 0xbe640
imulq $0x18, %rbp, %rax
movl 0x8(%rbx,%rax), %ecx
movl 0x20(%rbx,%rax), %eax
incq %rbp
movq 0x8(%r15), %rsi
movq 0x28(%r15), %rdx
movq (%rdx,%rcx,8), %rcx
movq %rcx, %rdi
shrq $0x20, %rdi
movl %ecx, %edx
imulq $0x18, %rdi, %rdi
addq %rsi, %rdi
addq $0xc, %rdi
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xbe61f
cmpl $0x0, (%rdi)
js 0xbe609
cmpl %eax, -0x4(%rdi)
je 0xbe612
incq %rsi
addq $0x18, %rdi
jmp 0xbe5fa
movl -0xc(%rdi), %r14d
cmpl %esi, %ecx
je 0xbe622
addq %r14, %r12
jmp 0xbe5c4
xorl %r14d, %r14d
movq 0x1949b7(%rip), %rax    # 0x252fe0
movq (%rax), %rcx
leaq 0x12c74d(%rip), %rdi    # 0x1ead80
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
jmp 0xbe61a
movq (%rsp), %rdx
decl %edx
imulq $0x18, %r13, %rax
movl 0x8(%rbx,%rax), %eax
movq 0x20(%r15), %rcx
shrl %eax
movl (%rcx,%rax,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r12
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl 0xc(%rbx), %eax
andl %ecx, %eax
imulq $0x18, %rdx, %rdx
andl 0xc(%rbx,%rdx), %ecx
addl %eax, %ecx
xorl %eax, %eax
cmpq %rcx, %r12
setg %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_binned_reads(ma_hit_t_alloc*, unsigned long, ma_sub_t*)
void print_binned_reads(ma_hit_t_alloc* paf, uint64_t n_read, ma_sub_t* coverage_cut)
{
    uint64_t i, j, binned_flag;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x1933c4(%rip), %r12    # 0x252fb8
leaq 0x12b25a(%rip), %r13    # 0x1eae55
xorl %ebp, %ebp
movq %rdx, (%rsp)
cmpq 0x10(%rsp), %rbp
je 0xbfd00
testq %rdx, %rdx
je 0xbfc72
imulq $0xc, %rbp, %rbx
cmpl $0x0, (%rdx,%rbx)
js 0xbfcf4
addq (%rsp), %rbx
leaq 0x194606(%rip), %rax    # 0x254230
movq 0x28(%rax), %rax
movzbl (%rax,%rbp), %ecx
movq (%r12), %rdi
leaq 0x12b1a0(%rip), %rsi    # 0x1eaddd
movl %ebp, %edx
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
movzbl 0x8(%rbx), %edx
movl (%rbx), %r9d
movl 0x4(%rbx), %r8d
movl %r9d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shrl $0x1f, %r9d
leaq 0x12b190(%rip), %rsi    # 0x1eadf9
xorl %eax, %eax
callq 0x22b0
jmp 0xbfc95
leaq 0x1945b7(%rip), %rax    # 0x254230
movq 0x28(%rax), %rax
movzbl (%rax,%rbp), %ecx
movq (%r12), %rdi
leaq 0x12b151(%rip), %rsi    # 0x1eaddd
movl %ebp, %edx
xorl %eax, %eax
callq 0x22b0
imulq $0x18, %rbp, %r15
addq 0x8(%rsp), %r15
pushq $0x18
popq %r14
xorl %ebx, %ebx
movl 0xc(%r15), %eax
cmpq %rax, %rbx
jae 0xbfcf4
movq (%r15), %rax
cmpq $0x0, (%rax,%r14)
js 0xbfceb
movq (%r12), %rdi
movq -0x18(%rax,%r14), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movl -0x10(%rax,%r14), %r8d
movl -0xc(%rax,%r14), %r9d
movl -0x8(%rax,%r14), %r10d
movl -0x4(%rax,%r14), %r11d
movq %r13, %rsi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x22b0
popq %rcx
popq %rdx
incq %rbx
addq $0x28, %r14
jmp 0xbfca4
incq %rbp
movq (%rsp), %rdx
jmp 0xbfc01
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: set_hom_global_coverage(hifiasm_opt_t*, asg_t*, ma_sub_t*, ma_hit_t_alloc*, ma_hit_t_alloc*, R_to_U*, int, int)
void set_hom_global_coverage(hifiasm_opt_t *opt, asg_t *sg, ma_sub_t* coverage_cut, 
ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, R_to_U* ruIndex, int max_hang, int min_ovlp)
{
    if(opt->hom_global_coverage_set == 0)
    {
        ma_ug_t *ug = NULL;
        ug = ma_ug_gen(sg);

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

        ma_ug_destroy(ug);
    } 
}

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

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

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

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

    return len;
}

// Assembly:
pushq %r14
pushq %rbx
movq (%rcx), %r8
movq 0x18(%rcx), %rax
movl (%rax), %ecx
xorl %eax, %eax
movl %ecx, %ecx
imulq $0x1c, %rcx, %rcx
movl (%r8,%rcx), %ecx
cmpl %edx, %ecx
je 0xc09d5
movq 0x10(%rsi), %r10
movl %ecx, %r9d
shrl %r9d
imulq $0x28, %r9, %r11
leaq (%r10,%r11), %r9
movl 0x10(%r10,%r11), %r10d
xorl %r11d, %r11d
cmpq %r11, %r10
je 0xc0986
movq 0x20(%rdi), %rbx
movq 0x18(%r9), %r14
movq (%r14,%r11,8), %r14
shrq $0x21, %r14
movl (%rbx,%r14,8), %ebx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
addq %rbx, %rax
incq %r11
jmp 0xc09ae
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: flat_soma_v(asg_t*, ma_hit_t_alloc*, R_to_U*)
void flat_soma_v(asg_t *sg, ma_hit_t_alloc* sources, R_to_U* ruIndex)
{
    uint64_t dip_thre_max;
    if(asm_opt.somatic_cov >= 0) {
        dip_thre_max = asm_opt.somatic_cov;
    } else {
        if(asm_opt.hom_global_coverage_set) {
            dip_thre_max = asm_opt.hom_global_coverage;
        } else {
            dip_thre_max = ((double)asm_opt.hom_global_coverage)/((double)HOM_PEAK_RATE);
        }
        dip_thre_max = (((double)(dip_thre_max)*1.15)/asm_opt.polyploidy);
    }
    flat_bubbles_advance(sg, sources, ruIndex, dip_thre_max);
}

// Assembly:
leaq 0x192815(%rip), %rax    # 0x253758
movq 0x280(%rax), %rcx
testq %rcx, %rcx
jns 0xc09d9
movslq 0x144(%rax), %rcx
cvtsi2sd %ecx, %xmm0
divsd 0x126cfa(%rip), %xmm0   # 0x1e7c60
movsd 0x12232a(%rip), %xmm1   # 0x1e3298
cvttsd2si %xmm0, %r8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %r9
movq %r8, %r10
sarq $0x3f, %r10
andq %r9, %r10
orq %r8, %r10
cmpl $0x0, 0x148(%rax)
cmovneq %rcx, %r10
movq %r10, %xmm0
punpckldq 0x1222cf(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1222d7(%rip), %xmm0   # 0x1e3280
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0x126ceb(%rip), %xmm2   # 0x1e7ca8
cvtsi2sdl 0x1bc(%rax), %xmm0
divsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %r8
sarq $0x3f, %r8
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %rcx
andq %r8, %rcx
orq %rax, %rcx
jmp 0xc09d9
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_outfile_name(char*)
char *get_outfile_name(char* output_file_name)
{
    char *buf = NULL;
    CALLOC(buf, strlen(output_file_name) + 25);
    if(ha_opt_triobin(&asm_opt) && ha_opt_hic(&asm_opt))
    {
        sprintf(buf, "%s.hic.bench", output_file_name);
    }
    else if(ha_opt_triobin(&asm_opt))
    {
        sprintf(buf, "%s.dip", output_file_name);
    }
    else if(ha_opt_hic(&asm_opt))
    {
        sprintf(buf, "%s.hic", output_file_name);
    }
    else if(asm_opt.flag & HA_F_PARTITION)
    {
        sprintf(buf, "%s.bp", output_file_name);
    }
    else
    {
        sprintf(buf, "%s", output_file_name);
    }

    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2090
leaq 0x19(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x2120
movq %rax, %rbx
callq 0xa4437
leaq 0x192748(%rip), %rcx    # 0x253758
cmpq $0x0, 0x50(%rcx)
sete %sil
cmpq $0x0, 0x58(%rcx)
sete %dl
orb %sil, %dl
testl %eax, %eax
je 0xc1035
testb %dl, %dl
je 0xc1051
leaq 0x129ecb(%rip), %rsi    # 0x1eaefe
jmp 0xc106a
testb %dl, %dl
je 0xc105a
testb $0x8, 0x1(%rcx)
jne 0xc1063
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
leaq 0x129e99(%rip), %rsi    # 0x1eaef1
jmp 0xc106a
leaq 0x129ea4(%rip), %rsi    # 0x1eaf05
jmp 0xc106a
leaq 0x129ea2(%rip), %rsi    # 0x1eaf0c
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: create_ul_info(ma_hit_t_alloc*, ma_hit_t_alloc*, long, long, long, long, unsigned long*, ma_sub_t*, R_to_U*, long long, float, long long, float, float, bub_label_t*, telo_end_t*)
void create_ul_info(ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, int64_t max_hang, int64_t min_ovlp, int64_t gap_fuzz, 
int64_t min_dp, uint64_t* readLen, ma_sub_t *coverage_cut, R_to_U* ruIndex, long long tipsLen, float tip_drop_ratio, long long stops_threshold, float chimeric_rate, float drop_ratio, bub_label_t* b_mask_t, telo_end_t *te)
{
    ug_opt_t opt; 
    gen_ug_opt_t(&opt, sources, reverse_sources, max_hang, min_ovlp, gap_fuzz, min_dp, readLen, coverage_cut, ruIndex, 
    tipsLen, tip_drop_ratio, stops_threshold, chimeric_rate, drop_ratio, b_mask_t, te);
    ul_load(&opt);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq 0xe0(%rsp), %r10
movq 0xd8(%rsp), %r11
movq 0xd0(%rsp), %rbx
movq 0xc8(%rsp), %r14
movq 0xc0(%rsp), %r15
movq 0xb8(%rsp), %r12
movq 0xb0(%rsp), %r13
xorps %xmm3, %xmm3
leaq 0x8(%rsp), %rax
movups %xmm3, 0x40(%rax)
movups %xmm3, 0x30(%rax)
movups %xmm3, 0x20(%rax)
movq %rdi, 0x8(%rax)
movq %rsi, 0x10(%rax)
movl %edx, 0x40(%rax)
movl %ecx, 0x44(%rax)
movq %r8, 0x50(%rax)
movq %r9, 0x58(%rax)
movq %r13, 0x68(%rax)
movq %r12, (%rax)
movq %r15, 0x30(%rax)
movq %r14, 0x18(%rax)
movss %xmm0, 0x20(%rax)
movq %rbx, 0x28(%rax)
movss %xmm1, 0x38(%rax)
movss %xmm2, 0x3c(%rax)
movq %r11, 0x60(%rax)
movq %r10, 0x70(%rax)
movq %rax, %rdi
callq 0x19adc5
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: rescue_src_ul(ma_hit_t_alloc*, unsigned long, unsigned long)
void rescue_src_ul(ma_hit_t_alloc* src, uint64_t n_read, uint64_t occ)
{
    uint64_t k, i;
    for (k = 0; k < n_read; k++) {
        for (i = 0; i < src[k].length; i++) {
            if(!src[k].buffer[i].del) continue;
            if(src[k].buffer[i].bl>=occ) src[k].buffer[i].del = 0;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
xorl %eax, %eax
movabsq $0x18, %rcx
cmpq %rsi, %rax
je 0xc1222
imulq $0x18, %rax, %r8
addq %rdi, %r8
movq %rcx, %r9
xorl %r10d, %r10d
movl 0xc(%r8), %r11d
cmpq %r11, %r10
jae 0xc121d
movq (%r8), %r11
movq (%r11,%r9), %rbx
testq %rbx, %rbx
jns 0xc1214
movq %rbx, %r14
shrq $0x20, %r14
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
cmpq %rdx, %r14
jb 0xc1214
btrq $0x3f, %rbx
movq %rbx, (%r11,%r9)
incq %r10
addq $0x28, %r9
jmp 0xc11e3
incq %rax
jmp 0xc11d1
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: prt_dbg_gfa(asg_t*, char const*, ma_sub_t*, ma_hit_t_alloc*, R_to_U*, long, long)
void prt_dbg_gfa(asg_t *sg, const char *suffix, ma_sub_t *cov, ma_hit_t_alloc* src, R_to_U* ruIndex, int64_t max_hang, int64_t min_ovlp)
{
    char *o_file = get_outfile_name(asm_opt.output_file_name);
    char* gfa_name; MALLOC(gfa_name, strlen(o_file)+strlen(suffix)+50); sprintf(gfa_name, "%s.%s", o_file, suffix);
    print_debug_gfa(sg, NULL, cov, gfa_name, src, ruIndex, max_hang, min_ovlp, 0, 0, 1);
    free(gfa_name); free(o_file);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movl 0x50(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x1924ff(%rip), %rax    # 0x253758
movq 0x10(%rax), %rdi
callq 0xc0fe9
movq %rax, %r14
movq %rax, %rdi
callq 0x2090
movq %rax, %rbx
movq %r15, %rdi
callq 0x2090
leaq (%rbx,%rax), %rdi
addq $0x32, %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x129c83(%rip), %rsi    # 0x1eaf12
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2050
subq $0x8, %rsp
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq 0x8(%rsp), %r9
pushq $0x1
pushq $0x0
pushq $0x0
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x926e3
addq $0x30, %rsp
movq %rbx, %rdi
callq 0x2220
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: renew_g(ma_hit_t_alloc**, ma_hit_t_alloc**, long long*, unsigned long**, ma_sub_t**, R_to_U*, asg_t**, long, long, ug_opt_t*, long, double, double, long, bub_label_t*, unsigned int, char*, char const*, unsigned long, unsigned long, unsigned long)
void renew_g(ma_hit_t_alloc **sources, ma_hit_t_alloc **reverse_sources, long long *n_read, 
uint64_t **readLen, ma_sub_t **coverage_cut, R_to_U *ruIndex, asg_t **sg, int64_t mini_overlap_length, 
int64_t max_hang_length, ug_opt_t *uopt, int64_t clean_round, double min_ovlp_drop_ratio, 
double max_ovlp_drop_ratio, int64_t max_tip, bub_label_t *b_mask_t, uint32_t is_trio, 
char *o_file, const char *bin_file, uint64_t free_uld, uint64_t is_bridg, uint64_t deep_clean)
{
    ul_renew_t nopt; memset(&nopt, 0, sizeof(nopt));
    nopt.src = sources; nopt.r_src = reverse_sources; nopt.ruIndex = ruIndex;
    nopt.n_read = n_read; nopt.readLen = readLen; nopt.sg = sg;
    nopt.cov = coverage_cut; nopt.b_mask_t = b_mask_t;
    nopt.max_hang = max_hang_length; nopt.mini_ovlp = mini_overlap_length;
    ul_realignment_gfa(uopt, *sg, clean_round, min_ovlp_drop_ratio, max_ovlp_drop_ratio, 
        asm_opt.max_short_tip, asm_opt.max_short_ul_tip, b_mask_t, ha_opt_triobin(&asm_opt), o_file, &nopt, bin_file, free_uld, is_bridg, deep_clean);
    // ma_ug_t *iug = ul_realignment_gfa(uopt, *sg, clean_round, min_ovlp_drop_ratio, max_ovlp_drop_ratio, 
    //                                                                 asm_opt.max_short_tip, b_mask_t, ha_opt_triobin(&asm_opt), o_file);
    // asg_t *ng = gen_ng(iug, *sg, uopt, coverage_cut, ruIndex, 256);
    // ma_ug_destroy(iug); asg_destroy(*sg);
    // (*sources) = R_INF.paf; 
    // (*reverse_sources) = R_INF.reverse_paf;
    // (*n_read) = R_INF.total_reads;
    // (*readLen) = R_INF.read_length;
    // (*sg) = ng; 
    // ma_hit_contained_advance(*sources, *n_read, *coverage_cut, ruIndex, max_hang_length, mini_overlap_length);
    // post_rescue(uopt, *sg, (*sources), (*reverse_sources), ruIndex, b_mask_t, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movsd %xmm1, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq 0x110(%rsp), %r14
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %r10
movq 0x100(%rsp), %r15
movq 0xd0(%rsp), %r11
leaq 0x48(%rsp), %rbx
movq %rdi, (%rbx)
movq %rsi, 0x8(%rbx)
movq %r9, 0x28(%rbx)
movq %rdx, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movq %r11, 0x20(%rbx)
movq %r8, 0x30(%rbx)
movq %r15, 0x38(%rbx)
movq %r10, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movq (%r11), %r12
leaq 0x191f91(%rip), %rax    # 0x253758
movslq 0x11c(%rax), %r13
movslq 0x120(%rax), %rbp
callq 0xa4437
movups 0x128(%rsp), %xmm0
movups %xmm0, 0x28(%rsp)
movups 0x118(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movl %eax, (%rsp)
movq 0xe8(%rsp), %rdi
movq %r12, %rsi
movq 0xf0(%rsp), %rdx
movsd 0x38(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movq %r13, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x1dcb75
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/./Overlaps.h
// Function: count_out_without_del(asg_t const*, unsigned int)
static inline int count_out_without_del(const asg_t *g, uint32_t v)
{
	uint32_t i, n, nv = asg_arc_n(g, v);
	const asg_arc_t *av = asg_arc_a(g, v);

	for (i = n = 0; i < nv; ++i)
		if (!av[i].del) ++n;
	return n;
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x28(%rdi), %rcx
movl %esi, %edx
movq (%rcx,%rdx,8), %rcx
movl %ecx, %edx
movq %rcx, %rsi
shrq $0x20, %rsi
imulq $0x18, %rdx, %rcx
imulq $0x18, %rsi, %rdx
addq %rax, %rdx
addq $0xc, %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rcx
je 0xc2d44
movl (%rdx,%rsi), %edi
notl %edi
shrl $0x1f, %edi
addl %edi, %eax
addq $0x18, %rsi
jmp 0xc2d2f
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/./Overlaps.h
// Function: get_real_length(asg_t*, unsigned int, unsigned int*)
inline int get_real_length(asg_t *g, uint32_t v, uint32_t* v_s)
{
    uint32_t i, kv = 0;
    for (i = 0, kv = 0; i < asg_arc_n(g, v); i++)
    {
        if(!asg_arc_a(g, v)[i].del)
        {
            if(v_s) v_s[kv] = asg_arc_a(g, v)[i].v;
            kv++;
        }
    }

    return kv;
}

// Assembly:
movq 0x28(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
shrq $0x20, %rax
imulq $0x18, %rax, %rsi
addq $0xc, %rsi
xorl %eax, %eax
subq $0x1, %rcx
jb 0xc2ebe
movq 0x8(%rdi), %r8
cmpl $0x0, (%r8,%rsi)
js 0xc2eb8
testq %rdx, %rdx
je 0xc2eb6
movl -0x4(%r8,%rsi), %r8d
movl %eax, %r9d
movl %r8d, (%rdx,%r9,4)
incl %eax
addq $0x18, %rsi
jmp 0xc2e94
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: check_weak_ma_hit(ma_hit_t_alloc*, ma_hit_t_alloc*, long long, unsigned int, unsigned int)
inline int check_weak_ma_hit(ma_hit_t_alloc* aim_paf, ma_hit_t_alloc* reverse_paf_list, 
long long weakID, uint32_t w_qs, uint32_t w_qe)
{
    long long i = 0;
    long long strongID, index;
    for (i = 0; i < aim_paf->length; i++)
    {
        ///if this is a strong overlap
        if (
        aim_paf->buffer[i].del == 0
        &&
        aim_paf->buffer[i].ml == 1
        && 
        Get_qs(aim_paf->buffer[i]) <= w_qs
        && 
        Get_qe(aim_paf->buffer[i]) >= w_qe)
        {
            strongID = Get_tn(aim_paf->buffer[i]);
            index = get_specific_overlap(&(reverse_paf_list[strongID]), strongID, weakID);
            if(index != -1) {
                // if((Get_qn(aim_paf->buffer[i]) == 27087 && weakID == 27128) || (Get_qn(aim_paf->buffer[i]) == 27128 && weakID == 27087)) {
                //     ma_hit_t *h = &(aim_paf->buffer[i]);
                //     fprintf(stderr, "[M::%s]\t%.*s(qn::%u)\t%u\t%u\t%u\t%c\t%.*s(tn::%u)\t%u\t%u\t%u\t%u\t%u\t255\n", __func__, (int)Get_NAME_LENGTH(R_INF, Get_qn(*h)), Get_NAME((R_INF), Get_qn(*h)), Get_qn(*h), (uint32_t)Get_READ_LENGTH(R_INF, Get_qn(*h)), Get_qs(*h), Get_qe(*h), "+-"[h->rev], 
                //         (int)Get_NAME_LENGTH(R_INF, Get_tn(*h)), Get_NAME((R_INF), Get_tn(*h)), Get_tn(*h), (uint32_t)Get_READ_LENGTH(R_INF, Get_tn(*h)), Get_ts(*h), Get_te(*h), h->ml, h->bl);
                // }
                return 0;
            }
        }
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
movl 0xc(%rdi), %r15d
xorl %r14d, %r14d
movabsq $-0x7fffffffc0000000, %rsi # imm = 0x8000000040000000
xorl %ebx, %ebx
cmpq %r15, %rbx
jae 0xc31c4
movq (%r13), %rax
movq 0x18(%rax,%r14), %rdx
andq %rsi, %rdx
cmpq $0x40000000, %rdx       # imm = 0x40000000
jne 0xc31bb
cmpl %r12d, (%rax,%r14)
ja 0xc31bb
cmpl %ebp, 0x8(%rax,%r14)
jb 0xc31bb
movl 0xc(%rax,%r14), %esi
imulq $0x18, %rsi, %rdi
addq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x696ab
movabsq $-0x7fffffffc0000000, %rsi # imm = 0x8000000040000000
cmpq $-0x1, %rax
jne 0xc31d6
incq %rbx
addq $0x28, %r14
jmp 0xc316c
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xc31c7
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/./Overlaps.h
// Function: get_origin_uid(unsigned int, trans_chain*, unsigned int*, unsigned int*)
inline uint32_t get_origin_uid(uint32_t v, trans_chain* t_ch, uint32_t *off, uint32_t *idx)
{
	if(off) (*off) = (t_ch->rUpos[v>>1]>>32);
	if(idx) (*idx) = (uint32_t)(t_ch->rUpos[v>>1]);
    if(t_ch->rUpos[v>>1] == (uint64_t)-1) return (uint32_t)-1;
    return (uint32_t)(((t_ch->rUidx[v>>1]>>1)<<1) + ((t_ch->rUidx[v>>1]^v)&1));
}

// Assembly:
movl %edi, %eax
testq %rdx, %rdx
je 0xc31f2
movq 0x8(%rsi), %rdi
movl %eax, %r8d
shrl %r8d
movl 0x4(%rdi,%r8,8), %edi
movl %edi, (%rdx)
movl %eax, %edx
shrl %edx
movq 0x8(%rsi), %rdi
testq %rcx, %rcx
je 0xc3206
movl (%rdi,%rdx,8), %r8d
movl %r8d, (%rcx)
cmpq $-0x1, (%rdi,%rdx,8)
je 0xc3217
movq (%rsi), %rcx
andl $0x1, %eax
xorl (%rcx,%rdx,4), %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/./Overlaps.h
// Function: check_tip(asg_t*, unsigned int, unsigned int*, buf_t*, unsigned int)
inline uint32_t check_tip(asg_t *sg, uint32_t begNode, uint32_t* endNode, buf_t* b, uint32_t max_ext)
{
    ///cut tip of length <= max_ext
    uint32_t v = begNode, w;
    uint32_t kv;
    uint32_t eLen = 0;
    (*endNode) = (uint32_t)-1;
    b->b.n = 0;
    while (1)
    {
        kv = get_real_length(sg, v, NULL);
        (*endNode) = v;
        eLen++;
        if(b) kv_push(uint32_t, b->b, v);
        if(kv == 0) return END_TIPS;
        if(kv > 1) return MUL_OUTPUT;
        ///if(eLen > max_ext) return LONG_TIPS;
        ///kv must be 1 here
        kv = get_real_length(sg, v, &w);
        ///here this value must be >= 1
        if(get_real_length(sg, w^1, NULL)!=1) return MUL_INPUT;
        v = w;
        if(v == begNode) return LOOP;
        if(eLen >= max_ext) return LONG_TIPS;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, %r15
orl $-0x1, (%rdx)
movl %esi, %r12d
andq $0x0, 0x38(%rcx)
movq %rdi, %r13
xorl %ebx, %ebx
movl %esi, 0x14(%rsp)
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0xc2e7a
movl %eax, %ebp
movl %r12d, (%r15)
testq %r14, %r14
je 0xc329f
movq 0x38(%r14), %rcx
movq 0x48(%r14), %rax
cmpq 0x40(%r14), %rcx
jne 0xc3293
leaq (%rcx,%rcx), %rsi
testq %rcx, %rcx
pushq $0x2
popq %rcx
cmoveq %rcx, %rsi
movq %rsi, 0x40(%r14)
shlq $0x2, %rsi
movq %rax, %rdi
callq 0x2370
movq %rax, 0x48(%r14)
movq 0x38(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%r14)
movl %r12d, (%rax,%rcx,4)
cmpl $0x1, %ebp
jne 0xc32e6
movq %r13, %rdi
movl %r12d, %esi
leaq 0xc(%rsp), %rdx
callq 0xc2e7a
movl 0xc(%rsp), %esi
xorl $0x1, %esi
movq %r13, %rdi
xorl %edx, %edx
callq 0xc2e7a
cmpl $0x1, %eax
jne 0xc32f1
movl 0xc(%rsp), %r12d
cmpl 0x14(%rsp), %r12d
je 0xc32f5
incl %ebx
cmpl 0x10(%rsp), %ebx
jb 0xc3248
xorl %eax, %eax
jmp 0xc32f8
testl %ebp, %ebp
pushq $0x4
popq %rax
jne 0xc32f8
pushq $0x5
jmp 0xc32f7
pushq $0x3
jmp 0xc32f7
pushq $0x7
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: trio_check(ma_ug_t*, unsigned int*, unsigned int, unsigned int)
inline int trio_check(ma_ug_t *ug, uint32_t *a, uint32_t a_n, uint32_t flag)
{
    if(flag != FATHER && flag != MOTHER) return 0;
    uint32_t flag_occ = 0, non_flag_occ = 0, ambigious = 0, u_n = 0, f, nf, ab, k;
    for (k = 0; k < a_n; k++) {
        get_unitig_trio_flag(&(ug->u.a[a[k]>>1]), flag, &f, &nf, &ab);
        flag_occ += f;
        non_flag_occ += nf;
        ambigious += ab;
        u_n += ug->u.a[a[k]>>1].n;
    }    
    if((flag_occ+non_flag_occ) == 0) return 0;
    if(flag_occ <= ((non_flag_occ+flag_occ)*0.75)) return 0;
    if(non_flag_occ == 0 && flag_occ >= 20) return 1;
    if(u_n >= 100)
    {
        if(flag_occ < u_n*DOUBLE_CHECK_THRES) return 0;
    }
    else if(u_n >= 50)
    {
        if(flag_occ < u_n*DOUBLE_CHECK_THRES*0.5) return 0;
    }
    else
    {
        if(flag_occ < u_n*DOUBLE_CHECK_THRES*0.25) return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
addl $-0x3, %ecx
xorl %eax, %eax
cmpl $-0x2, %ecx
jb 0xc388f
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %eax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq %rbx, 0x10(%rsp)
je 0xc380f
movl (%r14,%rbx,4), %eax
shrl %eax
imulq $0x28, %rax, %rdi
addq 0x10(%r15), %rdi
movq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x24(%rsp), %r8
callq 0x94ad6
addl 0xc(%rsp), %r13d
addl 0x8(%rsp), %ebp
movq 0x10(%r15), %rax
movl (%r14,%rbx,4), %ecx
shrl %ecx
imulq $0x28, %rcx, %rcx
addl 0x10(%rax,%rcx), %r12d
incq %rbx
jmp 0xc37c0
xorl %eax, %eax
movl %ebp, %ecx
addl %r13d, %ecx
je 0xc388f
movl %r13d, %edx
cvtsi2sd %rdx, %xmm0
movl %ecx, %ecx
cvtsi2sd %rcx, %xmm1
mulsd 0x11fd59(%rip), %xmm1   # 0x1e3588
ucomisd %xmm0, %xmm1
jae 0xc388f
testl %ebp, %ebp
sete %dl
cmpl $0x14, %r13d
setae %sil
pushq $0x1
popq %rcx
testb %sil, %dl
jne 0xc388d
cmpl $0x64, %r12d
jb 0xc3862
movl %r12d, %edx
cvtsi2sd %rdx, %xmm1
mulsd 0x11f390(%rip), %xmm1   # 0x1e2bf0
jmp 0xc3887
cvtsi2sd %r12d, %xmm1
mulsd 0x11f381(%rip), %xmm1   # 0x1e2bf0
cmpl $0x32, %r12d
jb 0xc387f
mulsd 0x11fccb(%rip), %xmm1   # 0x1e3548
jmp 0xc3887
mulsd 0x11fc99(%rip), %xmm1   # 0x1e3520
ucomisd %xmm0, %xmm1
ja 0xc388f
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_scp_len(sec_t*, ma_ug_t*)
inline uint64_t get_scp_len(sec_t *scp, ma_ug_t *mg)
{
    uint64_t k, len; ma_utg_t *z = NULL;
    for (k = len = 0; k < scp->n; k++) {
        z = &(mg->u.a[((uint32_t)scp->a[k])>>1]); len += z->len; len += (scp->a[k]>>32);
    }

    return len;
}

// Assembly:
movq 0x8(%rdi), %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0xc3926
movq 0x10(%rsi), %r8
movq 0x18(%rdi), %r9
movq (%r9,%rdx,8), %r9
movl %r9d, %r10d
shrl %r10d
imulq $0x28, %r10, %r10
movl (%r8,%r10), %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
shrq $0x20, %r9
addq %rax, %r9
addq %r8, %r9
incq %rdx
movq %r9, %rax
jmp 0xc38ee
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: reset_visit_flag(unsigned char*, asg_t*, R_to_U*, unsigned int, ma_hit_t_alloc*)
inline void reset_visit_flag(uint8_t* visit, asg_t *read_g, R_to_U* ruIndex, uint32_t contigNum, 
ma_hit_t_alloc* x)
{
    uint32_t k, rId, is_Unitig, Hap_cId;

    if(x->length*2 > contigNum)
    {
        memset(visit, 0, contigNum);
    }
    else
    {
        for (k = 0; k < x->length; k++)
        {
            rId = Get_tn(x->buffer[k]);
        
            if(read_g->seq[rId].del == 1)
            {
                ///get the id of read that contains it 
                get_R_to_U(ruIndex, rId, &rId, &is_Unitig);
                if(rId == (uint32_t)-1 || is_Unitig == 1 || read_g->seq[rId].del == 1) continue;
            }

            ///there are two cases: 
            ///1. read at primary contigs, get_R_to_U() return its corresponding contig Id  
            ///2. read at alternative contigs, get_R_to_U() return (uint32_t)-1
            get_R_to_U(ruIndex, rId, &Hap_cId, &is_Unitig);
            if(is_Unitig == 0 || Hap_cId == (uint32_t)-1) continue;
            ///here rId is the id of the read coming from the different haplotype
            ///Hap_cId is the id of the corresponding contig (note here is the contig, instead of untig)
            visit[Hap_cId] = 0;
        }
    }
}

// Assembly:
movl 0xc(%r8), %eax
leal (%rax,%rax), %r9d
cmpl %ecx, %r9d
jbe 0xc3bb6
movl %ecx, %edx
xorl %esi, %esi
jmp 0x20e0
pushq %r14
pushq %rbx
movabsq $0xc, %rcx
xorl %r9d, %r9d
movl %eax, %r10d
cmpq %r10, %r9
jae 0xc3c2a
movq (%r8), %r10
movl (%r10,%rcx), %r10d
movq 0x20(%rsi), %rbx
cmpl $0x0, (%rbx,%r10,8)
movq (%rdx), %r11
js 0xc3c08
cmpq %r10, %r11
jbe 0xc3c21
movq 0x8(%rdx), %r11
movl (%r11,%r10,4), %r10d
cmpl $-0x2, %r10d
jg 0xc3c21
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
movb $0x0, (%rdi,%r10)
movl 0xc(%r8), %eax
jmp 0xc3c21
cmpq %r10, %r11
jbe 0xc3c21
movq 0x8(%rdx), %r14
movslq (%r14,%r10,4), %r10
testq %r10, %r10
js 0xc3c21
cmpl $0x0, (%rbx,%r10,8)
jns 0xc3be3
incq %r9
addq $0x28, %rcx
jmp 0xc3bc6
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: retrieve_skip_overlaps(ma_hit_t_alloc*, unsigned int)
uint32_t inline retrieve_skip_overlaps(ma_hit_t_alloc* x, uint32_t target)
{
    if(x == NULL) return (uint32_t)-1;

    uint32_t i;
    for (i = 0; i < x->length; i++)
    {
        if(Get_tn(x->buffer[i]) == target)
        {
            return i;
        }
    }

    return (uint32_t)-1;
}

// Assembly:
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0xc3c56
movl 0xc(%rdi), %edx
xorl %ecx, %ecx
cmpl %ecx, %edx
je 0xc3c56
movq (%rdi), %r8
movl %ecx, %r9d
imulq $0x28, %r9, %r9
cmpl %esi, 0xc(%r8,%r9)
je 0xc3c54
incl %ecx
jmp 0xc3c3b
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: check_duplicate(Hap_Align_warp*, unsigned int, unsigned int)
inline uint32_t check_duplicate(Hap_Align_warp* u_buffer, uint32_t x_pos, uint32_t y_pos)
{
    if(u_buffer->x.n == 0) return 0;

    int i = u_buffer->x.n;
    for (i--; i >= 0; i--)
    {
        if(x_pos != (uint32_t)-1 && u_buffer->x.a[i].q_pos != x_pos) return 0;
        if(y_pos != (uint32_t)-1 && u_buffer->x.a[i].t_pos == y_pos)
        {
            u_buffer->x.a[i].is_color++;
            return 1;
        } 
    }

    if(x_pos == (uint32_t)-1) fprintf(stderr, "ERROR: cannot found y\n");
    
    return 0;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0xc3cbf
movl %eax, %ecx
shlq $0x4, %rcx
testl %eax, %eax
jle 0xc3c94
cmpl $-0x1, %esi
je 0xc3c7c
movq 0x10(%rdi), %r8
cmpl %esi, -0x10(%r8,%rcx)
jne 0xc3cbf
cmpl $-0x1, %edx
je 0xc3c8c
movq 0x10(%rdi), %r8
cmpl %edx, -0xc(%r8,%rcx)
je 0xc3cb7
decl %eax
addq $-0x10, %rcx
jmp 0xc3c68
cmpl $-0x1, %esi
jne 0xc3cbf
movq 0x18f340(%rip), %rax    # 0x252fe0
movq (%rax), %rcx
leaq 0x1275e2(%rip), %rdi    # 0x1eb28c
pushq $0x16
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
jmp 0xc3cbf
incl -0x4(%r8,%rcx)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Overlaps.cpp
// Function: process_tangles(ma_ug_t*, unsigned long*, unsigned long, unsigned int, unsigned int, buf_t*, unsigned char*, unsigned int, long long, long long)
inline uint32_t process_tangles(ma_ug_t *ug, uint64_t* nodes, uint64_t nodes_n, uint32_t beg, uint32_t end,
buf_t* bb, uint8_t* visit, uint32_t trio_flag, long long totalNodeLen, long long totalBaseLen)
{
    uint32_t n_reduce = 1, v, w, kv, is_found = 0;
    asg_t* nsg = ug->g;

    while (n_reduce != 0)
    {
        while (n_reduce != 0)
        {
            n_reduce = 0;
            n_reduce += drop_tips_at_tangle(nsg, nodes, nodes_n, beg, end, bb);
            n_reduce += pop_bubble_at_tangle(ug, totalBaseLen, nodes, nodes_n, beg, end, trio_flag, DROP);
        }
        n_reduce = drop_useless_edges(ug, bb, visit, beg, end, nodes, nodes_n, totalNodeLen);
    }
    // if(pop_bubble_at_tangle(ug, 10000000, nodes, nodes_n, beg, end, trio_flag, DROP)!=0)
    // {
    //     fprintf(stderr, "false bubble popping: beg: %u, end: %u\n", beg>>1, end>>1);
    // }

    v = beg;
    is_found = 0;
    while (1)
    {
        if(v == end) is_found = 1;
        if(is_found == 1) break;

        kv = get_real_length(nsg, v, NULL);
        if(kv!=1) break;
        kv = get_real_length(nsg, v, &w);
        if(get_real_length(nsg, w^1, NULL)!=1) break;

        v = w;
        if(v == beg) break;
    }
    return is_found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rax
testl %eax, %eax
je 0xc3ecd
pushq $0x1
popq %rax
testl %eax, %eax
je 0xc3ea6
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
movq 0x10(%rsp), %r9
callq 0xaf258
movl %eax, %r15d
movq %r14, %rdi
movq 0x68(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %ebp, %r8d
movl %ebx, %r9d
pushq $0x5
movl 0x60(%rsp), %eax
pushq %rax
callq 0xaf3ec
popq %rcx
popq %rdx
addl %r15d, %eax
jmp 0xc3e5e
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq 0x50(%rsp), %rdx
movl %ebp, %ecx
movl %ebx, %r8d
movq %r13, %r9
movl 0x60(%rsp), %eax
pushq %rax
pushq %r12
callq 0xaf978
addq $0x10, %rsp
jmp 0xc3e57
leaq 0x4(%rsp), %r14
movl %ebp, %eax
movq 0x8(%rsp), %r12
movl %eax, %r15d
cmpl %ebx, %eax
je 0xc3f20
movq 0x8(%rsp), %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0xc2e7a
cmpl $0x1, %eax
jne 0xc3f20
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0xc2e7a
movl 0x4(%rsp), %esi
xorl $0x1, %esi
movq %r12, %rdi
xorl %edx, %edx
callq 0xc2e7a
cmpl $0x1, %eax
jne 0xc3f20
movl 0x4(%rsp), %eax
cmpl %ebp, %eax
jne 0xc3ed9
xorl %eax, %eax
cmpl %ebx, %r15d
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Trio.cpp
// Function: test_yak_binning(char*, char*)
uint32_t test_yak_binning(char* fn, char *cmd)
{
    gzFile fp; kstream_t *ks; kstring_t str = {0,0,0};
	int dret, eq = 0; fp = gzopen(fn, "r");
	if (fp == 0) return eq;
	ks = ks_init(fp);
	if(ks_getuntil(ks, KS_SEP_LINE, &str, &dret) >= 0) {
		uint64_t sl = strlen(str.s), z;
		for (z = 0; (z < sl) && (str.s[z]!='\t'); z++);
		if(((z+1)<sl) && (str.s[z]=='\t')) {
			if((strlen(str.s+z+1)==strlen(cmd)) && (!memcmp(str.s+z+1, cmd, strlen(cmd)))) {
				eq = 1;
			}
		}		
	}
	free(str.s);
	ks_destroy(ks);
	gzclose(fp);
	return eq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x12cb0d(%rip), %rsi    # 0x1f16b7
callq 0x22d0
testq %rax, %rax
je 0xc4bfc
movq %rax, %rbx
movq %rax, %rdi
callq 0xc4c78
movq %rax, %r14
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0xc4ca9
movq 0x10(%r12), %r12
testl %eax, %eax
js 0xc4c00
movq %r12, %rdi
callq 0x2090
xorl %r13d, %r13d
cmpq %r13, %rax
je 0xc4c04
cmpb $0x9, (%r12,%r13)
je 0xc4c07
incq %r13
jmp 0xc4beb
xorl %ebp, %ebp
jmp 0xc4c67
xorl %ebp, %ebp
jmp 0xc4c4f
movq %rax, %r13
leaq 0x1(%r13), %rcx
xorl %ebp, %ebp
cmpq %rax, %rcx
jae 0xc4c4f
cmpb $0x9, (%r12,%r13)
jne 0xc4c4f
addq %r12, %r13
incq %r13
movq %r13, %rdi
callq 0x2090
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x2090
movq (%rsp), %rdx
cmpq %rax, %rdx
jne 0xc4c4f
movq %r13, %rdi
movq %r15, %rsi
callq 0x21a0
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
movq %r12, %rdi
callq 0x2220
movq %r14, %rdi
callq 0xc4e80
movq %rbx, %rdi
callq 0x2390
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Trio.cpp
// Function: ha_triobin_set_list(cstr_ht_t const*, char const*, int)
static int ha_triobin_set_list(const cstr_ht_t *h, const char *fn, int flag)
{
	gzFile fp;
	kstream_t *ks;
	kstring_t str = {0,0,0};
	int dret;
	int64_t n_tot = 0, n_bin = 0;
	fp = gzopen(fn, "r");
	if (fp == 0) {
		fprintf(stderr, "ERROR: failed to open file '%s'\n", fn);
		return -1;
	}
	ks = ks_init(fp);
	while (ks_getuntil(ks, KS_SEP_LINE, &str, &dret) >= 0) {
		char *p;
		khint_t k;
		++n_tot;
		for (p = str.s; *p; ++p)
			if (*p == '\t' || *p == ' ')
				*p = 0;
		k = cstr_ht_get(h, str.s);
		if (k != kh_end(h)) {
			R_INF.trio_flag[kh_val(h, k)] = flag;
			++n_bin;
		}
	}
	free(str.s);
	ks_destroy(ks);
	gzclose(fp);
	fprintf(stderr, "[M::%s::%.3f*%.2f] flagged %ld reads, out of %ld lines in file '%s'\n",
			__func__, yak_realtime(), yak_cpu_usage(), (long)n_bin, (long)n_tot, fn);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x12bcf4(%rip), %rsi    # 0x1f16b7
movq %rbx, %rdi
callq 0x22d0
testq %rax, %rax
jne 0xc59f9
movq 0x18d609(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x125967(%rip), %rsi    # 0x1eb348
movq %rbx, %rdx
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
movq %rbx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq %rax, %rdi
callq 0xc4c78
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0x30(%rsp), %r12
leaq 0x2c(%rsp), %rbp
pushq $0x1
popq %r15
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xc4ca9
movq 0x40(%rsp), %rsi
testl %eax, %eax
js 0xc5aa6
movq %rsi, %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0xc5a55
cmpl $0x20, %ecx
je 0xc5a55
testl %ecx, %ecx
jne 0xc5a58
jmp 0xc5a5d
movb $0x0, (%rax)
incq %rax
jmp 0xc5a42
movq %r13, %rdi
callq 0xc5540
movq 0x10(%r13), %rdx
testq %rdx, %rdx
je 0xc5a79
movb (%r13), %cl
movl %r15d, %esi
shll %cl, %esi
jmp 0xc5a7b
xorl %esi, %esi
incq %r14
cmpl %esi, %eax
je 0xc5a28
leaq 0x18e7a7(%rip), %rcx    # 0x254230
movq 0x28(%rcx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq 0x8(%rdx,%rax), %rax
movl 0x8(%rsp), %edx
movb %dl, (%rcx,%rax)
incq 0x10(%rsp)
jmp 0xc5a28
movq %rsi, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0xc4e80
movq 0x18(%rsp), %rdi
callq 0x2390
movq 0x18d519(%rip), %rax    # 0x252fe0
movq (%rax), %rbx
callq 0xefea7
movsd %xmm0, 0x8(%rsp)
callq 0xefef4
movaps %xmm0, %xmm1
leaq 0x125918(%rip), %rsi    # 0x1eb3fc
leaq 0x125956(%rip), %rdx    # 0x1eb441
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rcx
movq %r14, %r8
movq 0x20(%rsp), %r9
movb $0x2, %al
callq 0x22b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/./htab.h
// Function: yak_hash64_64(unsigned long)
static inline uint64_t yak_hash64_64(uint64_t key)
{
	key = ~key + (key << 21);
	key = key ^ key >> 24;
	key = (key + (key << 3)) + (key << 8);
	key = key ^ key >> 14;
	key = (key + (key << 2)) + (key << 4);
	key = key ^ key >> 28;
	key = key + (key << 31);
	return key;
}

// Assembly:
movq %rdi, %rax
notq %rax
shlq $0x15, %rdi
addq %rax, %rdi
movq %rdi, %rax
shrq $0x18, %rax
xorq %rdi, %rax
imulq $0x109, %rax, %rax      # imm = 0x109
movq %rax, %rcx
shrq $0xe, %rcx
xorq %rax, %rcx
imulq $0x15, %rcx, %rax
movq %rax, %rcx
shrq $0x1c, %rcx
xorq %rax, %rcx
movl $0x80000001, %eax       # imm = 0x80000001
imulq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Trio.cpp
// Function: phrase_hstatus(char*, char**, unsigned int*)
inline void phrase_hstatus(char *s, char **rname, uint32_t *hid)
{
	char *p = NULL, *id = NULL; *rname = NULL; *hid = (uint32_t)-1;
	uint32_t tot; 
	for (p = s, tot = 0; *p; ++p){
		if (*p == '\t' || *p == ' '){
			*p = 0;
			if(!tot) *rname = p+1;
			else break;
			tot++;
		}
	}
	for (p = s, tot = 0; *p; ++p){
		if (*p == '_') id = p + 1;
	}
	*hid = atoi(id);
}

// Assembly:
pushq %rbx
andq $0x0, (%rsi)
movq %rdx, %rbx
orl $-0x1, (%rdx)
leaq 0x1(%rdi), %rax
xorl %edx, %edx
pushq $0x1
popq %rcx
movzbl -0x1(%rax), %r8d
cmpl $0x9, %r8d
je 0xc6786
cmpl $0x20, %r8d
je 0xc6786
testl %r8d, %r8d
jne 0xc6793
jmp 0xc6798
movb $0x0, -0x1(%rax)
testl %edx, %edx
jne 0xc6798
movq %rax, (%rsi)
movl %ecx, %edx
incq %rax
jmp 0xc676e
incq %rdi
xorl %eax, %eax
movzbl -0x1(%rdi), %ecx
cmpl $0x5f, %ecx
je 0xc67ac
testl %ecx, %ecx
jne 0xc67af
jmp 0xc67b4
movq %rdi, %rax
incq %rdi
jmp 0xc679d
movq %rax, %rdi
callq 0x2330
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/kthread.cpp
// Function: kt_for
void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n)
{
	if (n_threads > 1) {
		int i;
		kt_for_t t;
		pthread_t *tid;
		t.func = func, t.data = data, t.n_threads = n_threads, t.n = n;
		t.w = (ktf_worker_t*)calloc(n_threads, sizeof(ktf_worker_t));
		tid = (pthread_t*)calloc(n_threads, sizeof(pthread_t));
		for (i = 0; i < n_threads; ++i)
			t.w[i].t = &t, t.w[i].i = i;
		for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktf_worker, &t.w[i]);
		for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
		free(tid); free(t.w);
	} else {
		long j;
		for (j = 0; j < n; ++j) func(data, j, 0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
cmpl $0x1, %edi
jle 0xc6830
movq %rsp, %r12
movq %r15, 0x18(%r12)
movq %r14, 0x20(%r12)
movl %edi, (%r12)
movq %rbx, 0x8(%r12)
movl %edi, %ebx
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x2120
movq %rax, %r15
movq %rax, 0x10(%r12)
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x2120
movq %rax, %r14
addq $0x8, %r15
xorl %eax, %eax
cmpq %rax, %rbx
je 0xc684f
movq %r12, -0x8(%r15)
movq %rax, (%r15)
incq %rax
addq $0x10, %r15
jmp 0xc681b
xorl %r12d, %r12d
testq %rbx, %rbx
cmovleq %r12, %rbx
cmpq %r12, %rbx
je 0xc68b0
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *%r15
incq %r12
jmp 0xc683a
movq %rbx, %r13
shlq $0x4, %r13
xorl %ebp, %ebp
leaq 0x60(%rip), %r15        # 0xc68bf
movq %r14, %r12
cmpq %rbp, %r13
je 0xc6886
movq 0x10(%rsp), %rcx
addq %rbp, %rcx
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x23c0
addq $0x10, %rbp
addq $0x8, %r12
jmp 0xc6862
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0xc689e
movq (%r14,%r15,8), %rdi
xorl %esi, %esi
callq 0x2170
incq %r15
jmp 0xc6889
movq %r14, %rdi
callq 0x2220
movq 0x10(%rsp), %rdi
callq 0x2220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/kthread.cpp
// Function: ktf_worker(void*)
static void *ktf_worker(void *data)
{
	ktf_worker_t *w = (ktf_worker_t*)data;
	long i;
	for (;;) {
		i = __sync_fetch_and_add(&w->i, w->t->n_threads);
		if (i >= w->t->n) break;
		w->t->func(w->t->data, i, w - w->t->w);
	}
	while ((i = steal_work(w->t)) >= 0)
		w->t->func(w->t->data, i, w - w->t->w);
	pthread_exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rax
movslq (%rax), %rsi
lock
xaddq %rsi, 0x8(%rbx)
movq (%rbx), %rax
cmpq 0x8(%rax), %rsi
jge 0xc68f2
movq 0x20(%rax), %rdi
movq %rbx, %rdx
subq 0x10(%rax), %rdx
shrq $0x4, %rdx
callq *0x18(%rax)
jmp 0xc68c9
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
pushq $-0x1
popq %rbp
pushq $-0x1
popq %r15
movslq (%rax), %rsi
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
movq 0x10(%rax), %rcx
leaq 0x8(%rcx), %rdi
xorl %r9d, %r9d
movl %ebp, %r8d
movq %r14, %r10
cmpq %r9, %rdx
je 0xc693d
movq (%rdi), %r11
cmpq %r11, %r10
cmovgl %r9d, %r8d
cmovgeq %r11, %r10
incq %r9
addq $0x10, %rdi
jmp 0xc6921
movslq %r8d, %rdx
shlq $0x4, %rdx
lock
xaddq %rsi, 0x8(%rcx,%rdx)
cmpq 0x8(%rax), %rsi
cmovgeq %r15, %rsi
testq %rsi, %rsi
js 0xc6972
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq %rbx, %rdx
subq 0x10(%rax), %rdx
shrq $0x4, %rdx
callq *0x18(%rax)
movq (%rbx), %rax
jmp 0xc6903
xorl %edi, %edi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/kthread.cpp
// Function: kt_pipeline
void kt_pipeline(int n_threads, void *(*func)(void*, int, void*), void *shared_data, int n_steps)
{
	ktp_t aux;
	pthread_t *tid;
	int i;

	if (n_threads < 1) n_threads = 1;
	aux.n_workers = n_threads;
	aux.n_steps = n_steps;
	aux.func = func;
	aux.shared = shared_data;
	aux.index = 0;
	pthread_mutex_init(&aux.mutex, 0);
	pthread_cond_init(&aux.cv, 0);

	aux.workers = (ktp_worker_t*)calloc(n_threads, sizeof(ktp_worker_t));
	for (i = 0; i < n_threads; ++i) {
		ktp_worker_t *w = &aux.workers[i];
		w->step = 0; w->pl = &aux; w->data = 0;
		w->index = aux.index++;
	}

	tid = (pthread_t*)calloc(n_threads, sizeof(pthread_t));
	for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktp_worker, &aux.workers[i]);
	for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
	free(tid); free(aux.workers);

	pthread_mutex_destroy(&aux.mutex);
	pthread_cond_destroy(&aux.cv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0x2, %edi
pushq $0x1
popq %r15
cmovgel %edi, %r15d
leaq 0x30(%rsp), %rdi
movl %r15d, -0x10(%rdi)
movl %ecx, -0xc(%rdi)
movq %rsi, -0x20(%rdi)
movq %rdx, -0x28(%rdi)
andq $0x0, -0x18(%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x22e0
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2240
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, -0x30(%rbx)
movq -0x40(%rbx), %rcx
movq %r15, %r14
shlq $0x5, %r14
leaq 0x8(%rsp), %rdx
cmpq %r12, %r14
je 0xc6a09
andl $0x0, 0x10(%rax,%r12)
movq %rdx, (%rax,%r12)
andq $0x0, 0x18(%rax,%r12)
movq %rcx, 0x8(%rax,%r12)
incq %rcx
addq $0x20, %r12
jmp 0xc69e6
movq %rcx, 0x18(%rsp)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %r12
xorl %ebx, %ebx
leaq 0x76(%rip), %r13        # 0xc6a9b
movq %rax, %rbp
cmpq %rbx, %r14
je 0xc6a4c
movq 0x28(%rsp), %rcx
addq %rbx, %rcx
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x23c0
addq $0x20, %rbx
addq $0x8, %rbp
jmp 0xc6a28
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0xc6a63
movq (%r12,%rbx,8), %rdi
xorl %esi, %esi
callq 0x2170
incq %rbx
jmp 0xc6a4e
movq %r12, %rdi
callq 0x2220
movq 0x28(%rsp), %rdi
callq 0x2220
leaq 0x30(%rsp), %rdi
callq 0x21f0
leaq 0x58(%rsp), %rdi
callq 0x2400
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq