LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: delete_ug_node(ma_ug_t*, unsigned long)
void delete_ug_node(ma_ug_t *ug, uint64_t nid)
{
    asg_seq_del(ug->g, nid);
    if(ug->u.a[nid].m!=0) {
        ug->u.a[nid].m = ug->u.a[nid].n = 0;
        free(ug->u.a[nid].a); ug->u.a[nid].a = NULL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rax), %rcx
movl %esi, %edx
orl $0x80000000, (%rcx,%rdx,8) # imm = 0x80000000
leal (%rsi,%rsi), %ecx
xorl %edx, %edx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq (%rdx,%rcx), %r8
movq 0x28(%rax), %r9
movq (%r9,%r8,8), %r10
movq %r10, %r9
andq %rdi, %r9
je 0xd9240
shrq $0x20, %r10
leaq (%r10,%r10,2), %r10
shlq $0x3, %r10
addq 0x8(%rax), %r10
xorl %r11d, %r11d
leaq (%r11,%r11,2), %r14
orb $-0x80, 0xf(%r10,%r14,8)
movl 0x8(%r10,%r14,8), %r14d
xorq $0x1, %r14
movq 0x28(%rax), %r15
movq (%r15,%r14,8), %r15
movq %r15, %r14
andq %rdi, %r14
je 0xd9238
movq 0x8(%rax), %r12
shrq $0x20, %r15
shlq $0x3, %r14
leaq (%r14,%r14,2), %r14
leaq (%r15,%r15,2), %r15
leaq (%r12,%r15,8), %r15
addq $0xc, %r15
xorl %r12d, %r12d
movl -0x4(%r15,%r12), %ebp
xorl %r8d, %ebp
cmpl $0x1, %ebp
jne 0xd922f
orb $-0x80, 0x3(%r15,%r12)
addq $0x18, %r12
cmpq %r12, %r14
jne 0xd921c
incq %r11
cmpq %r9, %r11
jne 0xd91da
leaq 0x1(%rdx), %r8
testq %rdx, %rdx
movq %r8, %rdx
je 0xd91b3
movq 0x10(%rbx), %rax
leaq (%rsi,%rsi,4), %rcx
cmpl $0x0, 0xc(%rax,%rcx,8)
je 0xd928c
leaq (%rax,%rcx,8), %rcx
xorl %edx, %edx
movl %edx, 0x10(%rcx)
shlq $0x3, %rsi
leaq (%rsi,%rsi,4), %r14
movl %edx, 0xc(%rax,%r14)
movq 0x18(%rax,%r14), %rdi
callq 0x2220
movq 0x10(%rbx), %rax
movq $0x0, 0x18(%rax,%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: dedup_exact_ug(dedup_idx_t*, dedup_idx_t*, ma_sub_t*, ma_hit_t_alloc*, R_to_U*, unsigned char*, unsigned char)
uint64_t dedup_exact_ug(dedup_idx_t *ref, dedup_idx_t *qry, ma_sub_t *cov, ma_hit_t_alloc *src, R_to_U *rui, uint8_t *ff, uint8_t trio_f)
{
    // fprintf(stderr, "[M::%s] Start\n", __func__);
    uint64_t k, n_base = 0; int64_t f;
    for (k = 0; k < qry->ug->u.n; k++) {
        if((qry->ug->u.a[k].n == 0) || (qry->ug->u.a[k].m == 0) || (qry->ug->g->seq[k].del)) continue;
        if(if_primary_unitig(&(qry->ug->u.a[k]), qry->rg, cov, src, rui, ff)) continue;
        f = cal_exact_ug_o(ref, &(qry->ug->u.a[k]), trio_f);
        if(f == INT32_MIN) continue;
        if(f == -1) {///delete qry
            delete_ug_node(qry->ug, k); n_base += qry->ug->u.a[k].len;
        } else if(f >= 0) {///delete ref
            delete_ug_node(ref->ug, f); n_base += ref->ug->u.a[f].len;
        }
    }
    // fprintf(stderr, "[M::%s] End\n", __func__);
    return n_base;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq (%rsi), %rax
cmpq $0x0, (%rax)
je 0xd93b5
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movzbl 0x70(%rsp), %ecx
movq %rcx, 0x28(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
movq %r8, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq 0x10(%rax), %rdi
cmpl $0x0, 0x10(%rdi,%rbx)
je 0xd939f
cmpl $0x0, 0xc(%rdi,%rbx)
je 0xd939f
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
cmpl $0x0, (%rax,%rbp,8)
js 0xd939f
addq %rbx, %rdi
movq 0x8(%r13), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0xced5a
testb %al, %al
jne 0xd939f
movq (%r13), %rax
movq 0x10(%rax), %rsi
addq %rbx, %rsi
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
callq 0xd8e36
cmpq $-0x80000000, %rax      # imm = 0x80000000
je 0xd939f
movq %r14, %r12
movq %r13, %r15
movq %rbp, %r14
cmpq $-0x1, %rax
je 0xd936f
movq 0x20(%rsp), %r15
movq %rax, %r14
testq %rax, %rax
js 0xd9392
movq (%r15), %rdi
movq %r14, %rsi
callq 0xd918d
movq (%r15), %rax
movq 0x10(%rax), %rax
leaq (%r14,%r14,4), %rcx
movl (%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, 0x8(%rsp)
movq %r12, %r14
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %r12
incq %rbp
movq (%r13), %rax
addq $0x28, %rbx
cmpq (%rax), %rbp
jb 0xd92e7
jmp 0xd93be
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
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/Overlaps.cpp
// Function: push_ma_utg_t(ma_ug_t*, ma_utg_t*)
void push_ma_utg_t(ma_ug_t *ug, ma_utg_t *u)
{
    ma_utg_t *p; 
    ///graph
    asg_seq_set(ug->g, ug->u.n, u->len, 0); ug->g->seq[ug->u.n].c = 0;

    //unitig
    kv_pushp(ma_utg_t, ug->u, &p); memset(p, 0, sizeof((*p)));
    *p = *u; p->a = NULL; p->s = NULL;
    MALLOC(p->a, p->m); memcpy(p->a, u->a, sizeof((*(p->a)))*p->m);
    if(u->s) {
        MALLOC(p->s, p->len); memcpy(p->s, u->s, sizeof((*(p->s)))*p->len);
    }
    assert(ug->g->n_seq == ug->u.n);
    if(p->n) {
        p->circ = 0; p->start = (p->a[0]>>32); p->end = (p->a[p->n-1]>>32)^1;
    }    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl (%rbx), %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl (%r14), %edx
xorl %ecx, %ecx
callq 0xa0115
movq (%rbx), %rcx
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rax
movb $0x0, 0x4(%rax,%rcx,8)
movq 0x8(%rbx), %rax
cmpq %rax, %rcx
jne 0xd9437
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x2, %eax
cmovneq %rcx, %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x3, %rax
leaq (%rax,%rax,4), %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movq $0x0, 0x20(%r12)
movups (%r14), %xmm1
movups 0x10(%r14), %xmm2
movups %xmm2, 0x10(%r12)
movq 0x20(%r14), %rax
movq %rax, 0x20(%r12)
movups %xmm1, (%r12)
movups %xmm0, 0x18(%r12)
movl 0xc(%r12), %r15d
shlq $0x3, %r15
movq %r15, %rdi
callq 0x2280
movq %rax, 0x18(%r12)
movq 0x18(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2160
cmpq $0x0, 0x20(%r14)
je 0xd94da
movl (%r12), %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq %r15, %rdi
callq 0x2280
movq %rax, 0x20(%r12)
movq 0x20(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2160
movq 0x18(%rbx), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, (%rbx)
jne 0xd9521
movl 0x10(%r12), %eax
testl %eax, %eax
je 0xd9515
andb $0x7f, 0x3(%r12)
movq 0x18(%r12), %rcx
movl 0x4(%rcx), %edx
movl %edx, 0x4(%r12)
decl %eax
movl 0x4(%rcx,%rax,8), %eax
xorl $0x1, %eax
movl %eax, 0x8(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x152144(%rip), %rdi    # 0x22b66c
leaq 0x150772(%rip), %rsi    # 0x229ca1
leaq 0x15214e(%rip), %rcx    # 0x22b684
movl $0x5404, %edx           # imm = 0x5404
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: update_ctg_trans_cc(kv_u_trans_t*)
void update_ctg_trans_cc(kv_u_trans_t *os)
{
    uint64_t k, m; u_trans_t *z;
    kt_for(asm_opt.thread_num, worker_for_ctg_trans_cc, os, os->idx.n);
    for (k = m = 0; k < os->n; k++) {
        if(!(os->a[k].del)) os->a[m++] = os->a[k];
    }
    os->n = m;
    for (k = 0; k < m; k++) {
        kv_pushp(u_trans_t, *os, &z);
        *z = os->a[k];
        z->qn = os->a[k].tn; z->qs = os->a[k].ts; z->qe = os->a[k].te; 
        z->tn = os->a[k].qn; z->ts = os->a[k].qs; z->te = os->a[k].qe; 
    }
    kt_u_trans_t_idx(os, os->idx.n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b02cb(%rip), %rax    # 0x28a758
movl 0x7c(%rax), %edi
movq 0x18(%rbx), %rcx
leaq 0x12b(%rip), %rsi       # 0xda5c6
movq %rbx, %rdx
callq 0x1047b4
cmpq $0x0, (%rbx)
je 0xda4f1
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r14d, %r14d
movq 0x10(%rbx), %rdx
cmpb $0x0, 0x28(%rdx,%rax)
js 0xda4e3
leaq (%rdx,%rax), %rsi
leaq (%r14,%r14,2), %rdi
incq %r14
shlq $0x4, %rdi
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x20(%rdx,%rdi)
movups %xmm1, 0x10(%rdx,%rdi)
movups %xmm0, (%rdx,%rdi)
incq %rcx
addq $0x30, %rax
cmpq (%rbx), %rcx
jb 0xda4b0
jmp 0xda4f4
xorl %r14d, %r14d
movq %r14, (%rbx)
testq %r14, %r14
je 0xda5b0
xorl %r15d, %r15d
movl $0x2, %r12d
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jne 0xda536
leaq (%rax,%rax), %rcx
testq %rax, %rax
cmoveq %r12, %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%rbx), %rdi
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movups (%rcx,%r15), %xmm0
movups 0x10(%rcx,%r15), %xmm1
movups 0x20(%rcx,%r15), %xmm2
movups %xmm2, 0x20(%rcx,%rax)
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
movq 0x10(%rbx), %rdx
movl 0x14(%rdx,%r15), %esi
movl %esi, 0x8(%rcx,%rax)
movl 0xc(%rdx,%r15), %esi
movl %esi, (%rcx,%rax)
movl 0x10(%rdx,%r15), %esi
movl %esi, 0x4(%rcx,%rax)
movl 0x8(%rdx,%r15), %esi
movl %esi, 0x14(%rcx,%rax)
movl (%rdx,%r15), %esi
movl %esi, 0xc(%rcx,%rax)
movl 0x4(%rdx,%r15), %edx
movl %edx, 0x10(%rcx,%rax)
addq $0x30, %r15
decq %r14
jne 0xda509
movl 0x18(%rbx), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc405a
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: is_noisy_ov(unsigned long, unsigned long, unsigned long, unsigned long, double, u_trans_t*, unsigned long)
uint64_t is_noisy_ov(uint64_t s, uint64_t e, uint64_t len, uint64_t bd, double cov_rate, u_trans_t *a, uint64_t a_n)
{
    uint64_t w, k, zs, ze, oz, tot;
    if(e - s < (bd<<1)) {
        w = (e + s)>>1;
        s = ((w>=bd)?(w-bd):(0)); 
        e = ((w+bd<=len)?(w+bd):(len));
    }
    if(s >= e) return 0;
    for(k = tot = 0; k < a_n; k++) {
        if(a[k].qs >= e) break;
        if(a[k].qe <= s) continue;
        zs = MAX(s, a[k].qs); ze = MIN(e, a[k].qe);
        oz = ((ze > zs)? (ze - zs):(0));
        tot += oz;
    }
    if((tot > 0) && (tot >= ((e - s)*cov_rate))) return 1;
    return 0;
}

// Assembly:
movq %rsi, %rax
subq %rdi, %rax
leaq (%rcx,%rcx), %r10
cmpq %r10, %rax
jae 0xdaeb9
addq %rdi, %rsi
shrq %rsi
xorl %edi, %edi
movq %rsi, %rax
subq %rcx, %rax
cmovaeq %rax, %rdi
addq %rcx, %rsi
cmpq %rdx, %rsi
cmovaeq %rdx, %rsi
movq %rsi, %rax
subq %rdi, %rax
jbe 0xdaf61
testq %r9, %r9
je 0xdaf09
addq $0x4, %r8
xorl %ecx, %ecx
movl -0x4(%r8), %edx
cmpq %rdx, %rsi
jbe 0xdaf0b
movl (%r8), %r10d
cmpq %r10, %rdi
jae 0xdaefe
cmpq %rdx, %rdi
cmovaq %rdi, %rdx
cmpq %r10, %rsi
cmovbq %rsi, %r10
subq %rdx, %r10
movl $0x0, %edx
cmovaeq %r10, %rdx
addq %rdx, %rcx
addq $0x30, %r8
decq %r9
jne 0xdaed0
jmp 0xdaf0b
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xdaf61
movq %rcx, %xmm1
movq 0x14a323(%rip), %xmm2   # 0x225240
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x14a327(%rip), %xmm3   # 0x225250
subpd %xmm3, %xmm1
movapd %xmm1, %xmm4
unpckhpd %xmm1, %xmm4            # xmm4 = xmm4[1],xmm1[1]
addsd %xmm1, %xmm4
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movl $0x1, %eax
ucomisd %xmm2, %xmm4
jae 0xdaf63
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: dedup_tang_flank(unsigned int*, unsigned int*, unsigned int*, unsigned int*, unsigned int*, unsigned int*)
void dedup_tang_flank(uint32_t *va, uint32_t *vd, uint32_t *vn0, uint32_t *wa, uint32_t *wd, uint32_t *wn0)
{
    uint64_t k, z, vn = (*vn0), wn = (*wn0);
    uint32_t vp, wp;
    for (k = 0; k < vn && k < wn; k++) {
        if(k < vn) {
            vp = va[vn-k-1]>>1;
            for (z = k; (z < wn) && (vp != (wa[z]>>1)); z++);
            if(z < wn) wn = z;
        }
        if(k < wn) {
            wp = wa[k]>>1;
            for (z = k; (z < vn) && (wp != (va[vn-z-1]>>1)); z++);
            if(z < vn) vn = z;
        }
    }
    if(vn < (*vn0)) {
        z = (*vn0) - vn;
        for (k = 0; k < vn; k++) {
            va[k] = va[k + z]; vd[k] = vd[k + z];
        }
    }
    (*vn0) = vn; (*wn0) = wn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rdx), %eax
testq %rax, %rax
setne %r10b
movl (%r9), %r8d
testl %r8d, %r8d
setne %r11b
andb %r10b, %r11b
movq %rax, %r10
cmpb $0x1, %r11b
jne 0xdbcd9
movl %r8d, %r8d
leaq -0x4(%rdi), %r11
movl $0x1, %ebx
xorl %r14d, %r14d
movq %rax, %r10
movq %r14, %r15
notq %r15
leaq (%rdi,%r10,4), %r12
movl (%r12,%r15,4), %ebp
cmpq %rbx, %r8
movq %rbx, %r12
cmovaq %r8, %r12
movq %r14, %r15
movl (%rcx,%r15,4), %r13d
xorl %ebp, %r13d
cmpl $0x2, %r13d
jb 0xdbc7f
incq %r15
cmpq %r8, %r15
jb 0xdbc67
movq %r12, %r15
cmpq %r8, %r15
cmovbq %r15, %r8
cmpq %r8, %r14
jae 0xdbcc1
movq %r14, %r15
cmpq %r10, %r14
jae 0xdbcba
movl (%rcx,%r14,4), %ebp
leaq (%r11,%r10,4), %r12
movq %r14, %r15
movl (%r12), %r13d
xorl %ebp, %r13d
cmpl $0x2, %r13d
jb 0xdbcba
incq %r15
addq $-0x4, %r12
cmpq %r10, %r15
jb 0xdbc9e
movq %r10, %r15
cmpq %r10, %r15
cmovbq %r15, %r10
incq %r14
cmpq %r10, %r14
jae 0xdbcd9
incq %rbx
addq $-0x4, %r11
cmpq %r8, %r14
jb 0xdbc4c
cmpq %rax, %r10
jae 0xdbd10
testq %r10, %r10
je 0xdbd10
shlq $0x2, %rax
leaq (,%r10,4), %rcx
subq %rcx, %rax
movq %r10, %rcx
movl (%rdi,%rax), %r11d
movl %r11d, (%rdi)
movl (%rsi,%rax), %r11d
movl %r11d, (%rsi)
addq $0x4, %rsi
addq $0x4, %rdi
decq %rcx
jne 0xdbcf5
movl %r10d, (%rdx)
movl %r8d, (%r9)
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: cal_arr_N50(unsigned int*, unsigned int, char const*)
void cal_arr_N50(uint32_t *a, uint32_t n, const char *cmd)
{
    uint64_t i, s, len;
    for (i = len = 0; i < n; i++) len += a[i];
    radix_sort_arch32(a, a + n);

    i = n; s = 0;
    while (i > 0) {
        s += a[--i];
        if(s >= (len>>1)) {
            fprintf(stderr, "CMD::%s[M::%s::] N50: %u, Size::%lu\n", cmd, __func__, a[i], len);
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movl %esi, %r12d
xorl %r14d, %r14d
testl %esi, %esi
je 0xdd2b3
xorl %eax, %eax
movl (%r15,%rax,4), %ecx
addq %rcx, %r14
incq %rax
cmpq %rax, %r12
jne 0xdd2a4
leaq (%r15,%r12,4), %rsi
movq %r15, %rdi
callq 0x9d7a2
movq %r14, %rax
shrq %rax
xorl %ecx, %ecx
subq $0x1, %r12
jb 0xdd309
movl (%r15,%r12,4), %r8d
addq %r8, %rcx
cmpq %rax, %rcx
jb 0xdd2c7
movq 0x1acd00(%rip), %rax    # 0x289fe0
movq (%rax), %rdi
leaq 0x14e68f(%rip), %rsi    # 0x22b979
leaq 0x14e6ad(%rip), %rcx    # 0x22b99e
movq %rbx, %rdx
movq %r14, %r9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: set_fsk(unsigned char*, unsigned char, ul_vec_t*)
void set_fsk(uint8_t *fsk, uint8_t mm, ul_vec_t *idx)
{
    uint64_t k, m, a_n; uc_block_t *a; 
    for (k = 0; k < idx->bb.n; k++) {
        a = idx->bb.a + idx->bb.a[k].ts; a_n = idx->bb.a[k].te - idx->bb.a[k].ts;
        for(m = 0; m < a_n; m++) fsk[a[m].hid] = mm;
    }
}

// Assembly:
cmpq $0x0, 0x20(%rdx)
je 0xdd36a
xorl %eax, %eax
movq 0x30(%rdx), %rcx
leaq (%rax,%rax,8), %r8
movl 0xc(%rcx,%r8,4), %r9d
movl 0x10(%rcx,%r8,4), %r8d
subl %r9d, %r8d
je 0xdd361
leaq (%r9,%r9,8), %r9
cmpl $0x1, %r8d
adcl $0x0, %r8d
leaq (%rcx,%r9,4), %rcx
shlq $0x2, %r8
leaq (%r8,%r8,8), %r8
xorl %r9d, %r9d
movl (%rcx,%r9), %r10d
movb %sil, (%rdi,%r10)
addq $0x24, %r9
cmpq %r9, %r8
jne 0xdd350
incq %rax
cmpq 0x20(%rdx), %rax
jb 0xdd31e
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: gen_contig_trans_func(ma_ug_t*, ma_ug_t*, ma_ug_t*, scaf_res_t*, scaf_res_t*, asg_t*, bubble_type*, ug_opt_t*, kv_u_trans_t*, unsigned char, ma_ug_t**, scaf_res_t**)
kv_u_trans_t *gen_contig_trans_func(ma_ug_t *ref, ma_ug_t *hu0, ma_ug_t *hu1, scaf_res_t *cp0, scaf_res_t *cp1, asg_t *sg, bubble_type *bu, ug_opt_t *opt, kv_u_trans_t *bd, uint8_t is_sep, ma_ug_t **rmg, scaf_res_t **rms)
{

    kv_u_trans_t *os; CALLOC(os, 1);
    if(is_sep) {
        gen_contig_trans(opt, sg, hu1, cp1, hu0, cp0, ref, bd, hu0->u.n, 0, bu, os);
        gen_contig_trans(opt, sg, hu0, cp0, hu1, cp1, ref, bd, 0, hu0->u.n, bu, os);
    } else {
        ma_ug_t *mg = merge_utgs(hu0, hu1); scaf_res_t *ms = merge_scaf_res(cp0, cp1);
        gen_contig_self(opt, sg, mg, ms, ref, bd, hu0->u.n, bu, os, 0);
        if(!rmg) ma_ug_destroy(mg); 
        else (*rmg) = mg;
        if(!rms) destroy_scaf_res_t(ms);
        else (*rms) = ms;
    }

    kt_u_trans_t_idx(os, hu0->u.n + hu1->u.n);
    update_ctg_trans_cc(os);
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2120
movq %rax, %rbx
cmpb $0x0, 0x68(%rsp)
je 0xdeccf
movl (%r14), %eax
xorl %r11d, %r11d
movq 0x58(%rsp), %rdi
movq %r13, %rcx
movq %r13, 0x10(%rsp)
movq %rbp, %r13
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %r8
movq %r15, %r9
pushq %rbx
movq 0x58(%rsp), %r10
pushq %r10
pushq %r11
pushq %rax
movq 0x80(%rsp), %rax
pushq %rax
movq 0x30(%rsp), %rbp
pushq %rbp
callq 0x28898
addq $0x30, %rsp
movl (%r14), %eax
movq 0x58(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
movq 0x10(%rsp), %r9
pushq %rbx
pushq 0x58(%rsp)
pushq %rax
xorl %eax, %eax
pushq %rax
pushq 0x80(%rsp)
pushq %rbp
callq 0x28898
addq $0x30, %rsp
jmp 0xded4f
movq %r14, %rdi
movq %r12, (%rsp)
movq %r12, %rsi
callq 0xde6d2
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
callq 0xde9fe
movq %rax, %r15
movq 0x58(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq 0x8(%rsp), %r8
movq 0x60(%rsp), %r9
pushq $0x0
pushq %rbx
pushq 0x60(%rsp)
pushq (%r14)
callq 0x28a75
movq 0x90(%rsp), %rax
addq $0x20, %rsp
testq %rax, %rax
je 0xded2c
movq %r12, (%rax)
jmp 0xded34
movq %r12, %rdi
callq 0xa0004
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xded43
movq %r15, (%rax)
jmp 0xded4b
movq %r15, %rdi
callq 0x38876
movq (%rsp), %r12
movl (%r12), %esi
addl (%r14), %esi
movq %rbx, %rdi
callq 0xc405a
movq %rbx, %rdi
callq 0xda47b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_ma(ma_hit_t*, _IO_FILE*)
void write_ma(ma_hit_t* x, FILE* fp)
{
    fwrite(&(x->qns), sizeof(x->qns), 1, fp);
    fwrite(&(x->qe), sizeof(x->qe), 1, fp);
    fwrite(&(x->tn), sizeof(x->tn), 1, fp);
    fwrite(&(x->ts), sizeof(x->ts), 1, fp);
    fwrite(&(x->te), sizeof(x->te), 1, fp);
    fwrite(&(x->el), sizeof(x->el), 1, fp);
    fwrite(&(x->no_l_indel), sizeof(x->no_l_indel), 1, fp);

    uint32_t t = x->ml;
    fwrite(&(t), sizeof(t), 1, fp);
    t = x->rev;
    fwrite(&(t), sizeof(t), 1, fp);

    t = x->bl;
    fwrite(&(t), sizeof(t), 1, fp);
    t =x->del;
    fwrite(&(t), sizeof(t), 1, fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
leaq 0x8(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
leaq 0xc(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
leaq 0x10(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
leaq 0x14(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
movsbl 0x20(%r14), %edi
movq %rbx, %rsi
callq 0x2270
movsbl 0x21(%r14), %edi
movq %rbx, %rsi
callq 0x2270
movl 0x18(%r14), %eax
shrl $0x1e, %eax
andl $0x1, %eax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2410
movl 0x18(%r14), %eax
shrl $0x1f, %eax
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2410
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl 0x1c(%r14), %eax
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2410
movq 0x18(%r14), %rax
shrq $0x3f, %rax
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x2410
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: load_yak_binning(hifiasm_opt_t*, char*)
uint32_t load_yak_binning(hifiasm_opt_t *opt, char *ou)///asm_opt
{
    char* paf_name = (char*)malloc(strlen(ou)+50); 
    uint32_t len[2] = {0}; char *lst0, *lst1, *yak0, *yak1;
    lst0 = lst1 = yak0 = yak1 = NULL;

    sprintf(paf_name, "%s.hap1.phase.bin", ou); len[0] = strlen(paf_name)+1;
    if(!test_yak_binning(paf_name, opt->fn_bin_yak[0])) {
        free(paf_name); return 0;
    }

    sprintf(paf_name, "%s.hap2.phase.bin", ou); len[1] = strlen(paf_name)+1;
    if(!test_yak_binning(paf_name, opt->fn_bin_yak[1])) {
        free(paf_name); return 0;
    }
    free(paf_name); paf_name = NULL;

    lst0 = opt->fn_bin_list[0]; MALLOC(opt->fn_bin_list[0], len[0]); 
    sprintf(opt->fn_bin_list[0], "%s.hap1.phase.bin", ou);

    lst1 = opt->fn_bin_list[1]; MALLOC(opt->fn_bin_list[1], len[1]); 
    sprintf(opt->fn_bin_list[1], "%s.hap2.phase.bin", ou);

    memset(R_INF.trio_flag, AMBIGU, R_INF.total_reads * sizeof(uint8_t));
    yak0 = opt->fn_bin_yak[0]; opt->fn_bin_yak[0] = NULL;
    yak1 = opt->fn_bin_yak[1]; opt->fn_bin_yak[1] = NULL;
    ha_triobin(opt); 
    opt->fn_bin_yak[0] = yak0; opt->fn_bin_yak[1] = yak1;
    free(opt->fn_bin_list[0]); opt->fn_bin_list[0] = lst0;
    free(opt->fn_bin_list[1]); opt->fn_bin_list[1] = lst1;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2090
leaq 0x32(%rax), %rdi
callq 0x2280
movq %rax, %r15
leaq 0x14bb43(%rip), %rsi    # 0x22bbf1
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2090
movq %rax, %r12
movq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0x103090
testl %eax, %eax
je 0xe01bd
leaq 0x14bb20(%rip), %rsi    # 0x22bc03
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2090
movq %rax, %r13
movq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0x103090
testl %eax, %eax
je 0xe01bd
incq %r12
incl %r13d
movq %r15, %rdi
callq 0x2220
movq 0x30(%rbx), %r15
movl %r12d, %edi
callq 0x2280
movq %rax, 0x30(%rbx)
leaq 0x14babb(%rip), %rsi    # 0x22bbf1
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x38(%rbx), %r12
movq %r13, %rdi
callq 0x2280
movq %rax, 0x38(%rbx)
leaq 0x14baa9(%rip), %rsi    # 0x22bc03
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x1ab0c2(%rip), %rax    # 0x28b230
movq 0x28(%rax), %rdi
movq 0x50(%rax), %rdx
xorl %esi, %esi
callq 0x20e0
movups 0x20(%rbx), %xmm0
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x10386a
movaps (%rsp), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x30(%rbx), %rdi
callq 0x2220
movq %r15, 0x30(%rbx)
movq 0x38(%rbx), %rdi
callq 0x2220
movq %r12, 0x38(%rbx)
movl $0x1, %ebp
jmp 0xe01c5
movq %r15, %rdi
callq 0x2220
movl %ebp, %eax
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: load_all_data_from_disk(ma_hit_t_alloc**, ma_hit_t_alloc**, char*)
int load_all_data_from_disk(ma_hit_t_alloc **sources, ma_hit_t_alloc **reverse_sources, char* output_file_name)
{
	char* gfa_name = (char*)malloc(strlen(output_file_name)+25);
	sprintf(gfa_name, "%s.ec", output_file_name);
	if (!load_All_reads(&R_INF, gfa_name)) {
		free(gfa_name);
		return 0;
	}

    if(ha_opt_triobin(&asm_opt)) {
        if(!((asm_opt.fn_bin_yak[0]) && (asm_opt.fn_bin_yak[1]) && 
                        (load_yak_binning(&asm_opt, asm_opt.output_file_name)))) {
            ha_triobin(&asm_opt); 
            write_yak_binning(asm_opt.output_file_name, asm_opt.fn_bin_yak[0], asm_opt.fn_bin_yak[1]);
        }
    }

    if((asm_opt.flag & HA_F_VERBOSE_GFA) && load_debug_graph(NULL, NULL, NULL, output_file_name, NULL, NULL, NULL))
    {
        (*sources) = NULL;
        (*reverse_sources) = NULL;
        free(gfa_name);
        return 1;
    }

	sprintf(gfa_name, "%s.ovlp.source", output_file_name);
	if (!load_ma_hit_ts(sources, gfa_name)) {
		free(gfa_name);
		return 0;
	}
	sprintf(gfa_name, "%s.ovlp.reverse", output_file_name);
	if (!load_ma_hit_ts(reverse_sources, gfa_name)) {
		free(gfa_name);
		return 0;
	}
	free(gfa_name);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq %rdx, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x144c83(%rip), %rsi    # 0x224e88
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x1ab015(%rip), %rdi    # 0x28b230
movq %rbx, %rsi
callq 0x32681
testl %eax, %eax
je 0xe02e4
leaq 0x1aa526(%rip), %r13    # 0x28a758
movq 0x20(%r13), %rcx
movq 0x28(%r13), %rax
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0xe025e
cmpq $0x0, 0x30(%r13)
je 0xe0280
cmpq $0x0, 0x38(%r13)
je 0xe0280
testq %rcx, %rcx
je 0xe02fd
testq %rax, %rax
je 0xe02fd
movq 0x10(%r13), %rsi
movq %r13, %rdi
callq 0xe007f
testl %eax, %eax
je 0xe02fd
testb $0x4, (%r13)
je 0xe02bf
movq $0x0, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe032a
testl %eax, %eax
je 0xe02bf
xorl %eax, %eax
movq %rax, (%r12)
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2220
movl $0x1, %ebp
jmp 0xe02ec
leaq 0x14b973(%rip), %rsi    # 0x22bc39
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
movq %r12, %rdi
movq %rbx, %rsi
callq 0xbb7a
testl %eax, %eax
jne 0xe0307
movq %rbx, %rdi
callq 0x2220
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x11422
jmp 0xe0280
leaq 0x14b93a(%rip), %rsi    # 0x22bc48
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbb7a
movl %eax, %ebp
jmp 0xe02e4
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_bub_backtrack_primary_length(asg_t*, ma_ug_t*, unsigned int, buf_t*, unsigned long*, unsigned long*)
void asg_bub_backtrack_primary_length(asg_t *g, ma_ug_t *utg, uint32_t v0, buf_t *b, uint64_t* path_base_len, uint64_t* path_nodes)
{
	uint32_t i, v, u, nv;
    uint64_t len = 0, node = 0;
    ///b->S.a[0] is the sink of this bubble
    asg_arc_t *av = NULL;

    ///v is the sink of this bubble
	v = b->S.a[0];
    len = 0;
	///recover node
    while (1)
    {
        u = b->a[v].p; // u->v
        if(u == v0) break;
        if(v == b->S.a[0])
        {
            len += g->seq[u>>1].len;
        } 
        else
        {
            nv = asg_arc_n(g, u);
            av = asg_arc_a(g, u);
            for (i = 0; i < nv; ++i)
            {
                if(av[i].del) continue;
                if(av[i].v == v) break;
            }
            ///if(i == nv) fprintf(stderr, "ERROR\n");
            len += (uint32_t)av[i].ul;
        }

        if(utg)
        {
            node += utg->u.a[u>>1].n;
        }
        else
        {
            node++;
        }
         
        v = u;
    }
    
    if(path_base_len) (*path_base_len) = len;
    if(path_nodes) (*path_nodes) = node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x10(%rsp)
movq %r8, -0x18(%rsp)
movq (%rcx), %r13
movq 0x18(%rcx), %rax
movl (%rax), %ecx
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
movl (%r13,%rax), %r14d
cmpl %edx, %r14d
jne 0xe16a2
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0xe177a
xorl %eax, %eax
xorl %r11d, %r11d
movl %ecx, %ebp
movq %rdi, -0x8(%rsp)
movl %r14d, %ebx
movl %r14d, %r14d
cmpl %ecx, %ebp
jne 0xe16cf
movq 0x20(%rdi), %r8
movl %ebx, %r9d
shrl %r9d
movl (%r8,%r9,8), %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
jmp 0xe1739
movq 0x8(%rdi), %r15
movq 0x28(%rdi), %r8
movq (%r8,%r14,8), %r10
movq %r10, %r8
shrq $0x20, %r8
leaq (%r8,%r8,2), %r12
testl %r10d, %r10d
je 0xe172a
movq %rcx, %rdi
movq %r13, %rcx
movl %r10d, %r9d
leaq (%r15,%r12,8), %r8
addq $0xc, %r8
xorl %r13d, %r13d
cmpl $0x0, (%r8)
js 0xe170b
cmpl %ebp, -0x4(%r8)
je 0xe171a
incq %r13
addq $0x18, %r8
cmpq %r13, %r9
jne 0xe16ff
movq %r10, %r13
movl %r13d, %r8d
movq %rcx, %r13
movq %rdi, %rcx
movq -0x8(%rsp), %rdi
jmp 0xe172d
xorl %r8d, %r8d
leaq (%r15,%r12,8), %r9
leaq (%r8,%r8,2), %r8
movl (%r9,%r8,8), %r15d
testq %rsi, %rsi
je 0xe1753
movq 0x10(%rsi), %r8
movl %ebx, %r9d
shrl %r9d
leaq (%r9,%r9,4), %r9
movl 0x10(%r8,%r9,8), %r8d
jmp 0xe1759
movl $0x1, %r8d
addq %r8, %rax
addq %r15, %r11
leaq (%r14,%r14,8), %r8
leaq (%r8,%r8,2), %r8
addq %r14, %r8
movl (%r13,%r8), %r14d
movl %ebx, %ebp
cmpl %edx, %r14d
jne 0xe16ae
movq -0x18(%rsp), %rcx
testq %rcx, %rcx
je 0xe1787
movq %r11, (%rcx)
movq -0x10(%rsp), %rcx
testq %rcx, %rcx
je 0xe1794
movq %rax, (%rcx)
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: asg_bub_backtrack_check_switch(asg_t*, ma_ug_t*, unsigned int, buf_t*)
int asg_bub_backtrack_check_switch(asg_t *g, ma_ug_t *utg, uint32_t v0, buf_t *b)
{
	uint32_t v, k, rId, father_occ = 0, mother_occ = 0;
    ma_utg_t* p = NULL;
    ///b->S.a[0] is the sink of this bubble
    ///v is the sink of this bubble
    v = b->S.a[0];
    ///recover node
    do {
        uint32_t u = b->a[v].p; // u->v
        if(v != b->S.a[0])
        {
            p = &(utg->u.a[v>>1]);
            for (k = 0; k < p->n; k++)
            {
                rId = p->a[k]>>33;
                if(R_INF.trio_flag[rId] == FATHER) father_occ++;
                if(R_INF.trio_flag[rId] == MOTHER) mother_occ++;
                if(R_INF.trio_flag[rId] != AMBIGU) continue;
                R_INF.trio_flag[rId] = DROP;
            }
        }
        v = u;
    } while (v != v0);

    if(father_occ > 0 && mother_occ > 0) return 1;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, -0x8(%rsp)
movq 0x18(%rcx), %rax
movl (%rax), %esi
xorl %eax, %eax
leaq 0x1a9a73(%rip), %r8     # 0x28b230
xorl %edi, %edi
movl %esi, %r10d
movl %esi, %r9d
leaq (%r9,%r9,8), %r11
leaq (%r11,%r11,2), %r11
addq %r9, %r11
movq (%rcx), %r9
movq 0x18(%rcx), %rbx
movl (%r9,%r11), %esi
cmpl (%rbx), %r10d
je 0xe1847
movq -0x8(%rsp), %r9
movq 0x10(%r9), %r11
shrl %r10d
leaq (%r10,%r10,4), %r10
cmpl $0x0, 0x10(%r11,%r10,8)
je 0xe1847
leaq (%r11,%r10,8), %r10
xorl %r11d, %r11d
movq 0x18(%r10), %rbx
movq (%rbx,%r11,8), %r14
shrq $0x21, %r14
movq 0x28(%r8), %r15
movb (%r15,%r14), %r9b
xorl %ebp, %ebp
cmpb $0x1, %r9b
sete %r13b
xorl %ebx, %ebx
cmpb $0x2, %r9b
sete %r12b
testb %r9b, %r9b
jne 0xe1831
movb $0x5, (%r15,%r14)
movb %r13b, %bpl
addl %ebp, %eax
movb %r12b, %bl
addl %ebx, %edi
incq %r11
movl 0x10(%r10), %r9d
cmpq %r9, %r11
jb 0xe17ff
cmpl %edx, %esi
jne 0xe17bf
testl %eax, %eax
setne %al
testl %edi, %edi
setne %cl
andb %al, %cl
movzbl %cl, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: debug_asg_bub_pop1_primary_trio(asg_t*, ma_ug_t*, unsigned int, unsigned long, buf_t*, unsigned int, unsigned int, unsigned int)
void debug_asg_bub_pop1_primary_trio(asg_t *g, ma_ug_t *utg, uint32_t v0, uint64_t max_dist, buf_t *b, 
uint32_t positive_flag, uint32_t negative_flag, uint32_t found)
{
    buf_t b_new;
    memset(&b_new, 0, sizeof(buf_t));
    b_new.a = (binfo_t*)calloc(g->n_seq * 2, sizeof(binfo_t));
    uint32_t n_pop = asg_bub_pop1_primary_trio(g, utg, v0, max_dist, &b_new, positive_flag, negative_flag, 0, NULL, NULL, NULL, 0, 0, NULL);
    if(n_pop != found) fprintf(stderr, "ERROR\n");

    free(b_new.a); free(b_new.S.a); free(b_new.T.a); free(b_new.b.a); free(b_new.e.a);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, 0x4c(%rsp)
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r13
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r12
movaps %xmm0, 0x50(%r12)
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
xorl %ebx, %ebx
movq %rbx, 0x60(%r12)
movl 0x14(%rdi), %edi
addl %edi, %edi
movl $0x1c, %esi
callq 0x2120
movq %rax, (%r12)
movq %rbx, 0x38(%rsp)
movl %ebx, 0x30(%rsp)
movl %ebx, 0x28(%rsp)
movq %rbx, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %ebx, 0x8(%rsp)
movl 0xf0(%rsp), %eax
movl %eax, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %r12, %r8
movl 0x4c(%rsp), %r9d
callq 0xbf39f
cmpl 0xf8(%rsp), %eax
jne 0xe4cc3
movq 0x50(%rsp), %rdi
callq 0x2220
movq 0x68(%rsp), %rdi
callq 0x2220
movq 0x80(%rsp), %rdi
callq 0x2220
movq 0x98(%rsp), %rdi
callq 0x2220
movq 0xb0(%rsp), %rdi
callq 0x2220
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x114b6
jmp 0xe4c76
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_bub_pop_max_dist(asg_t*, buf_t*)
uint64_t get_bub_pop_max_dist(asg_t *g, buf_t *b)
{
    uint32_t n_vtx = g->n_seq, i, p_bub;
    uint64_t cLen = 0, mLen = 0, tLen = 0;
    
    
    for (i = 0; i < n_vtx; ++i) 
    {
        if(b->a[i].s) continue;
        cLen = dfs_subgraph(g, b, i, &p_bub);
        tLen += cLen;
        if(p_bub == 0) continue;///no bubble
        if(cLen > mLen) mLen = cLen;
    }

    for (i = 0; i < n_vtx; ++i) 
    {
        ///if(b->a[i].s == 0) fprintf(stderr, "ERROR\n");
        b->a[i].s = 0;
        ///debug_tLen += g->seq[i].len;
    }
    ///if(debug_tLen != tLen) fprintf(stderr, "ERROR\n");

    ///fprintf(stderr, "mLen: %lu, tLen: %lu\n", mLen, tLen);
    b->S.n = 0;
    return mLen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x14(%rdi), %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0xe5016
movq %rdi, %r15
movl $0x18, %r13d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq (%rbx), %rax
cmpl $0x0, (%rax,%r13)
js 0xe5008
movq %r15, %rdi
movq %rbx, %rsi
movl %r12d, %edx
leaq 0x4(%rsp), %rcx
callq 0xe4cca
cmpq %r14, %rax
cmovbeq %r14, %rax
cmpl $0x0, 0x4(%rsp)
cmovneq %rax, %r14
incq %r12
addq $0x1c, %r13
cmpq %r12, %rbp
jne 0xe4fdb
jmp 0xe5019
xorl %r14d, %r14d
testl %ebp, %ebp
je 0xe5040
movl %ebp, %ecx
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
xorl %ecx, %ecx
movq (%rbx), %rdx
andl $0x7fffffff, 0x18(%rdx,%rcx) # imm = 0x7FFFFFFF
addq $0x1c, %rcx
cmpq %rcx, %rax
jne 0xe502c
movq $0x0, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: append_node_arcs(asg_t*, asg_t*, unsigned char*, unsigned char, unsigned int)
void append_node_arcs(asg_t *des, asg_t *src, uint8_t *s, uint8_t se, uint32_t v)
{
    asg_arc_t *av, *za; uint32_t an, zn, k, n0, n1;
    n0 = n1 = 0;
    za = asg_arc_a(src, v); zn = asg_arc_n(src, v); 
    av = asg_arc_a(des, v); an = asg_arc_n(des, v); 
    ///set
    for (k = 0; k < zn; k++) {
        if(za[k].del) continue;
        s[za[k].v] |= se; n0++;
    }

    for (k = 0; k < an; k++) {
        ///s[av[k].v]&se:: in the existing graph
        if(s[av[k].v]&se) {
            av[k].del = 0; n1++;
            asg_arc_del(des, av[k].v^1, (av[k].ul>>32)^1, 0);
        }
    }
    
    ///reset
    for (k = 0; k < zn; k++) {
        if(za[k].del) continue;
        if(s[za[k].v]&se) s[za[k].v] -= se;
    }
    if(!(n0 == n1)) {
        fprintf(stderr, "[M::%s] n0::%u, n1::%u\n", __func__, n0, n1);
    }
    assert(n0 == n1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rax
movq 0x8(%rsi), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsi), %rsi
movl %r8d, %edi
movq (%rsi,%rdi,8), %r10
movq %r10, %r8
movq 0x28(%rax), %rsi
movq (%rsi,%rdi,8), %rbx
movq %rbx, %rsi
shrq $0x20, %rsi
leaq (%rsi,%rsi,2), %r11
shlq $0x3, %r11
addq 0x8(%rax), %r11
shrq $0x20, %r8
movq %r8, 0x8(%rsp)
xorl %esi, %esi
movl $0x0, %edi
testl %r10d, %r10d
je 0xe57dd
movl %r10d, %edi
movq 0x8(%rsp), %r8
leaq (%r8,%r8,2), %r9
movq 0x10(%rsp), %r8
leaq (%r8,%r9,8), %r14
addq $0xc, %r14
shlq $0x3, %rdi
leaq (%rdi,%rdi,2), %r15
xorl %r12d, %r12d
xorl %edi, %edi
cmpl $0x0, (%r14,%r12)
js 0xe57d4
movl -0x4(%r14,%r12), %r9d
orb %cl, (%rdx,%r9)
incl %edi
addq $0x18, %r12
cmpq %r12, %r15
jne 0xe57c2
testl %ebx, %ebx
je 0xe586a
movl %ebx, %ebx
xorl %r14d, %r14d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %esi, %esi
leaq (%r14,%r14,2), %r9
movl 0x8(%r11,%r9,8), %r12d
testb %cl, (%rdx,%r12)
je 0xe5862
leaq (%r11,%r9,8), %r9
andb $0x7f, 0xf(%r9)
incl %esi
xorq $0x1, %r12
movq 0x28(%rax), %r13
movq (%r13,%r12,8), %r13
movq %r13, %r12
andq %r15, %r12
je 0xe5862
movl 0x4(%r9), %ebp
movq 0x8(%rax), %r9
shrq $0x20, %r13
shlq $0x3, %r12
leaq (%r12,%r12,2), %r12
leaq (%r13,%r13,2), %r13
leaq (%r9,%r13,8), %r13
addq $0xc, %r13
xorl %r9d, %r9d
movl -0x4(%r13,%r9), %r8d
xorl %ebp, %r8d
cmpl $0x1, %r8d
jne 0xe5859
andb $0x7f, 0x3(%r13,%r9)
addq $0x18, %r9
cmpq %r9, %r12
jne 0xe5845
incq %r14
cmpq %rbx, %r14
jne 0xe57f2
testl %r10d, %r10d
je 0xe58b8
movl %r10d, %r9d
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%rsp), %r8
leaq (%r8,%rax,8), %rax
addq $0xc, %rax
shlq $0x3, %r9
leaq (%r9,%r9,2), %r8
xorl %r9d, %r9d
cmpl $0x0, (%rax,%r9)
js 0xe58af
movl -0x4(%rax,%r9), %r10d
movb (%rdx,%r10), %r11b
testb %cl, %r11b
je 0xe58af
subb %cl, %r11b
movb %r11b, (%rdx,%r10)
addq $0x18, %r9
cmpq %r9, %r8
jne 0xe5893
cmpl %esi, %edi
jne 0xe58cb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x114d8
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: asg_arc_del_triangular_directly(asg_t*, long long, ma_hit_t_alloc*, R_to_U*)
int asg_arc_del_triangular_directly(asg_t *g, long long min_edge_length, 
ma_hit_t_alloc* reverse_sources, R_to_U* ruIndex)
{
    double startTime = Get_T();
    ///the reason is that each read has two direction (query->target, target->query)
    uint32_t v, n_vtx = g->n_seq * 2, n_reduced = 0;

    for (v = 0; v < n_vtx; ++v) 
    {
        uint32_t nv = asg_arc_n(g, v);
        if (g->seq[v>>1].del)
        {
            continue;
        } 

        if(nv < 2)
        {
            continue;
        }


        n_reduced += test_triangular_directly(g, v, min_edge_length, reverse_sources, ruIndex);
    }

    

    if (n_reduced) {
        asg_cleanup(g);
        asg_symm(g);
    }

    if(VERBOSE >= 1)
    {
        fprintf(stderr, "[M::%s] removed %d triangular overlaps\n", 
        __func__, n_reduced);
        fprintf(stderr, "[M::%s] takes %0.2f s\n\n", __func__, Get_T()-startTime);
    }
    return n_reduced;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x300fc
movl 0x14(%rbx), %eax
addl %eax, %eax
je 0xe76a8
movl %eax, %r14d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%rbx), %rax
movl %r13d, %ecx
shrl %ecx
cmpl $0x0, (%rax,%rcx,8)
js 0xe769e
movq 0x28(%rbx), %rax
testl $0xfffffffe, (%rax,%r13,8) # imm = 0xFFFFFFFE
je 0xe769e
movq %rbx, %rdi
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
movq (%rsp), %r8
callq 0xe6fae
addl %eax, %ebp
incq %r13
cmpq %r13, %r14
jne 0xe766a
jmp 0xe76aa
xorl %ebp, %ebp
testl %ebp, %ebp
je 0xe76ca
movq %rbx, %rdi
callq 0xa02fa
movq %rbx, %rdi
callq 0xa0333
movq %rbx, %rdi
callq 0xa03e9
orb $-0x80, 0x17(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_untig_coverage(ma_hit_t_alloc*, ma_sub_t*, unsigned int*, unsigned long)
long long get_untig_coverage(ma_hit_t_alloc* sources, ma_sub_t* coverage_cut, uint32_t* b, uint64_t n)
{
    uint64_t k, j;
    uint32_t v;
    ma_hit_t *h;
    long long R_bases = 0, C_bases = 0;
    for (k = 0; k < n; ++k) 
    {
        v = b[k]>>1;
        R_bases += coverage_cut[v].e - coverage_cut[v].s;
        for (j = 0; j < (uint64_t)(sources[v].length); j++)
        {
            h = &(sources[v].buffer[j]);
            C_bases += Get_qe((*h)) - Get_qs((*h));
        }
    }
    return C_bases/R_bases;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %eax, %eax
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
xorl %r10d, %r10d
movl (%rdx,%r10,4), %r11d
shrl %r11d
leaq (%r11,%r11,2), %r11
movl 0xc(%rdi,%r11,8), %r14d
testq %r14, %r14
je 0xe7e46
leaq (%rdi,%r11,8), %rbx
movq (%rbx), %rbx
shlq $0x3, %r14
leaq (%r14,%r14,4), %r14
xorl %r15d, %r15d
movl 0x8(%rbx,%r15), %r12d
subl (%rbx,%r15), %r12d
addq %r12, %rax
addq $0x28, %r15
cmpq %r15, %r14
jne 0xe7e31
movl 0x4(%rsi,%r11,4), %ebx
movl (%rsi,%r11,4), %r11d
andl %r9d, %r11d
subl %r11d, %ebx
addq %rbx, %r8
incq %r10
cmpq %rcx, %r10
jne 0xe7e0a
cqto
idivq %r8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: get_arc(asg_t*, unsigned int, unsigned int, asg_arc_t*)
int get_arc(asg_t *g, uint32_t src, uint32_t dest, asg_arc_t* result)
{
    uint32_t i;
    if(g->seq[src>>1].del) return 0;

    uint32_t nv = asg_arc_n(g, src);
    asg_arc_t *av = asg_arc_a(g, src);
    for (i = 0; i < nv; i++)
    {
        if(av[i].del) continue;
        if(av[i].v == dest)
        {
            (*result) = av[i];
            break;
        } 
    }

    if(i != nv) return 1;
    return 0;
}

// Assembly:
movq 0x20(%rdi), %rax
movl %esi, %r8d
shrl %r8d
cmpl $0x0, (%rax,%r8,8)
js 0xe8da1
movq 0x28(%rdi), %rax
movl %esi, %esi
movq (%rax,%rsi,8), %rsi
testl %esi, %esi
je 0xe8da4
movq 0x8(%rdi), %rax
movq %rsi, %rdi
shrq $0x20, %rdi
movl %esi, %r8d
leaq (%rdi,%rdi,2), %rdi
leaq (%rax,%rdi,8), %rax
addq $0xc, %rax
xorl %edi, %edi
cmpl $0x0, (%rax)
js 0xe8d91
cmpl %edx, -0x4(%rax)
je 0xe8da8
incq %rdi
addq $0x18, %rax
cmpq %rdi, %r8
jne 0xe8d87
movl %esi, %edi
jmp 0xe8db7
xorl %eax, %eax
retq
xorl %edi, %edi
jmp 0xe8db7
movq 0x4(%rax), %rdx
movq %rdx, 0x10(%rcx)
movups -0xc(%rax), %xmm0
movups %xmm0, (%rcx)
xorl %eax, %eax
cmpl %esi, %edi
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: insert_index(asg_t*, unsigned int)
uint32_t insert_index(asg_t *g, uint32_t v)
{
    uint32_t v_tx = g->n_seq * 2;
    if(v >= v_tx) return (uint32_t)-1;
    if(asg_arc_n(g, v)!=0) return (g->idx[v]>>32) + asg_arc_n(g, v);
    ///now v itself does not have any edge
    while (v < v_tx && asg_arc_n(g, v) == 0){v++;}
    ///means there are no edge at the whole graph
    if(v>=v_tx) return g->n_arc;
    return (g->idx[v]>>32);
}

// Assembly:
movl 0x14(%rdi), %edx
addl %edx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, %edx
jbe 0xe8de6
movq 0x28(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %r8
testl %r8d, %r8d
je 0xe8de7
movq %r8, %rax
shrq $0x20, %rax
addl %r8d, %eax
retq
cmpl %esi, %edx
seta %sil
jbe 0xe8e26
cmpl $0x0, (%rax,%rcx,8)
je 0xe8dfa
movq %rcx, %rdx
jmp 0xe8e1a
movl %edx, %esi
leaq -0x1(%rsi), %r8
cmpq %rcx, %r8
je 0xe8e26
leaq 0x1(%rcx), %rdx
cmpl $0x0, 0x8(%rax,%rcx,8)
movq %rdx, %rcx
je 0xe8e00
cmpq %rsi, %rdx
setb %sil
testb %sil, %sil
je 0xe8e26
movl %edx, %ecx
movl 0x4(%rax,%rcx,8), %eax
retq
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl 0x4(%rdi), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: insert_index_p(asg_t*, long long, unsigned int)
asg_arc_t* insert_index_p(asg_t *g, long long index, uint32_t m_distance)
{
    ///each edge has two direction
    if (g->n_arc + m_distance > g->m_arc) 
    {
        ///g->m_arc = g->n_arc + (m_distance<<1);
        g->m_arc = (g->n_arc + m_distance)<<1;
		g->arc = (asg_arc_t*)realloc(g->arc, g->m_arc * sizeof(asg_arc_t));
	}
    long long i = g->n_arc; i--;
    for (; i >= index; i--)
    {
        g->arc[i+m_distance] = g->arc[i];
    }

    g->n_arc = g->n_arc + m_distance;

    return &(g->arc[index]);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl 0x4(%rdi), %eax
movq %rsi, %r14
addl %edx, %eax
cmpl (%rdi), %eax
jbe 0xe8e62
addl %eax, %eax
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
callq 0x2370
movq %rax, 0x8(%rbx)
movl 0x4(%rbx), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %r14, %rax
jle 0xe8eb0
movl %ebp, %ecx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (,%rax,8), %rdx
leaq (%rdx,%rdx,2), %rdx
decq %rax
movq 0x8(%rbx), %rsi
leaq (%rdx,%rsi), %rdi
addq $-0x18, %rdi
movq -0x8(%rdx,%rsi), %r8
movq %r8, 0x10(%rcx,%rdi)
movups -0x18(%rdx,%rsi), %xmm0
movups %xmm0, (%rcx,%rdi)
addq $-0x18, %rdx
cmpq %r14, %rax
jg 0xe8e85
movl 0x4(%rbx), %eax
addl %eax, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
andl $0x80000000, %eax       # imm = 0x80000000
orl %ebp, %eax
movl %eax, 0x4(%rbx)
leaq (%r14,%r14,2), %rax
shlq $0x3, %rax
addq 0x8(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: append_ma_utg_t(ma_utg_t*, ma_utg_t*)
void append_ma_utg_t(ma_utg_t* v_x, ma_utg_t* v_y)
{
    if(v_x->m < (v_x->n + v_y->n))
    {
        v_x->m = v_x->n + v_y->n;
        v_x->a = (uint64_t*)realloc(v_x->a, v_x->m * sizeof(uint64_t));
    }
    memcpy(v_x->a+v_x->n, v_y->a, v_y->n*sizeof(uint64_t));
    v_x->n = v_x->n + v_y->n;
    free(v_y->a);
    v_y->m=v_y->n=0;v_y->a=NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rsi), %eax
addl 0x10(%rdi), %eax
cmpl %eax, 0xc(%rdi)
jae 0xe912a
movl %eax, 0xc(%r14)
movq 0x18(%r14), %rdi
movl %eax, %esi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x18(%r14)
movl 0x10(%r14), %edi
shlq $0x3, %rdi
addq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
callq 0x2160
movl 0x10(%rbx), %eax
addl %eax, 0x10(%r14)
movq 0x18(%rbx), %rdi
callq 0x2220
xorl %eax, %eax
movq %rax, 0xc(%rbx)
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/Overlaps.cpp
// Function: lable_hap_asg_by_ug(ma_ug_t*, asg_t*)
void lable_hap_asg_by_ug(ma_ug_t *ug, asg_t *read_g)
{
    uint32_t v, n_vtx, i = 0, qn;
    asg_t* nsg = ug->g;
    n_vtx = nsg->n_seq;
    ma_utg_t* node = NULL;
    for (v = 0; v < n_vtx; ++v) 
    {
        if(nsg->seq[v].c == HAP_LABLE)
        {
            node = &(ug->u.a[v]);
            for (i = 0; i < node->n; i++)
            {
                qn = node->a[i]>>33;
                read_g->seq[qn].c = HAP_LABLE;
            }
        }
    }

}

// Assembly:
pushq %rbx
movq 0x18(%rdi), %rcx
movl 0x14(%rcx), %eax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
je 0xe98c0
movq 0x20(%rcx), %rcx
xorl %edx, %edx
cmpb $0x2, 0x4(%rcx,%rdx,8)
jne 0xe98b8
movq 0x10(%rdi), %r9
leaq (%rdx,%rdx,4), %r10
movl 0x10(%r9,%r10,8), %r8d
testq %r8, %r8
je 0xe98b8
leaq (%r9,%r10,8), %r9
movq 0x18(%r9), %r9
movq 0x20(%rsi), %r10
xorl %r11d, %r11d
movq (%r9,%r11,8), %rbx
shrq $0x21, %rbx
movb $0x2, 0x4(%r10,%rbx,8)
incq %r11
cmpq %r11, %r8
jne 0xe98a2
incq %rdx
cmpq %rax, %rdx
jne 0xe987a
popq %rbx
retq