LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: print_cns_seq(ma_ug_t*, ul_str_t*, unsigned long*, unsigned long)
void print_cns_seq(ma_ug_t *ug, ul_str_t *str, uint64_t *cns_seq, uint64_t cns_occ)
{
    fprintf(stderr,"[M::%s::]\t", __func__);
    uint64_t k, ck;
    for (k = ck = 0; k < str->cn; k++) {
        for (; ck < cns_occ; ck++) {
            if(cns_seq[ck] >= k) break;
        }
        if(ck < cns_occ && cns_seq[ck] == k) {
            fprintf(stderr, "utg%.6d%c(%c)\t", (((uint32_t)str->a[k])>>1)+1, 
                    "lc"[ug->u.a[(((uint32_t)str->a[k])>>1)].circ], "+-"[(((uint32_t)str->a[k])&1)]);
        } else {
            fprintf(stderr, "*\t");
        }
    }
    fprintf(stderr,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq 0x98f61(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x6c202(%rip), %rsi     # 0x39728b
leaq 0x6c206(%rip), %rdx     # 0x397296
movb $0x0, %al
callq 0x22a0
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x32b1cd
jmp 0x32b0c5
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x32b0f3
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jb 0x32b0e3
jmp 0x32b0f3
jmp 0x32b0e5
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x32b0c5
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x32b1a2
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jne 0x32b1a2
movq 0x98ec2(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %edx
shrl %edx
addl $0x1, %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
shrl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x5a198(%rip), %rax     # 0x385303
movsbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rsi
movq (%rax,%rsi,8), %rax
andl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x57d0e(%rip), %rax     # 0x382e9b
movsbl (%rax,%rsi), %r8d
leaq 0x65640(%rip), %rsi     # 0x3907d9
movb $0x0, %al
callq 0x22a0
jmp 0x32b1ba
movq 0x98e37(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x6c0f1(%rip), %rsi     # 0x3972a4
movb $0x0, %al
callq 0x22a0
jmp 0x32b1bc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x32b0a7
movq 0x98e0c(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x5b84a(%rip), %rsi     # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: print_res_seq(poa_g_t*, ma_ug_t*, unsigned int*, unsigned int)
void print_res_seq(poa_g_t *pg, ma_ug_t *ug, uint32_t *cns_seq, uint32_t cns_occ)
{
    fprintf(stderr,"[M::%s::]\t", __func__);
    uint64_t k;
    for (k = 0; k < cns_occ; k++) {
        fprintf(stderr, "utg%.6d%c(%c)\t", (pg->seq.a[(cns_seq[k]>>1)].nid>>1)+1, 
                "lc"[ug->u.a[(pg->seq.a[(cns_seq[k]>>1)].nid>>1)].circ], 
                "+-"[(pg->seq.a[(cns_seq[k]>>1)].nid&1)]);
        
    }
    fprintf(stderr,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0x98dd2(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x6c073(%rip), %rsi     # 0x39728b
leaq 0x6c088(%rip), %rdx     # 0x3972a7
movb $0x0, %al
callq 0x22a0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jae 0x32b2f9
movq 0x98d9b(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
shrl %ecx
movl %ecx, %ecx
movl 0x4(%rax,%rcx,8), %edx
shrl %edx
addl $0x1, %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %r8
movl (%rsi,%r8,4), %esi
shrl %esi
movl %esi, %esi
movl 0x4(%rcx,%rsi,8), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
shrl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x5a05c(%rip), %rax     # 0x385303
movsbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %r8
movl (%rsi,%r8,4), %esi
shrl %esi
movl %esi, %esi
movl 0x4(%rax,%rsi,8), %eax
andl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x57bc6(%rip), %rax     # 0x382e9b
movsbl (%rax,%rsi), %r8d
leaq 0x654f8(%rip), %rsi     # 0x3907d9
movb $0x0, %al
callq 0x22a0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x32b22e
movq 0x98ce0(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x5b71e(%rip), %rsi     # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: uc_block_qse_cutoff(unsigned int, unsigned int, uc_block_t*, unsigned int*, unsigned int*)
void uc_block_qse_cutoff(uint32_t c_ts, uint32_t c_te, uc_block_t *x, uint32_t *nqs, uint32_t *nqe)
{
    uint32_t l, r;
    assert(c_ts >= x->ts && c_te <= x->te);
    if(!(x->rev)) {
        l = c_ts - x->ts; r = x->te - c_te;
    } else {
        r = c_ts - x->ts; l = x->te - c_te;
    }

    (*nqs) = x->qs + get_offset_adjust(l, x->te - x->ts, x->qe - x->qs);
    (*nqe) = x->qe - get_offset_adjust(r, x->te - x->ts, x->qe - x->qs);
    assert((*nqs) >= x->qs && (*nqe) <= x->qe);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, -0x29(%rbp)
jb 0x32d6bb
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
setbe %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x32d6c4
jmp 0x32d6c6
jmp 0x32d6e5
leaq 0x6a046(%rip), %rdi     # 0x397713
leaq 0x68ae5(%rip), %rsi     # 0x3961b9
movl $0x1467, %edx           # imm = 0x1467
leaq 0x6a052(%rip), %rcx     # 0x397732
callq 0x2130
movq -0x10(%rbp), %rax
movb 0x20(%rax), %al
shrb $0x5, %al
andb $0x1, %al
cmpb $0x0, %al
jne 0x32d711
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x32d72b
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
subl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
subl 0x4(%rax), %edx
callq 0xc14d0
movl -0x34(%rbp), %ecx
addl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
subl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
subl 0x4(%rax), %edx
callq 0xc14d0
movl -0x30(%rbp), %ecx
subl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x2a(%rbp)
jb 0x32d7c4
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setbe %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x32d7cd
jmp 0x32d7cf
jmp 0x32d7ee
leaq 0x69faf(%rip), %rdi     # 0x397785
leaq 0x689dc(%rip), %rsi     # 0x3961b9
movl $0x1470, %edx           # imm = 0x1470
leaq 0x69f49(%rip), %rcx     # 0x397732
callq 0x2130
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: update_poa_nid_occ(ma_ug_t*, uc_block_t*, poa_g_t*, long, unsigned long*, long, long)
void update_poa_nid_occ(ma_ug_t *ug, uc_block_t *raw, poa_g_t *g, int64_t gidx, uint64_t *str, int64_t str_idx, int64_t is_rev)
{
    uint32_t g_v, str_v, new_occ; uc_block_t *z; 
    ///update 
    g_v = g->seq.a[gidx].nid;
    z = &(raw[str[str_idx]>>32]); str_v = ((uint32_t)str[str_idx]); if(is_rev) str_v ^= 1;
    assert(g_v == str_v); assert(g->seq.a[gidx].occ <= ug->u.a[g->seq.a[gidx].nid>>1].n);
    if(g->seq.a[gidx].occ != ug->u.a[g->seq.a[gidx].nid>>1].n) {
        new_occ = ug_occ_w(z->ts, z->te, &(ug->u.a[z->hid]));
        if(new_occ > g->seq.a[gidx].occ) g->seq.a[gidx].occ = new_occ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x38(%rbp)
cmpq $0x0, 0x10(%rbp)
je 0x32f5c5
movl -0x38(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jne 0x32f5cf
jmp 0x32f5ee
leaq 0x682e9(%rip), %rdi     # 0x3978bf
leaq 0x66bdc(%rip), %rsi     # 0x3961b9
movl $0x1555, %edx           # imm = 0x1555
leaq 0x682e3(%rip), %rcx     # 0x3978cc
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq 0x10(%rdx), %rdx
movq -0x20(%rbp), %rsi
movl 0x4(%rdx,%rsi,8), %edx
shrl %edx
movl %edx, %edx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
ja 0x32f627
jmp 0x32f646
leaq 0x68301(%rip), %rdi     # 0x39792f
leaq 0x66b84(%rip), %rsi     # 0x3961b9
movl $0x1555, %edx           # imm = 0x1555
leaq 0x6828b(%rip), %rcx     # 0x3978cc
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq 0x10(%rdx), %rdx
movq -0x20(%rbp), %rsi
movl 0x4(%rdx,%rsi,8), %edx
shrl %edx
movl %edx, %edx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
je 0x32f6d4
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
movq -0x48(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %esi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x48(%rbp), %rax
movl (%rax), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdx
callq 0x327090
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
jbe 0x32f6d2
movl -0x3c(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
jmp 0x32f6d4
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: poa_g_arc_w(poa_g_t*, unsigned int, unsigned int)
uint32_t poa_g_arc_w(poa_g_t *pg, uint32_t v, uint32_t w)
{
    poa_arc_t *av; uint32_t an, k;
    an = poa_arc_n(pg, v); av = poa_arc_a(pg, v);
    for (k = 0; k < an; k++) {
        if(av[k].v == w) return (uint32_t)av[k].ul;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x33520e
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x335201
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x335215
jmp 0x335203
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3351cd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_ul_o(ul2ul_idx_t*, unsigned int, unsigned int, unsigned int, unsigned int)
ul2ul_t *get_ul_o(ul2ul_idx_t *idx, uint32_t qid, uint32_t is_q_ul, uint32_t tid, uint32_t is_t_ul)
{
    ul2ul_item_t *z = get_ul_ovlp(idx, qid, is_q_ul); uint64_t k;
    if(!is_t_ul) tid += idx->uln;
    for (k = 0; k < z->n; k++) {
        if(z->a[k].hid == tid) return &(z->a[k]);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0x3370e0
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3371a7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movl -0x1c(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3371f8
movq -0x28(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x3371e8
movq -0x28(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x337200
jmp 0x3371ea
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3371af
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: gen_integer_normalize(ul_resolve_t*)
void gen_integer_normalize(ul_resolve_t *uidx) 
{
    uint64_t k; ul2ul_idx_t *u2o = &(uidx->uovl); ul2ul_item_t *it;
    for (k = 0; k < u2o->uln; k++) {
        it = get_ul_ovlp(u2o, k, 1);
        if(!it) continue;
        assert(uidx->pstr.str.a[k].cn > 1);
        if(it->is_del) continue;
        integer_normalize_ovlp(uidx, k, it, u2o);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f0, %rax            # imm = 0x1F0
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x339a10
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3370e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x339993
jmp 0x3399ff
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x1, %eax
jle 0x3399b8
jmp 0x3399d7
leaq 0x5ea88(%rip), %rdi     # 0x398447
leaq 0x5c7f3(%rip), %rsi     # 0x3961b9
movl $0x1b46, %edx           # imm = 0x1B46
leaq 0x5ea90(%rip), %rcx     # 0x398462
callq 0x2130
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x3399e8
jmp 0x3399ff
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x337c40
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x339962
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: chimeric_integer_deal(ul_resolve_t*)
void chimeric_integer_deal(ul_resolve_t *uidx)
{
    uint64_t k; ul2ul_idx_t *u2o = &(uidx->uovl); ul2ul_item_t *it;
    kt_for(uidx->str_b.n_thread, worker_detect_chimeric, uidx, uidx->idx->n);
    for (k = 0; k < u2o->uln; k++) {
        it = get_ul_ovlp(u2o, k, 1);
        if(!it) continue;
        assert(uidx->pstr.str.a[k].cn > 1);
        integer_normalize_ovlp_purge(uidx, k, it, u2o);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f0, %rax            # imm = 0x1F0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x50(%rax), %rcx
leaq 0xb2(%rip), %rsi        # 0x33a840
callq 0x16d710
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x33a838
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3370e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x33a7cc
jmp 0x33a827
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x1, %eax
jle 0x33a7f1
jmp 0x33a810
leaq 0x5dc4f(%rip), %rdi     # 0x398447
leaq 0x5b9ba(%rip), %rsi     # 0x3961b9
movl $0x1c34, %edx           # imm = 0x1C34
leaq 0x5dcf9(%rip), %rcx     # 0x398504
callq 0x2130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x338360
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x33a79b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: worker_detect_chimeric(void*, long, int)
static void worker_detect_chimeric(void *data, long i, int tid) // callback for kt_for()
{
    ul_resolve_t *uidx = (ul_resolve_t *)data;
    integer_ml_t *sl = &(uidx->str_b); 
    integer_t *buf = &(sl->buf[tid]);
    ul2ul_item_t *it = get_ul_ovlp(&(uidx->uovl), i, 1);
    if(!it) return;
    assert(uidx->pstr.str.a[i].cn > 1);
    if(it->is_del) return;
    clip_integer_chimeric(uidx, i, it, &(uidx->uovl), buf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1d8, %rax            # imm = 0x1D8
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x328, %rcx, %rcx      # imm = 0x328
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3370e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x33a8a8
jmp 0x33a925
movq -0x20(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x1, %eax
jle 0x33a8cd
jmp 0x33a8ec
leaq 0x608c6(%rip), %rdi     # 0x39b19a
leaq 0x5b8de(%rip), %rsi     # 0x3961b9
movl $0x1c27, %edx           # imm = 0x1C27
leaq 0x608ce(%rip), %rcx     # 0x39b1b5
callq 0x2130
movq -0x38(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x33a8fd
jmp 0x33a925
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1f0, %rcx            # imm = 0x1F0
movq -0x30(%rbp), %r8
movl $0x1, %r9d
callq 0x339c20
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: double_check_gconnect(asg_t*, unsigned int, unsigned int, unsigned int)
uint32_t double_check_gconnect(asg_t *g, uint32_t v, uint32_t w, uint32_t v2w_d)
{
    asg_arc_t *av = asg_arc_a(g, v); uint32_t nv = asg_arc_n(g, v), k;
    for (k = 0; k < nv; k++) {
        if(av[k].del) continue;
        if(av[k].v == w) break;
    }
    if(k < nv) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x33b198
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x33b173
jmp 0x33b18d
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x33b18b
jmp 0x33b198
jmp 0x33b18d
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x33b150
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x33b1a9
movl $0x1, -0x4(%rbp)
jmp 0x33b1b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: rebuid_idx(ul_resolve_t*)
void rebuid_idx(ul_resolve_t *uidx)
{
    uint32_t k;
    free(uidx->idx->ridx.idx.a); free(uidx->idx->ridx.occ.a); 
    memset(&(uidx->idx->ridx), 0, sizeof((uidx->idx->ridx)));
    filter_ul_ug(uidx->l1_ug);
	gen_ul_vec_rid_t(uidx->idx, NULL, uidx->l1_ug);
    update_ug_arch_ul_mul(uidx->l1_ug);

    free(uidx->pstr.idx.a); free(uidx->pstr.occ.a); 
    for (k = 0; k < uidx->pstr.str.n; k++) {
        free(uidx->pstr.str.a[k].a);
    }
    free(uidx->pstr.str.a); 
    memset(&(uidx->pstr), 0, sizeof(uidx->pstr));
    init_ul_str_idx_t(uidx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2f1800
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2f0d10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2f11d0
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rdi
callq 0x2210
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x1c0(%rcx), %rax
jae 0x33d299
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x33d260
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
xorl %esi, %esi
movl $0x48, %edx
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x3271a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: shrink_uls(ul_resolve_t*)
void shrink_uls(ul_resolve_t *uidx)
{
    all_ul_t *uls = uidx->idx; uint64_t k, ul_n = uls->n; 
    for (k = 0; k < ul_n; k++) {
        // fprintf(stderr, "+[M::%s::k->%lu] ul_n::%lu, uls->n::%u\n", __func__, k, ul_n, uls->n);
        shrink_ul0(uls, &(uidx->pstr.str.a[k]), k, &(uidx->str_b.buf[0]), uidx->l1_ug);
        // fprintf(stderr, "-[M::%s::k->%lu] ul_n::%lu, uls->n::%u\n", __func__, k, ul_n, uls->n);
    }
    rebuid_idx(uidx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x33e9fa
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rsi
movq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x1d8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r8
callq 0x33d910
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x33e9ac
movq -0x8(%rbp), %rdi
callq 0x33d1c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: print_ul_seq(ul_resolve_t*, unsigned long)
void print_ul_seq(ul_resolve_t *uidx, uint64_t id)
{
    uint64_t i; ul_str_t *str = &(uidx->pstr.str.a[id]); ma_ug_t *ug = uidx->init_ug;
    fprintf(stderr, "%.*s\tid::%lu\t", (int32_t)uidx->idx->nid.a[id].n, 
                                                        uidx->idx->nid.a[id].a, id);
    for (i = 0; i < str->cn; i++) {
        fprintf(stderr, "utg%.6d%c(%c)\t", (((uint32_t)str->a[i])>>1)+1, 
        "lc"[ug->u.a[(((uint32_t)str->a[i])>>1)].circ], "+-"[(((uint32_t)str->a[i])&1)]);
    }
    fprintf(stderr,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x85593(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x10(%rbp), %r8
leaq 0x51d3c(%rip), %rsi     # 0x3907cb
movb $0x0, %al
callq 0x22a0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x33eb54
movq 0x8551f(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %edx
shrl %edx
addl $0x1, %edx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
shrl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x467f5(%rip), %rax     # 0x385303
movsbl (%rax,%rcx), %ecx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rsi
movq (%rax,%rsi,8), %rax
andl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x4436b(%rip), %rax     # 0x382e9b
movsbl (%rax,%rsi), %r8d
leaq 0x51c9d(%rip), %rsi     # 0x3907d9
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x33ea9e
movq 0x85485(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x47ec3(%rip), %rsi     # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: ul_re_correct(ul_resolve_t*, unsigned long)
void ul_re_correct(ul_resolve_t *uidx, uint64_t n_r)
{   
    // print_ul_seq(uidx, 2062); print_ul_seq(uidx, 2093);
    uint64_t k, occ, n_circle; ///uidx->str_b.n_thread = 1;
    for (k = 0; k < n_r; k++) {
        kt_for(uidx->str_b.n_thread, worker_integer_correction, uidx, uidx->idx->n);
        occ = clean_ul_re_correct_buf(uidx, 0, &n_circle);
        fprintf(stderr, "+[M::%s::round->%lu] # corrected UL reads::%lu, # circle UL reads::%lu\n", 
                                                                                __func__, k, occ, n_circle);
        kt_for(uidx->str_b.n_thread, worker_integer_update, uidx, uidx->str_b.n_thread);
        occ = clean_ul_re_correct_buf(uidx, 1, &n_circle);
        fprintf(stderr, "-[M::%s::round->%lu] # corrected UL reads::%lu, # circle UL reads::%lu\n", 
                                                                                __func__, k, occ, n_circle);
        rebuid_idx(uidx);
        // print_ul_seq(uidx, 2062); print_ul_seq(uidx, 2093);
        // exit(1);
    }

    shrink_uls(uidx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x33ec92
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x50(%rax), %rcx
leaq 0xe6(%rip), %rsi        # 0x33ecb0
callq 0x16d710
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdx
callq 0x33cf70
movq %rax, -0x20(%rbp)
movq 0x853f5(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0x59c1a(%rip), %rsi     # 0x39881b
leaq 0x59c5b(%rip), %rdx     # 0x398863
movb $0x0, %al
callq 0x22a0
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rcx
leaq 0xfe(%rip), %rsi        # 0x33ed30
callq 0x16d710
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x33cf70
movq %rax, -0x20(%rbp)
movq 0x8538c(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0x59c07(%rip), %rsi     # 0x398871
leaq 0x59bf2(%rip), %rdx     # 0x398863
movb $0x0, %al
callq 0x22a0
movq -0x8(%rbp), %rdi
callq 0x33d1c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x33eb98
movq -0x8(%rbp), %rdi
callq 0x33e980
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: worker_integer_correction(void*, long, int)
static void worker_integer_correction(void *data, long i, int tid) // callback for kt_for()
{
    ul_resolve_t *uidx = (ul_resolve_t *)data;
    integer_ml_t *sl = &(uidx->str_b); 
    integer_t *buf = &(sl->buf[tid]);
    // uc_block_t *uls; uint64_t uls_n; uint32_t v;
    // uint64_t *srt_a, srt_n, is_circle = ((uidx->psrt.idx.a[i]&((uint64_t)(0x100000000)))?1:0);
    // srt_a = uidx->psrt.srt.a + (uint32_t)uidx->psrt.idx.a[i]; srt_n = uidx->psrt.idx.a[i]>>33;
    // if(srt_n == 0) return;
    // integer_candidate(uidx, srt_a, srt_n, is_circle, buf);
    integer_candidate(uidx, buf, i, (asm_opt.purge_level_primary == 0?1:0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1d8, %rax            # imm = 0x1D8
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x328, %rcx, %rcx      # imm = 0x328
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movl %eax, %edx
leaq 0x85af1(%rip), %rax     # 0x3c47f8
movl 0x130(%rax), %r8d
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %r8d
cmovel %eax, %ecx
callq 0x336140
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: worker_integer_update(void*, long, int)
static void worker_integer_update(void *data, long i, int tid) // callback for kt_for()
{
    ul_resolve_t *uidx = (ul_resolve_t *)data;
    integer_ml_t *sl = &(uidx->str_b); 
    integer_t *buf = &(sl->buf[i]);///normally should be buf = &(sl->buf[tid])
    uint64_t k, l;
    for (k = 0, l = (uint64_t)-1; k <= buf->res_dump.n; k++) {
        if(k == buf->res_dump.n || (buf->res_dump.a[k]&((uint64_t)(0xffffffff))) == ((uint64_t)(0xffffffff))) {
            if(l != (uint64_t)-1 && k - l > 1) {
                update_integer_seq(uidx, buf, buf->res_dump.a[l]>>32, buf->res_dump.a + l + 1, k - l - 1, tid);
            }
            l = k;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1d8, %rax            # imm = 0x1D8
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
imulq $0x328, -0x10(%rbp), %rcx # imm = 0x328
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $-0x1, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x300(%rcx), %rax
ja 0x33ee4c
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x300(%rcx), %rax
je 0x33edcc
movq -0x30(%rbp), %rax
movq 0x310(%rax), %rcx
movq -0x38(%rbp), %rdx
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq (%rcx,%rdx,8), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x33ee39
cmpq $-0x1, -0x40(%rbp)
je 0x33ee31
movq -0x38(%rbp), %rax
subq -0x40(%rbp), %rax
cmpq $0x1, %rax
jbe 0x33ee31
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x310(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movl %eax, %edx
movq -0x30(%rbp), %rax
movq 0x310(%rax), %rcx
movq -0x40(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
addq $0x8, %rcx
movq -0x38(%rbp), %r8
subq -0x40(%rbp), %r8
subq $0x1, %r8
movl -0x14(%rbp), %r9d
callq 0x33b1c0
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x33ee3b
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x33ed7f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: append_utg_es(ul_resolve_t*)
void append_utg_es(ul_resolve_t *uidx)
{
    uint64_t k; ul2ul_idx_t *u2o = &(uidx->uovl); ul2ul_item_t *it;
    for (k = 0; k < u2o->uln; k++) {
        it = get_ul_ovlp(u2o, k, 1);
        if(!it) continue;
        assert(uidx->pstr.str.a[k].cn > 1);
        integer_append_ug_ovlp(uidx, k, it, u2o);
    }

    kt_for(uidx->str_b.n_thread, worker_integert_clean, uidx, u2o->tot);///all ul + ug

    for (k = 0; k < u2o->tot; k++) {
        it = get_ul_ovlp(u2o, ulg_id(*u2o, k), ulg_type(*u2o, k));
        if(!it) continue;
        integer_normalize_ovlp(uidx, k, it, u2o);
    }

    kt_for(uidx->str_b.n_thread, worker_integert_clean, uidx, u2o->tot);///all ul + ug
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f0, %rax            # imm = 0x1F0
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x33ef1f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3370e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x33eeb3
jmp 0x33ef0e
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x1, %eax
jle 0x33eed8
jmp 0x33eef7
leaq 0x59568(%rip), %rdi     # 0x398447
leaq 0x572d3(%rip), %rsi     # 0x3961b9
movl $0x1eef, %edx           # imm = 0x1EEF
leaq 0x599c7(%rip), %rcx     # 0x3988b9
callq 0x2130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x338570
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x33ee82
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0xe1(%rip), %rsi        # 0x33f020
callq 0x16d710
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x33efec
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x33ef86
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0x30(%rbp)
jmp 0x33ef8e
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %r8
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %r8, %rdx
cmovael %ecx, %eax
movslq %eax, %rdx
callq 0x3370e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x33efc4
jmp 0x33efdb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x337c40
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x33ef4c
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x14(%rip), %rsi        # 0x33f020
callq 0x16d710
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: worker_integert_clean(void*, long, int)
static void worker_integert_clean(void *data, long i, int tid) // callback for kt_for()
{
    ul_resolve_t *uidx = (ul_resolve_t *)data;
    ul2ul_item_t *it = get_ul_ovlp(&(uidx->uovl), ulg_id(uidx->uovl, (uint32_t)i), 
                                                            ulg_type(uidx->uovl, (uint32_t)i));
    if(!it) return;
    if((uint32_t)i >= uidx->uovl.uln) it->id = i;
    clean_srt_integer(uidx, i, it, &(uidx->uovl));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1f0, %rax            # imm = 0x1F0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %eax
movq -0x20(%rbp), %rcx
cmpq 0x208(%rcx), %rax
jb 0x33f073
movq -0x10(%rbp), %rax
movl %eax, %eax
movq -0x20(%rbp), %rcx
subq 0x208(%rcx), %rax
movq %rax, -0x38(%rbp)
jmp 0x33f07d
movq -0x10(%rbp), %rax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movl %eax, %eax
movl %eax, %edx
movq -0x20(%rbp), %rax
movq 0x208(%rax), %r8
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %r8, %rdx
cmovael %ecx, %eax
movslq %eax, %rdx
callq 0x3370e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x33f0ba
jmp 0x33f109
movq -0x10(%rbp), %rax
movl %eax, %eax
movq -0x20(%rbp), %rcx
cmpq 0x208(%rcx), %rax
jb 0x33f0eb
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x28(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1f0, %rcx            # imm = 0x1F0
callq 0x33a450
addq $0x40, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: remove_integert_containment(ul_resolve_t*, unsigned int)
void remove_integert_containment(ul_resolve_t *uidx, uint32_t keep_raw_utg)
{
    ul2ul_idx_t *u2o = &(uidx->uovl); ul2ul_item_t *o;
    uint64_t k, kn = keep_raw_utg?u2o->uln:u2o->tot; 
    for (k = 0; k < kn; k++) {
        o = get_ul_ovlp(u2o, ulg_id(*u2o, k), ulg_type(*u2o, k));
        if(!o) continue;
        integer_containment_purge(uidx, k, o, u2o, keep_raw_utg);
    }

    kt_for(uidx->str_b.n_thread, worker_integert_clean, uidx, u2o->tot);///all ul + ug
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f0, %rax            # imm = 0x1F0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x33f141
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x33f14d
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x33f1fd
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x33f193
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0x48(%rbp)
jmp 0x33f19b
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %r8
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %r8, %rdx
cmovael %ecx, %eax
movslq %eax, %rdx
callq 0x3370e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x33f1d1
jmp 0x33f1ec
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %r8d
callq 0x338f80
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x33f15d
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
leaq -0x1fd(%rip), %rsi      # 0x33f020
callq 0x16d710
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: print_integert_ovlp_stat(ul2ul_idx_t*)
void print_integert_ovlp_stat(ul2ul_idx_t *ul2)
{
    uint64_t i, k, occ_r = 0, occ_o = 0; ul2ul_item_t *o;
    for (i = 0; i < ul2->uln; i++) {
        o = get_ul_ovlp(ul2, ulg_id(*ul2, i), ulg_type(*ul2, i));
        if((!o) || (o->is_del)) continue;
        occ_r++;
        for (k = 0; k < o->n; k++) {
            if(o->a[k].is_del || o->a[k].is_ct || (!ulg_type(*ul2, o->a[k].hid))) continue;
            occ_o++;
        }
    }
    fprintf(stderr, "[M::%s::] # UL reads::%lu, # UL ovlps::%lu\n", __func__, occ_r, occ_o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x33f397
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x33f28e
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0x40(%rbp)
jmp 0x33f296
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r8
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %r8, %rdx
cmovael %ecx, %eax
movslq %eax, %rdx
callq 0x3370e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x33f2d9
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x33f2de
jmp 0x33f386
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x33f384
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movb 0x24(%rax), %al
shrb $0x6, %al
andb $0x1, %al
cmpb $0x0, %al
jne 0x33f365
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movb 0x24(%rax), %al
shrb $0x7, %al
cmpb $0x0, %al
jne 0x33f365
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovael %ecx, %eax
cmpl $0x0, %eax
jne 0x33f367
jmp 0x33f373
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x33f2f2
jmp 0x33f386
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x33f254
movq 0x84c42(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x5952c(%rip), %rsi     # 0x3988dc
leaq 0x59551(%rip), %rdx     # 0x398908
movb $0x0, %al
callq 0x22a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: output_integer_graph(ul_resolve_t*, ma_ug_t*, char const*, unsigned int)
void output_integer_graph(ul_resolve_t *uidx, ma_ug_t *iug, const char *nn, uint32_t is_seq)
{
    char* gfa_name = NULL; MALLOC(gfa_name, strlen(nn)+50);
	sprintf(gfa_name, "%s.integer.noseq.gfa", nn);
    FILE* fp = fopen(gfa_name, "w"); free(gfa_name);
	if (!fp) return;
    ma_integer_ug_print0(iug, uidx, 0, "itg", fp, is_seq);
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x32, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x574da(%rip), %rsi     # 0x3989c5
movb $0x0, %al
callq 0x2050
movq -0x28(%rbp), %rdi
leaq 0x57ed5(%rip), %rsi     # 0x3993d2
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2210
cmpq $0x0, -0x30(%rbp)
jne 0x341518
jmp 0x34153f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %r8
movl -0x1c(%rbp), %r9d
xorl %edx, %edx
leaq 0x574a9(%rip), %rcx     # 0x3989da
callq 0x3404d0
movq -0x30(%rbp), %rdi
callq 0x21a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: gen_srt_cov_interval(unsigned long*, unsigned long)
uint64_t gen_srt_cov_interval(uint64_t *b, uint64_t b_n)
{
    uint64_t i, m, start, end; int64_t dp, old_dp;
    radix_sort_srt64(b, b + b_n);
    for (i = m = 0, dp = 0, start = 0; i < b_n; ++i) {
        old_dp = dp;
        if (b[i]&1) --dp;
        else ++dp;

        if (old_dp < 1 && dp >= 1) {///old_dp < dp, b.a[j] is qs
            start = b[i]>>1;
        } else if (old_dp >= 1 && dp < 1){
            end = b[i]>>1;
            b[m] = start; b[m] <<= 32; b[m] += end; m++;
        } 
    }

    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x30ed90
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x34245b
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x3423b2
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3423be
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpq $0x1, -0x40(%rbp)
jge 0x3423e1
cmpq $0x1, -0x38(%rbp)
jl 0x3423e1
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq %rax
movq %rax, -0x28(%rbp)
jmp 0x342448
cmpq $0x1, -0x40(%rbp)
jl 0x342446
cmpq $0x1, -0x38(%rbp)
jge 0x342446
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
shlq $0x20, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x342448
jmp 0x34244a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x342378
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: ulg_seq_del(ma_ug_t*, unsigned int)
static inline void ulg_seq_del(ma_ug_t *ug, uint32_t s)
{
	uint32_t k; asg_t *g = ug->g;
	g->seq[s].del = 1;
	for (k = 0; k < 2; ++k) {
		uint32_t i, v = s<<1 | k;
		uint32_t nv = asg_arc_n(g, v);
		asg_arc_t *av = asg_arc_a(g, v);
		for (i = 0; i < nv; ++i) {
			av[i].del = 1;
			asg_arc_del(g, av[i].v^1, v^1, 1);
		}
	}
    free(ug->u.a[s].a); memset(&(ug->u.a[s]), 0, sizeof(ug->u.a[s]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,8), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
orl $0x80000000, %edx       # imm = 0x80000000
movl %edx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jae 0x342e0e
movl -0xc(%rbp), %eax
shll %eax
orl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x20(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x342dfe
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
xorl $0x1, %esi
movl -0x20(%rbp), %edx
xorl $0x1, %edx
movl $0x1, %ecx
callq 0x31bd30
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x342da3
jmp 0x342e00
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x342d4f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2100
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)