LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: minor_transitive_reduction_r_g(asg_t*, asg_arc_t*, unsigned int)
void minor_transitive_reduction_r_g(asg_t *r_g, asg_arc_t* rbub_edges, uint32_t num)
{
    uint32_t i, j, k, rId, nv, w;
    asg_arc_t* t = NULL;
    asg_arc_t* p = NULL;
    asg_arc_t *av = NULL;
    ///here all edges from v are saved in rbub_edges
    ///for edges already in graph, need to check del
    ///but for edges in rbub_edges, don't check del
    for (i = 0; i < num; i++)
    {
        t = &rbub_edges[i];
        rId = t->v;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1380d4
movl $0x110, %edx            # imm = 0x110
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20e0
testq %r12, %r12
je 0xf98fd
movq $0x0, (%r12)
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x138ab3
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfd133
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leal -0x1(%rdx), %esi
addl $-0x2, %edx
je 0xfd0e3
movl %esi, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movl %edx, %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
leaq (,%rbp,2), %rcx
addq %rbp, %rcx
movl 0x8(%rbx,%rcx,8), %eax
movq 0x28(%r14), %rdx
movq (%rdx,%rax,8), %rax
testl %eax, %eax
je 0xfd0b5
movl 0x20(%rbx,%rcx,8), %edx
movq 0x8(%r14), %rcx
movq %rax, %rdi
shrq $0x20, %rdi
movl %eax, %esi
leaq (%rdi,%rdi,2), %rdi
leaq (%rcx,%rdi,8), %rdi
addq $0xc, %rdi
xorl %ecx, %ecx
cmpl $0x0, (%rdi)
js 0xfd0a5
cmpl %edx, -0x4(%rdi)
je 0xfd0bc
incq %rcx
addq $0x18, %rdi
cmpq %rcx, %rsi
jne 0xfd09b
movl %eax, %ecx
jmp 0xfd0b7
xorl %ecx, %ecx
xorl %r15d, %r15d
jmp 0xfd0c0
movl -0xc(%rdi), %r15d
cmpl %eax, %ecx
je 0xfd0d1
incq %rbp
addq %r15, %r12
cmpq %r13, %rbp
jne 0xfd061
jmp 0xfd0d8
callq 0x11e54
jmp 0xfd0c4
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
jmp 0xfd0e8
xorl %eax, %eax
xorl %r12d, %r12d
cmpl %esi, %eax
jae 0xfd107
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%rbx,%rax,8), %eax
movq 0x20(%r14), %rcx
shrl %eax
movl (%rcx,%rax,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r12
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl 0xc(%rbx), %eax
andl %ecx, %eax
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
andl 0xc(%rbx,%rdx,8), %ecx
addl %eax, %ecx
xorl %eax, %eax
cmpq %rcx, %r12
setg %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_binned_reads(ma_hit_t_alloc*, unsigned long, ma_sub_t*)
void print_binned_reads(ma_hit_t_alloc* paf, uint64_t n_read, ma_sub_t* coverage_cut)
{
    uint64_t i, j, binned_flag;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0xfe9f3
movq 0x18b6f1(%rip), %r12    # 0x289fb8
leaq 0x12e497(%rip), %r13    # 0x22cd65
xorl %ebp, %ebp
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0xfe947
leaq (,%rbp,2), %rax
addq %rbp, %rax
cmpl $0x0, (%rdx,%rax,4)
js 0xfe9e0
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,4), %rbx
leaq 0x18c931(%rip), %rax    # 0x28b230
movq 0x28(%rax), %rax
movzbl (%rax,%rbp), %ecx
movq (%r12), %rdi
leaq 0x12e3db(%rip), %rsi    # 0x22cced
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 0x12e3cb(%rip), %rsi    # 0x22cd09
xorl %eax, %eax
callq 0x22b0
jmp 0xfe96a
leaq 0x18c8e2(%rip), %rax    # 0x28b230
movq 0x28(%rax), %rax
movzbl (%rax,%rbp), %ecx
movq (%r12), %rdi
leaq 0x12e38c(%rip), %rsi    # 0x22cced
movl %ebp, %edx
xorl %eax, %eax
callq 0x22b0
leaq (,%rbp,2), %rax
addq %rbp, %rax
movq (%rsp), %rcx
cmpl $0x0, 0xc(%rcx,%rax,8)
je 0xfe9e0
movq (%rsp), %rcx
leaq (%rcx,%rax,8), %r14
movl $0x18, %r15d
xorl %ebx, %ebx
movq (%r14), %rax
cmpq $0x0, (%rax,%r15)
js 0xfe9d0
movq (%r12), %rdi
movq -0x18(%rax,%r15), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movl -0x10(%rax,%r15), %r8d
movl -0xc(%rax,%r15), %r9d
movl -0x8(%rax,%r15), %r10d
movl -0x4(%rax,%r15), %r11d
movq %r13, %rsi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x22b0
addq $0x10, %rsp
incq %rbx
movl 0xc(%r14), %eax
addq $0x28, %r15
cmpq %rax, %rbx
jb 0xfe990
incq %rbp
cmpq 0x10(%rsp), %rbp
movq 0x8(%rsp), %rdx
jne 0xfe8d5
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: 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 0xfea0c
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 0xb0285
movq %rax, 0x8(%rsp)
subq $0x8, %rsp
xorl %r10d, %r10d
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %r13, %r9
pushq %r10
movl 0x68(%rsp), %eax
pushq %rax
movl 0x68(%rsp), %eax
pushq %rax
callq 0xd621b
addq $0x20, %rsp
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movss 0x16c(%rbx), %xmm0
movl 0x138(%rbx), %r10d
subq $0x8, %rsp
xorps %xmm1, %xmm1
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
xorl %r11d, %r11d
pushq %r11
pushq %r11
xorl %r11d, %r11d
pushq %rax
pushq $0x1
pushq %r11
movl 0x88(%rsp), %eax
pushq %rax
movl 0x88(%rsp), %eax
pushq %rax
pushq %r10
pushq $0x0
callq 0x12fee
addq $0x50, %rsp
leaq 0x10(%rsp), %rdi
callq 0xc8943
movq %rbx, %rdi
callq 0xa0004
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: get_primary_path_len(asg_t*, ma_ug_t*, unsigned int, buf_t*)
uint64_t get_primary_path_len(asg_t *sg, ma_ug_t *ug, uint32_t v0, buf_t *b)
{
    uint32_t v, u, k;
    uint64_t len;
    ma_utg_t *p = NULL; 

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

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

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

    return len;
}

// Assembly:
pushq %r14
pushq %rbx
movq (%rcx), %r8
movq 0x18(%rcx), %rax
movl (%rax), %eax
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
movl (%r8,%rcx), %r9d
cmpl %edx, %r9d
jne 0xff74b
xorl %eax, %eax
jmp 0xff7a7
movq 0x10(%rsi), %rcx
xorl %eax, %eax
movl %r9d, %esi
shrl %esi
leaq (%rsi,%rsi,4), %r10
movl 0x10(%rcx,%r10,8), %esi
testq %rsi, %rsi
je 0xff790
leaq (%rcx,%r10,8), %r11
movq 0x20(%rdi), %r10
movq 0x18(%r11), %r11
xorl %ebx, %ebx
movq (%r11,%rbx,8), %r14
shrq $0x21, %r14
movl (%r10,%r14,8), %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
addq %r14, %rax
incq %rbx
cmpq %rbx, %rsi
jne 0xff772
movl %r9d, %esi
leaq (%rsi,%rsi,8), %r9
leaq (%r9,%r9,2), %r9
addq %rsi, %r9
movl (%r8,%r9), %r9d
cmpl %edx, %r9d
jne 0xff751
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18a929(%rip), %rax    # 0x28a758
movq 0x280(%rax), %rcx
testq %rcx, %rcx
jns 0xff7ab
movslq 0x144(%rax), %rcx
cvtsi2sd %ecx, %xmm0
divsd 0x129d16(%rip), %xmm0   # 0x229b68
movsd 0x12540e(%rip), %xmm1   # 0x225268
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 0x1253b3(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1253bb(%rip), %xmm0   # 0x225250
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0x129d07(%rip), %xmm2   # 0x229bb0
xorps %xmm0, %xmm0
cvtsi2sdl 0x1bc(%rax), %xmm0
divsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %r8
sarq $0x3f, %r8
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %rcx
andq %r8, %rcx
orq %rax, %rcx
jmp 0xff7ab
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_outfile_name(char*)
char *get_outfile_name(char* output_file_name)
{
    char *buf = NULL;
    CALLOC(buf, strlen(output_file_name) + 25);
    if(ha_opt_triobin(&asm_opt) && ha_opt_hic(&asm_opt))
    {
        sprintf(buf, "%s.hic.bench", output_file_name);
    }
    else if(ha_opt_triobin(&asm_opt))
    {
        sprintf(buf, "%s.dip", output_file_name);
    }
    else if(ha_opt_hic(&asm_opt))
    {
        sprintf(buf, "%s.hic", output_file_name);
    }
    else if(asm_opt.flag & HA_F_PARTITION)
    {
        sprintf(buf, "%s.bp", output_file_name);
    }
    else
    {
        sprintf(buf, "%s", output_file_name);
    }

    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2090
leaq 0x19(%rax), %rdi
movl $0x1, %esi
callq 0x2120
leaq 0x18a85f(%rip), %rcx    # 0x28a758
cmpq $0x0, 0x20(%rcx)
sete %dl
cmpq $0x0, 0x28(%rcx)
movq %rax, %rbx
sete %al
orb %dl, %al
cmpb $0x1, %al
jne 0xfff20
cmpq $0x0, 0x30(%rcx)
je 0xfff37
cmpq $0x0, 0x38(%rcx)
je 0xfff37
cmpq $0x0, 0x50(%rcx)
je 0xfff37
cmpq $0x0, 0x58(%rcx)
je 0xfff37
leaq 0x12cecc(%rip), %rsi    # 0x22ce01
jmp 0xfff50
testb %al, %al
je 0xfff49
cmpq $0x0, 0x30(%rcx)
je 0xfff68
cmpq $0x0, 0x38(%rcx)
je 0xfff68
leaq 0x12cebe(%rip), %rsi    # 0x22ce0e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x0, 0x50(%rcx)
je 0xfff7f
cmpq $0x0, 0x58(%rcx)
je 0xfff7f
leaq 0x12ce98(%rip), %rsi    # 0x22ce15
jmp 0xfff50
testb $0x8, 0x1(%rcx)
jne 0xfff97
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
leaq 0x12ce7e(%rip), %rsi    # 0x22ce1c
jmp 0xfff50
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: gen_ug_opt_t(ug_opt_t*, 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 gen_ug_opt_t(ug_opt_t *opt, 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)
{
    memset(opt, 0, sizeof((*opt)));
    opt->sources = sources; opt->reverse_sources = reverse_sources; opt->max_hang = max_hang;
    opt->min_ovlp = min_ovlp; opt->gap_fuzz = gap_fuzz; opt->min_dp = min_dp; opt->readLen = readLen;
    opt->coverage_cut = coverage_cut; opt->ruIndex = ruIndex; opt->tipsLen = tipsLen; 
    opt->tip_drop_ratio = tip_drop_ratio; opt->stops_threshold = stops_threshold; 
    opt->chimeric_rate = chimeric_rate; opt->drop_ratio = drop_ratio; opt->b_mask_t = b_mask_t; opt->te = te;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %r10
movq 0x58(%rsp), %r11
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r14
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %r13
xorps %xmm3, %xmm3
movups %xmm3, (%rdi)
movups %xmm3, 0x10(%rdi)
movups %xmm3, 0x40(%rdi)
movups %xmm3, 0x50(%rdi)
movups %xmm3, 0x60(%rdi)
movups %xmm3, 0x30(%rdi)
movups %xmm3, 0x20(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x40(%rdi)
movl %r8d, 0x44(%rdi)
movq %r9, 0x50(%rdi)
movq %r13, 0x58(%rdi)
movq %r12, 0x68(%rdi)
movq %r15, (%rdi)
movq %r14, 0x30(%rdi)
movq %rbx, 0x18(%rdi)
movss %xmm0, 0x20(%rdi)
movq %r11, 0x28(%rdi)
movss %xmm1, 0x38(%rdi)
movss %xmm2, 0x3c(%rdi)
movq %r10, 0x60(%rdi)
movq %rax, 0x70(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsp, %rax
movaps %xmm3, (%rax)
movaps %xmm3, 0x10(%rax)
movaps %xmm3, 0x40(%rax)
movaps %xmm3, 0x50(%rax)
movaps %xmm3, 0x60(%rax)
movaps %xmm3, 0x30(%rax)
movaps %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 0x27fdb
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: rescue_src_ul(ma_hit_t_alloc*, unsigned long, unsigned long)
void rescue_src_ul(ma_hit_t_alloc* src, uint64_t n_read, uint64_t occ)
{
    uint64_t k, i;
    for (k = 0; k < n_read; k++) {
        for (i = 0; i < src[k].length; i++) {
            if(!src[k].buffer[i].del) continue;
            if(src[k].buffer[i].bl>=occ) src[k].buffer[i].del = 0;
        }
    }
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
testq %rsi, %rsi
jns 0x1001de
movq %rdx, %r12
leaq 0x18b0a9(%rip), %rax    # 0x28b230
movq 0x50(%rax), %r14
movq 0x8(%rax), %rbp
movq 0x40(%rax), %rbx
movq %r14, %r13
negq %r13
movq $-0x1, %r15
leaq (%r15,%r13), %rax
cmpq $-0x1, %rax
je 0x1001cf
movq 0x8(%rbx,%r15,8), %rax
movq 0x10(%rbx,%r15,8), %rdx
leaq (%rax,%rbp), %rsi
subq %rax, %rdx
movq %r12, %rdi
callq 0x21a0
incq %r15
testl %eax, %eax
jne 0x1001a0
cmpq %r14, %r15
jb 0x1001de
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0x11e8c
jmp 0x1001cf
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %eax, %eax
je 0x10109c
movq 0x8(%rdi), %rcx
movq %rax, %rsi
shrq $0x20, %rsi
movl %eax, %eax
leaq (%rsi,%rsi,2), %rsi
leaq (%rcx,%rsi,8), %rcx
addq $0xc, %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
xorl %edi, %edi
xorl %eax, %eax
cmpl $0x0, (%rcx,%rdi)
js 0x101092
testq %rdx, %rdx
je 0x101090
movl -0x4(%rcx,%rdi), %r8d
movl %eax, %r9d
movl %r8d, (%rdx,%r9,4)
incl %eax
addq $0x18, %rdi
cmpq %rdi, %rsi
jne 0x101079
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x20(%rsp)
leaq 0x1304ee(%rip), %rsi    # 0x2335a7
callq 0x22d0
testq %rax, %rax
je 0x103175
movq %rax, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x2120
movq %rax, %r14
movq %rbx, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x2280
movq %rax, (%r14)
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x1031b1
testl %eax, %eax
js 0x10317a
movq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x2090
xorl %r12d, %r12d
xorl %ecx, %ecx
testq %rax, %rax
je 0x10312d
cmpb $0x9, (%r13,%rcx)
je 0x10312d
incq %rcx
cmpq %rcx, %rax
jne 0x10311a
movq %rax, %rcx
leaq 0x1(%rcx), %rdx
cmpq %rax, %rdx
jae 0x10317d
cmpb $0x9, (%r13,%rcx)
jne 0x10317d
addq %rcx, %r13
incq %r13
movq %r13, %rdi
callq 0x2090
movq %rax, %rbp
movq %r15, %rdi
callq 0x2090
cmpq %rax, %rbp
jne 0x10317d
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x21a0
xorl %r12d, %r12d
testl %eax, %eax
sete %r12b
jmp 0x10317d
xorl %r12d, %r12d
jmp 0x10319f
xorl %r12d, %r12d
movq 0x20(%rsp), %rdi
callq 0x2220
movq (%r14), %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2390
movl %r12d, %eax
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/Trio.cpp
// Function: ha_triobin(hifiasm_opt_t const*)
void ha_triobin(const hifiasm_opt_t *opt)
{
	memset(R_INF.trio_flag, AMBIGU, R_INF.total_reads * sizeof(uint8_t));
	if (opt->fn_bin_list[0] && opt->fn_bin_list[1])
		ha_triobin_list(opt);
	if (opt->fn_bin_yak[0] && opt->fn_bin_yak[1])
		ha_triobin_yak(opt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1879b8(%rip), %r14    # 0x28b230
movq 0x28(%r14), %rdi
movq 0x50(%r14), %rdx
xorl %esi, %esi
callq 0x20e0
cmpq $0x0, 0x30(%rbx)
je 0x103895
cmpq $0x0, 0x38(%rbx)
jne 0x1038ad
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x1038a5
cmpq $0x0, 0x28(%rbx)
jne 0x1038ca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x50(%r14), %rdi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rdi
jae 0x1038d8
leaq 0x30(%rbx), %rsi
leaq 0x38(%rbx), %rdx
callq 0x12370
jmp 0x103895
leaq 0x28(%rbx), %rdx
movq %rbx, %rdi
callq 0x124fd
jmp 0x1038a5
leaq 0x1298d4(%rip), %rdi    # 0x22d1b3
leaq 0x1298ee(%rip), %rsi    # 0x22d1d4
leaq 0x1299e3(%rip), %rcx    # 0x22d2d0
movl $0x14d, %edx            # imm = 0x14D
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %edx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x12fc81(%rip), %rsi    # 0x2335a7
movq %rbx, %rdi
callq 0x22d0
testq %rax, %rax
jne 0x10395c
movq 0x1866a6(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x129914(%rip), %rsi    # 0x22d258
movq %rbx, %rdx
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
movq %rax, %r14
movq %rbx, 0x30(%rsp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x2120
movq %rax, %r12
movq %r14, 0x28(%rsp)
movq %r14, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x2280
movq %rax, (%r12)
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
callq 0x1031b1
testl %eax, %eax
js 0x103a32
xorl %r13d, %r13d
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rbp
xorl %ebx, %ebx
movq 0x20(%rsp), %rsi
movq %rsi, %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0x1039d1
cmpl $0x20, %ecx
je 0x1039d1
testl %ecx, %ecx
jne 0x1039d4
jmp 0x1039d9
movb $0x0, (%rax)
incq %rax
jmp 0x1039be
movq %r15, %rdi
callq 0x1037b2
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x1039f6
movb (%r15), %cl
movl $0x1, %esi
shll %cl, %esi
jmp 0x1039f8
xorl %esi, %esi
cmpl %esi, %eax
je 0x103a1b
leaq 0x18782d(%rip), %rcx    # 0x28b230
movq 0x28(%rcx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movq 0x8(%rdx,%rax), %rax
movl (%rsp), %edx
movb %dl, (%rcx,%rax)
incq %r13
incq %rbx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x1031b1
testl %eax, %eax
jns 0x1039b6
jmp 0x103a37
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x20(%rsp), %rdi
callq 0x2220
movq (%r12), %rdi
callq 0x2220
movq %r12, %rdi
callq 0x2220
movq 0x28(%rsp), %rdi
callq 0x2390
movq 0x18657d(%rip), %rax    # 0x289fe0
movq (%rax), %r14
callq 0x1303c7
movsd %xmm0, (%rsp)
callq 0x130490
movaps %xmm0, %xmm1
leaq 0x12988d(%rip), %rsi    # 0x22d30c
leaq 0x1298cb(%rip), %rdx    # 0x22d351
movq %r14, %rdi
movsd (%rsp), %xmm0
movq %r13, %rcx
movq %rbx, %r8
movq 0x30(%rsp), %r9
movb $0x2, %al
callq 0x22b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdx, %r15
movq %rsi, %r12
cmpl $0x1, %edi
jle 0x104893
movl %edi, %ebx
movq %rsp, %r13
movq %r12, 0x18(%r13)
movq %r15, 0x20(%r13)
movl %edi, (%r13)
movq %r14, 0x8(%r13)
movl %edi, %r15d
movl $0x10, %esi
movq %r15, %rdi
callq 0x2120
movq %rax, %r12
movq %rax, 0x10(%r13)
movl $0x8, %esi
movq %r15, %rdi
callq 0x2120
movq %rax, %r14
addq $0x8, %r12
xorl %eax, %eax
movq %r13, -0x8(%r12)
movq %rax, (%r12)
incq %rax
addq $0x10, %r12
cmpq %rax, %r15
jne 0x104816
shlq $0x4, %r15
xorl %ebp, %ebp
leaq 0x84(%rip), %r12        # 0x1048bc
movq %r14, %r13
movq 0x10(%rsp), %rcx
addq %rbp, %rcx
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x23c0
addq $0x10, %rbp
addq $0x8, %r13
cmpq %rbp, %r15
jne 0x10483b
cmpl $0x2, %ebx
movl $0x1, %r15d
cmovgel %ebx, %r15d
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
xorl %esi, %esi
callq 0x2170
incq %rbx
cmpq %rbx, %r15
jne 0x10486c
movq %r14, %rdi
callq 0x2220
movq 0x10(%rsp), %rdi
callq 0x2220
jmp 0x1048ad
testq %r14, %r14
jle 0x1048ad
xorl %ebx, %ebx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *%r12
incq %rbx
cmpq %rbx, %r14
jne 0x10489a
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/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movslq (%rax), %rsi
lock
xaddq %rsi, 0x8(%rdi)
movq (%rdi), %rax
cmpq 0x8(%rax), %rsi
jge 0x10490d
movq 0x20(%rax), %rdi
movq %rbx, %rdx
subq 0x10(%rax), %rdx
shrq $0x4, %rdx
callq *0x18(%rax)
movq (%rbx), %rax
movslq (%rax), %rsi
lock
xaddq %rsi, 0x8(%rbx)
movq (%rbx), %rax
jmp 0x1048cf
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq %rbx, %rdx
subq 0x10(%rax), %rdx
shrq $0x4, %rdx
callq *0x18(%rax)
movq (%rbx), %rcx
movslq (%rcx), %rax
movq $-0x1, %rsi
movq $-0x1, %rdx
testq %rax, %rax
jle 0x10495d
movq 0x10(%rcx), %rdx
addq $0x8, %rdx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
xorl %r9d, %r9d
movq (%rdx), %r10
cmpq %r10, %r8
cmovgl %r9d, %edi
cmovgeq %r10, %r8
incq %r9
addq $0x10, %rdx
cmpq %r9, %rax
jne 0x104940
movslq %edi, %rdx
movq 0x10(%rcx), %rdi
shlq $0x4, %rdx
lock
xaddq %rax, 0x8(%rdi,%rdx)
cmpq 0x8(%rcx), %rax
cmovlq %rax, %rsi
testq %rsi, %rsi
jns 0x1048f8
xorl %edi, %edi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %r15d
cmovgel %edi, %r15d
leaq 0x30(%rsp), %rdi
movl %r15d, -0x10(%rdi)
movl %ecx, -0xc(%rdi)
movq %rsi, -0x20(%rdi)
movq %rdx, -0x28(%rdi)
movq $0x0, -0x18(%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x22e0
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2240
movl $0x20, %esi
movq %r15, %rdi
callq 0x2120
movq %rax, -0x30(%rbx)
movq -0x40(%rbx), %rcx
movq %r15, %r14
shlq $0x5, %r14
leaq 0x8(%rsp), %rdx
movl $0x0, 0x10(%rax,%r12)
movq %rdx, (%rax,%r12)
movq $0x0, 0x18(%rax,%r12)
movq %rcx, 0x8(%rax,%r12)
incq %rcx
addq $0x20, %r12
cmpq %r12, %r14
jne 0x1049f8
movq %rcx, 0x18(%rsp)
movl $0x8, %esi
movq %r15, %rdi
callq 0x2120
movq %rax, %r12
xorl %ebx, %ebx
leaq 0x72(%rip), %r13        # 0x104aaf
movq %rax, %rbp
movq 0x28(%rsp), %rcx
addq %rbx, %rcx
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x23c0
addq $0x20, %rbx
addq $0x8, %rbp
cmpq %rbx, %r14
jne 0x104a40
xorl %ebx, %ebx
movq (%r12,%rbx,8), %rdi
xorl %esi, %esi
callq 0x2170
incq %rbx
cmpq %rbx, %r15
jne 0x104a64
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
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/kthread.cpp
// Function: ktp_worker(void*)
static void *ktp_worker(void *data)
{
	ktp_worker_t *w = (ktp_worker_t*)data;
	ktp_t *p = w->pl;
	while (w->step < p->n_steps) {
		// test whether we can kick off the job with this worker
		pthread_mutex_lock(&p->mutex);
		for (;;) {
			int i;
			// test whether another worker is doing the same step
			for (i = 0; i < p->n_workers; ++i) {
				if (w == &p->workers[i]) continue; // ignore itself
				if (p->workers[i].step <= w->step && p->workers[i].index < w->index)
					break;
			}
			if (i == p->n_workers) break; // no workers with smaller indices are doing w->step or the previous steps
			pthread_cond_wait(&p->cv, &p->mutex);
		}
		pthread_mutex_unlock(&p->mutex);

		// working on w->step
		w->data = p->func(p->shared, w->step, w->step? w->data : 0); // for the first step, input is NULL

		// update step and let other workers know
		pthread_mutex_lock(&p->mutex);
		w->step = w->step == p->n_steps - 1 || w->data? (w->step + 1) % p->n_steps : p->n_steps;
		if (w->step == 0) w->index = p->index++;
		pthread_cond_broadcast(&p->cv);
		pthread_mutex_unlock(&p->mutex);
	}
	pthread_exit(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movl 0x10(%rdi), %eax
cmpl 0x1c(%r12), %eax
jge 0x104ba9
movq %rdi, %rbx
leaq 0x28(%r12), %r14
leaq 0x50(%r12), %r15
movq %r14, %rdi
callq 0x22c0
movl 0x18(%r12), %eax
testl %eax, %eax
jle 0x104b14
movq 0x20(%r12), %rdx
xorl %ecx, %ecx
cmpq %rbx, %rdx
je 0x104b04
movl 0x10(%rdx), %esi
cmpl 0x10(%rbx), %esi
jg 0x104b04
movq 0x8(%rdx), %rsi
cmpq 0x8(%rbx), %rsi
jl 0x104b16
incq %rcx
addq $0x20, %rdx
cmpq %rcx, %rax
jne 0x104aed
movl %eax, %ecx
jmp 0x104b16
xorl %ecx, %ecx
cmpl %eax, %ecx
je 0x104b27
movq %r15, %rdi
movq %r14, %rsi
callq 0x2300
jmp 0x104add
movq %r14, %rdi
callq 0x2130
movq (%r12), %rdi
movq 0x8(%r12), %rax
movl 0x10(%rbx), %esi
testl %esi, %esi
je 0x104b45
movq 0x18(%rbx), %rdx
jmp 0x104b47
xorl %edx, %edx
callq *%rax
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x22c0
movl 0x10(%rbx), %eax
movl 0x1c(%r12), %ecx
leal -0x1(%rcx), %edx
cmpl %edx, %eax
je 0x104b6b
cmpq $0x0, 0x18(%rbx)
je 0x104b72
incl %eax
cltd
idivl %ecx
movl %edx, %ecx
movl %ecx, 0x10(%rbx)
testl %ecx, %ecx
jne 0x104b8b
movq 0x10(%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%r12)
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x2070
movq %r14, %rdi
callq 0x2130
movl 0x10(%rbx), %eax
cmpl 0x1c(%r12), %eax
jl 0x104ad5
xorl %edi, %edi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: init_hap_alignment_struct(hap_alignment_struct*, unsigned int)
void init_hap_alignment_struct(hap_alignment_struct* x, uint32_t size)
{
    x->vote_counting = (uint64_t*)malloc(sizeof(uint64_t)*size);
    memset(x->vote_counting, 0, sizeof(uint64_t)*size);

    x->visit = (uint8_t*)malloc(sizeof(uint8_t)*size);
    memset(x->visit, 0, size);

    kv_init(x->u_vecs.a);
    kv_init(x->u_buffer.a);
    kv_init(x->u_buffer_tailIndex.a);
    kv_init(x->u_buffer_prevIndex.a);
    kv_init(x->u_buffer_beg.a);
    kv_init(x->u_buffer_flag.a);
    kv_init(x->u_can.a);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
leaq (,%r14,8), %r15
movq %r15, %rdi
callq 0x2280
movq %rax, (%rbx)
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20e0
movq %r14, %rdi
callq 0x2280
movq %rax, 0x8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20e0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %r12, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movq %r12, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movq %r12, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq %r12, 0x80(%rbx)
movups %xmm0, 0x90(%rbx)
movq %r12, 0xa0(%rbx)
movups %xmm0, 0xb0(%rbx)
movq %r12, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movq %r12, 0xe0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: destory_hap_alignment_struct(hap_alignment_struct*)
void destory_hap_alignment_struct(hap_alignment_struct* x)
{
    free(x->vote_counting);
    free(x->visit);
    kv_destroy(x->u_vecs.a);
    kv_destroy(x->u_buffer.a);
    kv_destroy(x->u_buffer_tailIndex.a);
    kv_destroy(x->u_buffer_prevIndex.a);
    kv_destroy(x->u_buffer_beg.a);
    kv_destroy(x->u_buffer_flag.a);
    kv_destroy(x->u_can.a);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x20(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x60(%rbx), %rdi
callq 0x2220
movq 0x80(%rbx), %rdi
callq 0x2220
movq 0xc0(%rbx), %rdi
callq 0x2220
movq 0xa0(%rbx), %rdi
callq 0x2220
movq 0xe0(%rbx), %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: init_pip_hh(asg_t*, ma_hit_t_alloc*, ma_sub_t*, long long)
uint8_t *init_pip_hh(asg_t *rg, ma_hit_t_alloc* reverse_sources, ma_sub_t *coverage_cut, long long sc)
{
    uint8_t *c = NULL; CALLOC(c, rg->n_seq);
    ma_hit_t *h = NULL;
    uint32_t i, k;
    long long R_Base, C_Base;
    for (i = 0; i < rg->n_seq; i++) {
        if(sc <= 0){
            c[i] = 1;
            continue;
        }
        R_Base = (coverage_cut[i].e - coverage_cut[i].s);
        for (k = 0, C_Base = 0; k < reverse_sources[i].length; k++){
            h = &(reverse_sources[i].buffer[k]);
            C_Base += (Get_qe((*h)) - Get_qs((*h)));
        }
        C_Base = (R_Base!=0?(C_Base/R_Base):0);
        C_Base /= sc;
        c[i] = 1;
        if(C_Base < REV_W) c[i] = REV_W -  C_Base;
    }
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl 0x14(%rdi), %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl $0x1, %esi
movq %r12, %rdi
callq 0x2120
movq %rax, %rcx
testq %r12, %r12
je 0x105aaa
movl %r12d, %esi
xorl %edi, %edi
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
testq %rbx, %rbx
jle 0x105a63
leaq (%rdi,%rdi,2), %rdx
movl 0xc(%r15,%rdx,8), %eax
testq %rax, %rax
je 0x105a69
leaq (%r15,%rdx,8), %r9
movq (%r9), %r9
shlq $0x3, %rax
leaq (%rax,%rax,4), %r10
xorl %r11d, %r11d
xorl %eax, %eax
movl 0x8(%r9,%r11), %r12d
subl (%r9,%r11), %r12d
addq %r12, %rax
addq $0x28, %r11
cmpq %r11, %r10
jne 0x105a4c
jmp 0x105a6b
movb $0x1, (%rcx,%rdi)
jmp 0x105a9e
xorl %eax, %eax
movl 0x4(%r14,%rdx,4), %r9d
movl (%r14,%rdx,4), %edx
andl %r8d, %edx
cmpl %edx, %r9d
jne 0x105a80
xorl %eax, %eax
jmp 0x105a88
subl %edx, %r9d
xorl %edx, %edx
divq %r9
cqto
idivq %rbx
movb $0x1, (%rcx,%rdi)
cmpq $0x7, %rax
jg 0x105a9e
movb $0x8, %dl
subb %al, %dl
movb %dl, (%rcx,%rdi)
incq %rdi
cmpq %rsi, %rdi
jne 0x105a25
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: destory_hap_alignment_struct_pip(hap_alignment_struct_pip*)
void destory_hap_alignment_struct_pip(hap_alignment_struct_pip* x)
{
    uint32_t i;
    for (i = 0; i < x->num_threads; i++)
    {
        destory_hap_alignment_struct(&(x->buf[i]));
    }

    free(x->buf);
    free(x->hh);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x105c41
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x105984
incq %r15
movl 0x8(%rbx), %eax
addq $0xf0, %r14
cmpq %rax, %r15
jb 0x105c24
movq (%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: init_hap_overlaps_list(hap_overlaps_list*, unsigned int)
void init_hap_overlaps_list(hap_overlaps_list* x, uint32_t num)
{
    uint32_t i = 0;
    x->num = num;
    x->x = (kvec_hap_overlaps*)malloc(sizeof(kvec_hap_overlaps)*x->num);
    for (i = 0; i < x->num; i++)
    {
        kv_init(x->x[i].a);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movl %esi, %r15d
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x2280
movq %rax, (%r14)
testl %ebx, %ebx
je 0x105c96
shlq $0x3, %r15
leaq (%r15,%r15,2), %rdx
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x20e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: destory_hap_overlaps_list(hap_overlaps_list*)
void destory_hap_overlaps_list(hap_overlaps_list* x)
{
    uint32_t i = 0;
    for (i = 0; i < x->num; i++)
    {
        kv_destroy(x->x[i].a);
    }
    free(x->x);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x105cd6
movl $0x10, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2220
incq %r15
movl 0x8(%rbx), %eax
addq $0x18, %r14
cmpq %rax, %r15
jb 0x105cbb
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: deduplicate_edge(kvec_asg_arc_t_offset*)
void deduplicate_edge(kvec_asg_arc_t_offset* u_buffer)
{
    if(u_buffer->a.n == 0) return;
    long long i = u_buffer->a.n - 1, k, i_off;
    uint32_t v = u_buffer->a.a[i].x.ul>>33, m;

    for (; i >= 0; i--) {
        if((u_buffer->a.a[i].x.ul>>33) != v) break;
    }

    i = i + 1;
    for (m = i; i < (long long)u_buffer->a.n; i++)
    {
        if(u_buffer->a.a[i].x.del) continue;

        i_off = Cal_Off(u_buffer->a.a[i].Off);

        for (k = i + 1; k < (long long)u_buffer->a.n; k++)
        {
            if(u_buffer->a.a[k].x.del) continue;
            if(u_buffer->a.a[i].x.el != u_buffer->a.a[k].x.el) continue;
            if(i_off != Cal_Off(u_buffer->a.a[k].Off)) continue;
            u_buffer->a.a[k].x.del = 1;
            u_buffer->a.a[i].weight += u_buffer->a.a[k].weight;
        }
        u_buffer->a.a[m] = u_buffer->a.a[i];
        m++;
    }

    u_buffer->a.n = m;
    ///fprintf(stderr, "u_buffer->a.n: %u, i: %lld\n", u_buffer->a.n, i);
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x105e62
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq %rax, %rcx
decq %rcx
js 0x105d7e
movq 0x10(%rdi), %rdx
leaq (%rcx,%rcx,4), %rcx
movq (%rdx,%rcx,8), %rcx
leaq (%rax,%rax,4), %rsi
leaq (%rdx,%rsi,8), %rdx
addq $-0x28, %rdx
movq (%rdx), %rsi
xorq %rcx, %rsi
decq %rax
shrq $0x21, %rsi
jne 0x105d7b
addq $-0x28, %rdx
testq %rax, %rax
jg 0x105d5c
movq $-0x1, %rax
incq %rax
cmpq (%rdi), %rax
jge 0x105e57
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,4), %rcx
movq %rax, %rdx
movq 0x10(%rdi), %r9
leaq (%rdx,%rdx,4), %rsi
cmpl $0x0, 0xc(%r9,%rsi,8)
js 0x105e47
leaq 0x1(%rdx), %r8
cmpq (%rdi), %r8
jge 0x105e1a
leaq (%r9,%rsi,8), %r9
movq 0x18(%r9), %r9
movl %r9d, %r10d
shrq $0x20, %r9
subq %r10, %r9
movq %rcx, %r10
movq 0x10(%rdi), %r11
movl 0x34(%r11,%r10), %ebx
testl %ebx, %ebx
js 0x105e0e
movb 0x12(%r11,%rsi,8), %bpl
cmpb 0x3a(%r11,%r10), %bpl
jne 0x105e0e
movq 0x40(%r11,%r10), %r14
movl %r14d, %r15d
shrq $0x20, %r14
subq %r15, %r14
cmpq %r14, %r9
jne 0x105e0e
orl $0x80000000, %ebx       # imm = 0x80000000
movl %ebx, 0x34(%r11,%r10)
movq 0x10(%rdi), %r11
movq 0x48(%r11,%r10), %rbx
addq %rbx, 0x20(%r11,%rsi,8)
incq %r8
addq $0x28, %r10
cmpq (%rdi), %r8
jl 0x105dc8
movq 0x10(%rdi), %r8
movl %eax, %r9d
leaq (%r9,%r9,4), %r9
movq 0x20(%r8,%rsi,8), %r10
movq %r10, 0x20(%r8,%r9,8)
movups (%r8,%rsi,8), %xmm0
movups 0x10(%r8,%rsi,8), %xmm1
movups %xmm1, 0x10(%r8,%r9,8)
movups %xmm0, (%r8,%r9,8)
incl %eax
incq %rdx
addq $0x28, %rcx
cmpq (%rdi), %rdx
jl 0x105d96
movl %eax, %eax
movq %rax, (%rdi)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: cmp_hap_alignment(void const*, void const*)
int cmp_hap_alignment(const void * a, const void * b)
{
    if((*(asg_arc_t_offset*)a).x.el > (*(asg_arc_t_offset*)b).x.el) return 1;
    if((*(asg_arc_t_offset*)a).x.el < (*(asg_arc_t_offset*)b).x.el) return -1;

    long long aOff = Cal_Off((*(asg_arc_t_offset*)a).Off);
    long long bOff = Cal_Off((*(asg_arc_t_offset*)b).Off);

    if(aOff > bOff) return 1;
    if(aOff < bOff) return -1;

    if(((*(asg_arc_t_offset*)a).Off>>32) > ((*(asg_arc_t_offset*)b).Off>>32)) return 1;
    if(((*(asg_arc_t_offset*)a).Off>>32) < ((*(asg_arc_t_offset*)b).Off>>32)) return -1;

    if((uint32_t)((*(asg_arc_t_offset*)a).Off) > (uint32_t)((*(asg_arc_t_offset*)b).Off)) return 1;
    if((uint32_t)((*(asg_arc_t_offset*)a).Off) < (uint32_t)((*(asg_arc_t_offset*)b).Off)) return -1;

    if((*(asg_arc_t_offset*)a).weight < (*(asg_arc_t_offset*)b).weight) return 1;
    if((*(asg_arc_t_offset*)a).weight > (*(asg_arc_t_offset*)b).weight) return -1;

    return 0;
}

// Assembly:
movb 0x12(%rsi), %al
cmpb %al, 0x12(%rdi)
jbe 0x105e71
movl $0x1, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jae 0x105e79
retq
pushq %rbx
movq 0x18(%rdi), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movl %ecx, %r8d
movq %rdx, %r10
subq %r8, %r10
movq 0x18(%rsi), %r8
movq %r8, %r9
shrq $0x20, %r9
movl %r8d, %r11d
movq %r9, %rbx
subq %r11, %rbx
cmpq %rbx, %r10
popq %rbx
jg 0x105e6b
jl 0x105e78
cmpl %r9d, %edx
ja 0x105e6b
cmpl %r9d, %edx
jb 0x105e78
cmpl %r8d, %ecx
ja 0x105e6b
jb 0x105e78
movq 0x20(%rdi), %rcx
movq 0x20(%rsi), %rdx
movl $0x1, %eax
cmpq %rdx, %rcx
jb 0x105e78
xorl %eax, %eax
cmpq %rcx, %rdx
sbbl %eax, %eax
retq