LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: is_ul_edge(ul_resolve_t*, unsigned int, unsigned int)
uint32_t is_ul_edge(ul_resolve_t *uidx, uint32_t uv, uint32_t uw)
{
    ma_ug_t *iug = uidx->uovl.i_ug; uint32_t qid, tid;
    qid = iug->u.a[uv>>1].a[((uv&1)?(0):(iug->u.a[uv>>1].n-1))]>>33;
    tid = iug->u.a[uw>>1].a[((uw&1)?(iug->u.a[uw>>1].n-1):(0))]>>33;
    if((qid != tid) && (!ulg_type(uidx->uovl, qid)) && (!ulg_type(uidx->uovl, tid))) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3441bd
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x3441dc
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x34423a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x344241
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x344241
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x3442aa
movl -0x24(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x208(%rax), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovael %ecx, %eax
cmpl $0x0, %eax
jne 0x3442aa
movl -0x28(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x208(%rax), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovael %ecx, %eax
cmpl $0x0, %eax
jne 0x3442aa
movl $0x0, -0x4(%rbp)
jmp 0x3442b1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_ul_spec_ovlp(ul2ul_idx_t*, unsigned long, unsigned long)
ul2ul_t* get_ul_spec_ovlp(ul2ul_idx_t *z, uint64_t qid, uint64_t tid)
{
    // uint64_t x = (is_qul?(qid):(qid+z->uln));
    if(z->item_idx[qid] == (uint32_t)-1) return NULL;
    ul2ul_item_t *o = &(z->a[z->item_idx[qid]]); uint64_t k;
    for (k = 0; k < o->cn; k++) {
        if(o->a[k].hid != tid) continue;
        return &(o->a[k]);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x3459bc
movq $0x0, -0x8(%rbp)
jmp 0x345a39
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x1c(%rcx), %ecx
cmpq %rcx, %rax
jae 0x345a31
movq -0x28(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpq -0x20(%rbp), %rax
je 0x345a0e
jmp 0x345a23
movq -0x28(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x345a39
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3459e5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: is_het_bridge(ul_resolve_t*, unsigned long*, long, long)
uint32_t is_het_bridge(ul_resolve_t *uidx, uint64_t *p_a, int64_t p_n, int64_t match_bound)
{
    bubble_type *bub = uidx->bub; int64_t z;
    for (z = match_bound; z >= 0 && IF_HOM((p_a[z]>>1), *bub); z--) {
        // if(is_debug){
        //     fprintf(stderr, "+[M::%s::] match_bound::%ld, p_n::%ld, (p_a[%ld]>>1)::%lu, IF_HOM::%u\n", 
        //     __func__, match_bound, p_n, z, (p_a[z]>>1), IF_HOM((p_a[z]>>1), *bub));
        // }
    } 
    if(z < 0) return 0;
    for (z = match_bound + 1; z < p_n && IF_HOM((p_a[z]>>1), *bub); z++) {
        // if(is_debug){
        //     fprintf(stderr, "-[M::%s::] match_bound::%ld, p_n::%ld, (p_a[%ld]>>1)::%lu, IF_HOM::%u\n", 
        //     __func__, match_bound, p_n, z, (p_a[z]>>1), IF_HOM((p_a[z]>>1), *bub));
        // }
    }
    // if(is_debug) {
    //     fprintf(stderr, "*[M::%s::] z::%ld, p_n::%ld\n", __func__, z, p_n);
    // }
    if(z >= p_n) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
jl 0x3482d5
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq %rcx
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
movq 0x80(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
seta %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3482de
jmp 0x3482ee
jmp 0x3482e0
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x348298
cmpq $0x0, -0x38(%rbp)
jge 0x3482fe
movl $0x0, -0x4(%rbp)
jmp 0x34837d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3a(%rbp)
jge 0x34834a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq %rcx
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rcx
movq 0x80(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
seta %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x348353
jmp 0x348363
jmp 0x348355
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x34830a
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x348376
movl $0x0, -0x4(%rbp)
jmp 0x34837d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: check_ulg_to_del(ul_resolve_t*, ma_ug_t*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, asg64_v*, asg64_v*)
uint32_t check_ulg_to_del(ul_resolve_t *uidx, ma_ug_t *ug, uint32_t v, uint32_t w, uint32_t kv, uint32_t kw, 
uint32_t max_ext, uint32_t max_ext_hifi, uint32_t topo_level, uint32_t collapse, asg64_v *b, asg64_v *ub)
{
    uint32_t to_del = 0;
    if(collapse) topo_level = 3; 
    if(topo_level == 0) {
        to_del = 1;
    } else if(topo_level == 2) {
        if (kv > 1 && kw > 1) to_del = 1;
    } else {
        if (kv > 1 && kw > 1) {
            to_del = 1;
        } else if (kw == 1) {
            if (usg_topocut_aux(uidx, ug, w^1, max_ext, max_ext_hifi, b, ub)) to_del = 1;                    
        } else if (kv == 1) {
            if (usg_topocut_aux(uidx, ug, v^1, max_ext, max_ext_hifi, b, ub)) to_del = 1;   
        }
    }

    return to_del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, 0x28(%rbp)
je 0x348fa6
movl $0x3, 0x20(%rbp)
cmpl $0x0, 0x20(%rbp)
jne 0x348fb8
movl $0x1, -0x24(%rbp)
jmp 0x349067
cmpl $0x2, 0x20(%rbp)
jne 0x348fd6
cmpl $0x1, -0x1c(%rbp)
jbe 0x348fd1
cmpl $0x1, -0x20(%rbp)
jbe 0x348fd1
movl $0x1, -0x24(%rbp)
jmp 0x349065
cmpl $0x1, -0x1c(%rbp)
jbe 0x348feb
cmpl $0x1, -0x20(%rbp)
jbe 0x348feb
movl $0x1, -0x24(%rbp)
jmp 0x349063
cmpl $0x1, -0x20(%rbp)
jne 0x349025
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
xorl $0x1, %edx
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %r8d
movq 0x30(%rbp), %r9
movq 0x38(%rbp), %rax
movq %rax, (%rsp)
callq 0x343240
cmpl $0x0, %eax
je 0x349023
movl $0x1, -0x24(%rbp)
jmp 0x349061
cmpl $0x1, -0x1c(%rbp)
jne 0x34905f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
xorl $0x1, %edx
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %r8d
movq 0x30(%rbp), %r9
movq 0x38(%rbp), %rax
movq %rax, (%rsp)
callq 0x343240
cmpl $0x0, %eax
je 0x34905d
movl $0x1, -0x24(%rbp)
jmp 0x34905f
jmp 0x349061
jmp 0x349063
jmp 0x349065
jmp 0x349067
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: worker_update_ul_arc_supports(void*, long, int)
static void worker_update_ul_arc_supports(void *data, long i, int tid) // callback for kt_for()
{
    ul_resolve_t *uidx = (ul_resolve_t *)data; integer_t *buf = &(uidx->str_b.buf[tid]);
    uint64_t *x = &(uidx->uovl.iug_tra->a[i]); asg_arc_t *ve = &(uidx->uovl.i_ug->g->arc[*x]);
    asg64_v b_v, b_r; uint64_t w_v, w_r;
    b_v.a = buf->u.a; b_v.n = buf->u.n; b_v.m = buf->u.m; 
    b_r.a = buf->o.a; b_r.n = buf->o.n; b_r.m = buf->o.m; 

    b_v.n = b_r.n = 0;
    get_ul_arc_supports(uidx, ve, &b_v, &b_r, 1, &w_v, &w_r);

    buf->u.a = b_v.a; buf->u.n = b_v.n; buf->u.m = b_v.m; 
    buf->o.a = b_r.a; buf->o.n = b_r.n; buf->o.m = b_r.m; 

    (*x) |= (w_v<<32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %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
movq 0x1d8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x328, %rcx, %rcx      # imm = 0x328
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x290(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x230(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movl $0x1, %r8d
leaq -0x70(%rbp), %r9
leaq -0x78(%rbp), %rax
movq %rax, (%rsp)
callq 0x348390
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x68(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x60(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x70(%rbp), %rcx
shlq $0x20, %rcx
movq -0x30(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_ug_integer_seq_occ(ul_resolve_t*, unsigned long*, unsigned long, asg64_v*)
uint64_t get_ug_integer_seq_occ(ul_resolve_t *uidx, uint64_t *u_a, uint64_t u_n, asg64_v *b)
{
    uint32_t bn = b->n, k, occ; ma_ug_t *raw = uidx->l1_ug;
    gen_ug_integer_seq_on_fly(uidx, u_a, u_n, b);
    for (k = bn, occ = 0; k < b->n; k++) occ += raw->u.a[b->a[k]>>1].n;
    b->n = bn;
    return occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x345a40
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x34b5c1
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x28(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x34b580
movl -0x24(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: ul_occ_check(ul_resolve_t*, ma_ug_t*, unsigned int, unsigned int, unsigned int, float, asg64_v*, asg64_v*)
uint32_t ul_occ_check(ul_resolve_t *uidx, ma_ug_t *ug, uint32_t qocc_ul, uint32_t qocc_hifi, uint32_t tv, float occ_rate, asg64_v *b, asg64_v *ub)
{
    uint32_t bn = b->n, z, tocc_ul, tocc_hifi, ul;
    get_ul_path_info(uidx, ug, tv, NULL, NULL, NULL, NULL, NULL, b);
    for (z = bn, tocc_ul = 0; z < b->n; z++) {
        get_iug_u_raw_occ(uidx, b->a[z]>>1, &ul, NULL); tocc_ul += ul;
    }
    tocc_hifi = get_ug_integer_seq_occ(uidx, b->a + bn, b->n - bn, ub);
    b->n = bn;
    if((qocc_ul <= (tocc_ul*occ_rate)) && (qocc_hifi <= (tocc_hifi*occ_rate))) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movss %xmm0, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %r9d
movq %r9, %rcx
movq %r9, %r8
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x344830
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x38(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x34b698
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x38(%rbp), %ecx
movq (%rax,%rcx,8), %rax
shrq %rax
movl %eax, %esi
leaq -0x44(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x37beb0
movl -0x44(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x34b653
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq 0x10(%rax), %rcx
movl -0x34(%rbp), %eax
leaq (%rcx,%rax,8), %rsi
subq %rax, %rdx
movq 0x10(%rbp), %rcx
callq 0x34b530
movl %eax, -0x40(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
cvtsi2ss %rax, %xmm1
movl -0x3c(%rbp), %eax
cvtsi2ss %rax, %xmm0
mulss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x34b706
movl -0x20(%rbp), %eax
cvtsi2ss %rax, %xmm1
movl -0x40(%rbp), %eax
cvtsi2ss %rax, %xmm0
mulss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x34b706
movl $0x1, -0x4(%rbp)
jmp 0x34b70d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: push_usg_t_node(usg_t*, unsigned long)
usg_seq_t *push_usg_t_node(usg_t *ng, uint64_t id)
{
    if(id >= ng->m) {
        uint64_t m = ng->m;
        kv_resize(usg_seq_t, *ng, id + 1); 
        memset(ng->a + m, 0, (ng->m - m)*(sizeof((*ng->a))));
    }
    if(id >= ng->n) ng->n = id + 1;

    return ng->a + id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x34d5b5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x34d58d
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x78, 0x10(%rax), %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x34d58f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0x78, -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
subq -0x18(%rbp), %rax
imulq $0x78, %rax, %rdx
xorl %esi, %esi
callq 0x2100
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x34d5d3
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x78, -0x10(%rbp), %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_usg_arc_mm(usg_t*, usg_arc_t*, usg_arc_mm_t**)
uint32_t get_usg_arc_mm(usg_t *g, usg_arc_t *z, usg_arc_mm_t **res)
{
    uint32_t v = z->ul>>32; (*res) = NULL;
    if(((uint32_t)z->idx) == 0) return 0;

    // fprintf(stderr, "[M::%s::] g->n::%u, v>>1::%u, v&1::%u, idx::%u, idx_n::%u, arc_mm.n::%u\n", __func__, 
    // (uint32_t)g->n, v>>1, v&1, (uint32_t)(z->idx>>32), (uint32_t)(z->idx), (uint32_t)(g->a[v>>1].arc_mm[v&1].n));

    (*res) = g->a[v>>1].arc_mm[v&1].a + (z->idx>>32);
    return ((uint32_t)z->idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, %eax
jne 0x35247f
movl $0x0, -0x4(%rbp)
jmp 0x3524d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
addq $0x40, %rax
movl -0x24(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x20, %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: is_junction_circle(usg_t*, unsigned int, unsigned int)
uint32_t is_junction_circle(usg_t *g, uint32_t v, uint32_t w)
{
    uint32_t k, nv, cov, op, cov_w; usg_arc_t *av;
    av = usg_arc_a(g, v); nv = usg_arc_n(g, v);

    for (k = 0; k < nv; k++){
        if(av[k].del) continue;
        if(av[k].v == (w^1)) return 1;///circle
        op = get_usg_unitig(g, av[k].v, &cov, NULL, NULL, NULL, NULL);
        if(op == LOOP || cov == (w^1)) return 1;///circle
        if(op == MUL_INPUT) {
            undel_arcs(g, cov, &cov_w);
            if(cov_w == (w^1)) return 1;///circle
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movl -0x14(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movl -0x14(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x352996
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x3528e1
jmp 0x352988
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl -0x18(%rbp), %ecx
xorl $0x1, %ecx
cmpl %ecx, %eax
jne 0x352908
movl $0x1, -0x4(%rbp)
jmp 0x35299d
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
leaq -0x24(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rcx
movq %r9, %r8
movq $0x0, (%rsp)
callq 0x37d4d0
movl %eax, -0x28(%rbp)
cmpl $0x7, -0x28(%rbp)
je 0x35294f
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
xorl $0x1, %ecx
cmpl %ecx, %eax
jne 0x352958
movl $0x1, -0x4(%rbp)
jmp 0x35299d
cmpl $0x3, -0x28(%rbp)
jne 0x352986
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x2c(%rbp), %rdx
callq 0x37d7e0
movl -0x2c(%rbp), %eax
movl -0x18(%rbp), %ecx
xorl $0x1, %ecx
cmpl %ecx, %eax
jne 0x352984
movl $0x1, -0x4(%rbp)
jmp 0x35299d
jmp 0x352986
jmp 0x352988
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3528b7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: check_hybrid_connect(usg_t*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
uint32_t check_hybrid_connect(usg_t *ng, uint32_t i_uid, uint32_t v, uint32_t vidx, uint32_t w, uint32_t widx)
{
    usg_arc_mm_t *z_a = NULL; uint32_t z_n, k;
    usg_arc_t *z = get_usg_arc(ng, v, w);
    if(!z) return 0;
    z_n = get_usg_arc_mm(ng, z, &z_a);
    if(!z_n) return 0;
    for (k = 0; k < z_n; k++) {
        if(z_a[k].uid != i_uid || z_a[k].off != vidx) continue;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x37d400
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3549c8
movl $0x0, -0x4(%rbp)
jmp 0x354a43
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x352440
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x3549eb
movl $0x0, -0x4(%rbp)
jmp 0x354a43
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x354a3c
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x354a26
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x354a28
jmp 0x354a31
movl $0x1, -0x4(%rbp)
jmp 0x354a43
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3549f2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: usg_arc_occ(usg_t*, unsigned int)
uint32_t usg_arc_occ(usg_t *ng, uint32_t v)
{
    usg_arc_t *p; uint32_t nv, kv, i;
    p = usg_arc_a(ng, v); nv = usg_arc_n(ng, v);
    for (i = kv = 0; i < nv; i++) {
        if(p[i].del) continue;
        kv++;
    }
    return kv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movl -0xc(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movl -0xc(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x354afe
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x354aea
jmp 0x354af3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x354ac7
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_ug_occ_v(unsigned int)
uint64_t get_ug_occ_v(uint32_t i_ug_occ)
{
    uint64_t v = (uint64_t)-1;
    if(!(i_ug_occ&((uint32_t)0x80000000))) return v;
    if(!(i_ug_occ&3)) return v;
    if((i_ug_occ&1)&&(i_ug_occ&2)) {
        v = (((i_ug_occ<<1)>>3)<<1);
        v <<= 32; v |= ((((i_ug_occ<<1)>>3)<<1)|1);
        return v;
    }
    if(i_ug_occ&1) {
        v <<= 32; v |= (((i_ug_occ<<1)>>3)<<1);
        return v;
    }
    if(i_ug_occ&2) {
        v <<= 32; v |= ((((i_ug_occ<<1)>>3)<<1)|1);
        return v;
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $-0x1, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
jne 0x355db9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x355e99
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x355dd1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x355e99
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x355e24
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x355e24
movl -0xc(%rbp), %eax
shll %eax
shrl $0x3, %eax
shll %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shll %eax
shrl $0x3, %eax
shll %eax
orl $0x1, %eax
movl %eax, %eax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x355e99
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x355e59
movq -0x18(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shll %eax
shrl $0x3, %eax
shll %eax
movl %eax, %eax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x355e99
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x355e91
movq -0x18(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shll %eax
shrl $0x3, %eax
shll %eax
orl $0x1, %eax
movl %eax, %eax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x355e99
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: ava_pass_unique_bridge(unsigned long*, unsigned long*, unsigned long, unsigned long)
uint32_t ava_pass_unique_bridge(uint64_t *idx, uint64_t *integer_seq, uint64_t s, uint64_t e)
{
    uint64_t k;
    for (k = s + 1; k < e; k++) {///note: here is [s, e]
        if((idx[integer_seq[k]]&((uint64_t)0x8000000000000000)) || 
                        (idx[integer_seq[k]^1]&((uint64_t)0x8000000000000000))) {
            return 0;
        }
    }
    if((idx[integer_seq[s]]&((uint64_t)0x8000000000000000)) || 
                        (idx[integer_seq[e]^1]&((uint64_t)0x8000000000000000))) {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x35718f
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rdx
movq (%rax,%rdx,8), %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x357176
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rdx
movq (%rax,%rdx,8), %rdx
xorq $0x1, %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
je 0x35717f
movl $0x0, -0x4(%rbp)
jmp 0x3571eb
jmp 0x357181
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x357120
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
movq (%rax,%rdx,8), %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x3571db
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax,%rdx,8), %rdx
xorq $0x1, %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
je 0x3571e4
movl $0x0, -0x4(%rbp)
jmp 0x3571eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: prt_thread_info(unsigned long*, unsigned long, unsigned long*, unsigned long, char const*)
void prt_thread_info(uint64_t *interval, uint64_t interval_n, uint64_t *cluster, uint64_t cluster_n, 
const char *nn)
{
    char* gfa_name = NULL; MALLOC(gfa_name, strlen(nn)+70);
    sprintf(gfa_name, "%s.thread_info.log", nn);
    FILE* fp = fopen(gfa_name, "w"); free(gfa_name);
    if (!fp) return;
    uint64_t k;
    if(interval) {
        for (k = 0; k < interval_n; k++) fprintf(fp,"it_val::[%lu, %u)\n", interval[k]>>32, (uint32_t)interval[k]);
    }
    if(cluster) {
        for (k = 0; k < cluster_n; k++) fprintf(fp,"cluster::%lu\tit_id::%u)\n", cluster[k]>>32, (uint32_t)cluster[k]);
    }
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x46, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x3f0cc(%rip), %rsi     # 0x3998ac
movb $0x0, %al
callq 0x2050
movq -0x30(%rbp), %rdi
leaq 0x3ebe0(%rip), %rsi     # 0x3993d2
callq 0x2200
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2210
cmpq $0x0, -0x38(%rbp)
jne 0x35a810
jmp 0x35a8cb
cmpq $0x0, -0x8(%rbp)
je 0x35a869
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x35a867
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
shrq $0x20, %rdx
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
leaq 0x3f06d(%rip), %rsi     # 0x3998bf
movb $0x0, %al
callq 0x22a0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x35a81f
jmp 0x35a869
cmpq $0x0, -0x18(%rbp)
je 0x35a8c2
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x35a8c0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
shrq $0x20, %rdx
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
leaq 0x3f027(%rip), %rsi     # 0x3998d2
movb $0x0, %al
callq 0x22a0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x35a878
jmp 0x35a8c2
movq -0x38(%rbp), %rdi
callq 0x21a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: prt_intg_info(unsigned long*, unsigned long, unsigned long*, char const*)
void prt_intg_info(uint64_t *int_idx, uint64_t int_idx_n, uint64_t *int_a, const char *nn)
{
    char* gfa_name = NULL; MALLOC(gfa_name, strlen(nn)+70);
    sprintf(gfa_name, "%s.intg_info.log", nn);
    FILE* fp = fopen(gfa_name, "w"); free(gfa_name);
    if (!fp) return;
    uint64_t k, i, s, e;
    for (i = 0; i < int_idx_n; i++) {///scan all integer contigs
        s = int_idx[i]>>32; e = s + ((uint32_t)int_idx[i]); 
        assert(e > s + 1);//the length is at least 2
        fprintf(fp,"idx::[%lu, %lu)\n", s, e);
        for (k = s; k < e; k++) {
            fprintf(fp,"%lu\n", int_a[k]);
        }
    }
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x46, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3efbf(%rip), %rsi     # 0x3998eb
movb $0x0, %al
callq 0x2050
movq -0x28(%rbp), %rdi
leaq 0x3ea94(%rip), %rsi     # 0x3993d2
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2210
cmpq $0x0, -0x30(%rbp)
jne 0x35a95c
jmp 0x35aa45
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x35aa3c
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x35a9b2
jmp 0x35a9d1
leaq 0x3ef43(%rip), %rdi     # 0x3998fc
leaq 0x3b7f9(%rip), %rsi     # 0x3961b9
movl $0x3219, %edx           # imm = 0x3219
leaq 0x3ef3a(%rip), %rcx     # 0x399906
callq 0x2130
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq 0x3ef65(%rip), %rsi     # 0x399949
movb $0x0, %al
callq 0x22a0
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x35aa29
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x32ace(%rip), %rsi     # 0x38d4e2
movb $0x0, %al
callq 0x22a0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x35a9f3
jmp 0x35aa2b
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x35a964
movq -0x30(%rbp), %rdi
callq 0x21a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: ava_pass_unique_bridge_cov(ul_resolve_t*, usg_t*, asg64_v*, unsigned long, unsigned long, unsigned long*, unsigned long)
uint32_t ava_pass_unique_bridge_cov(ul_resolve_t *uidx, usg_t *g, asg64_v *b64, uint64_t g_s, uint64_t g_e, uint64_t *integer_seq, uint64_t tip_l)
{
    if((tip_l == 0) && (g_e - g_s == 1)) return 1; ///if only one path, go through in anyway 
    uint64_t i, is_del = 0; unique_bridge_check_t uaux;

    uaux.uidx = uidx; uaux.integer_seq = integer_seq; 
    uaux.gidx = b64->a + g_s; uaux.gidx_n = g_e - g_s;
    uaux.interval_idx = b64->a; uaux.ng = g;
    ///if tip_l == 0, it is more likely to be right, so give more chance by double checking
    // if(!tip_l) uaux.is_double_check = 1;
    // else uaux.is_double_check = 0;

    kt_for(uidx->str_b.n_thread, worker_unique_bridge_check_s, (&uaux), g_e-g_s);///seq->n > 1

    for (i = g_s; i < g_e; i++) {///available intervals within the same cluster
        if(b64->a[i]&((uint64_t)0x8000000000000000)) {
            b64->a[i] -= ((uint64_t)0x8000000000000000); is_del = 1;
        }
    }
    return (!is_del);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, 0x10(%rbp)
jne 0x35c4d8
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cmpq $0x1, %rax
jne 0x35c4d8
movl $0x1, -0x4(%rbp)
jmp 0x35c5db
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rax
movl %eax, %edi
movq -0x30(%rbp), %rcx
subq -0x28(%rbp), %rcx
leaq 0x9e(%rip), %rsi        # 0x35c5f0
leaq -0xb0(%rbp), %rdx
callq 0x16d710
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x35c5c9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x40(%rbp), %rdx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
je 0x35c5b9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
subq %rsi, %rdx
movq %rdx, (%rax,%rcx,8)
movq $0x1, -0x48(%rbp)
jmp 0x35c5bb
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x35c566
cmpq $0x0, -0x48(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: prt_sub_integer_path(asg64_v*, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)
void prt_sub_integer_path(asg64_v *res, uint64_t it, uint64_t w0, uint64_t w1, uint64_t z_n, uint64_t z)
{
    uint64_t k;
    fprintf(stderr, "(it::%lu) res->n::%u, w0::%lu, w1::%lu, z_n::%lu, z::%lu\n", it, (uint32_t)res->n, 
    w0, w1, z_n, z);
    for (k = 0; k < res->n; k++) {
        fprintf(stderr, "(it::%lu) utg%.6dl,", it, (int32_t)(res->a[k]>>1)+1);
    }
    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
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 0x61c29(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x30(%rbp), %rax
leaq 0x37d17(%rip), %rsi     # 0x39a0f5
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x22a0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x362445
movq 0x61bd6(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq %rax
movl %eax, %ecx
addl $0x1, %ecx
leaq 0x37cff(%rip), %rsi     # 0x39a12f
movb $0x0, %al
callq 0x22a0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3623f6
movq 0x61b94(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x245d2(%rip), %rsi     # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: debug_prt_renew_aln(usg_t*, unsigned long*, unsigned long, unsigned long*, unsigned long, asg64_v*, unsigned long*)
void debug_prt_renew_aln(usg_t *ng, uint64_t *int_idx, uint64_t int_idx_n, uint64_t *int_a, uint64_t int_an, asg64_v *b64, uint64_t *ridx)
{
    uint64_t k, s, e, i;
    for (i = 0; i < int_idx_n; i++) {///scan all integer contigs
        s = int_idx[i]>>32; e = s + ((uint32_t)int_idx[i]); assert(e > s + 1);//the length is at least 2
        fprintf(stderr, "\n[M::%s::] occ::%lu\n", __func__, e - s);
        for (k = s; k <= e; k++) {
            // fprintf(stderr, "utg%.6dl(%c),", (int32_t)(int_a[k]>>1)+1, "+-"[int_a[k]&1]);
            fprintf(stderr, "utg%.6dl,", (int32_t)(int_a[k]>>1)+1);
        }
        fprintf(stderr, "\n");
    }
}

// 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 $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x363d65
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x50(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x363caa
jmp 0x363cc9
leaq 0x35c4b(%rip), %rdi     # 0x3998fc
leaq 0x32501(%rip), %rsi     # 0x3961b9
movl $0x3816, %edx           # imm = 0x3816
leaq 0x36732(%rip), %rcx     # 0x39a3f6
callq 0x2130
movq 0x60310(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x48(%rbp), %rcx
subq -0x40(%rbp), %rcx
leaq 0x36779(%rip), %rsi     # 0x39a45b
leaq 0x36787(%rip), %rdx     # 0x39a470
movb $0x0, %al
callq 0x22a0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
ja 0x363d3c
movq 0x602d7(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq %rax
movl %eax, %edx
addl $0x1, %edx
leaq 0x36412(%rip), %rsi     # 0x39a139
movb $0x0, %al
callq 0x22a0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x363cf8
movq 0x6029d(%rip), %rax     # 0x3c3fe0
movq (%rax), %rdi
leaq 0x22cdb(%rip), %rsi     # 0x386a28
movb $0x0, %al
callq 0x22a0
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x363c5c
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: reset_scaf_node_uinfo_srt_t(usc_t*, long, long, long*)
uint64_t reset_scaf_node_uinfo_srt_t(usc_t *z, int64_t min_arc_len, int64_t scaf_len, int64_t *nlen)
{
    (*nlen) = scaf_len + (min_arc_len<<1);
    if(z->ulid == ((uint32_t)-1)) return 0;///a scaffold node
    if(z->raw_eof + min_arc_len <= z->raw_sof) {///has an overlap longer than min_arc_len; 
        return 1;///a scaffold node; no need this node, could directly use existing nodes
    }
    int64_t s, e;
    s = z->raw_sof; e = z->raw_eof; 
    (*nlen) = (min_arc_len<<1) + (e - s);  ///(e - s)>=(-min_arc_len)
    return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
shlq %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
jne 0x36549d
movq $0x0, -0x8(%rbp)
jmp 0x3654f5
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jg 0x3654be
movq $0x1, -0x8(%rbp)
jmp 0x3654f5
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
shlq %rcx
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq $0x2, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: reload_uu(all_ul_t*, ma_ug_t*, char*, char const*)
void reload_uu(all_ul_t *x, ma_ug_t *raw_g, char* file_name, const char *bin_file)
{
    char* gfa_name = NULL; MALLOC(gfa_name, strlen(asm_opt.output_file_name)+50);
	sprintf(gfa_name, "%s.%s", asm_opt.output_file_name, bin_file);
    clear_all_ul_t(x);
    load_all_ul_t(x, gfa_name, &R_INF, raw_g);
    // filter_ul_ug(raw_g);//no filter since we would like to use all alignments
    gen_ul_vec_rid_t(x, NULL, raw_g);
    free(gfa_name);
}

// 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 $0x0, -0x28(%rbp)
leaq 0x5d6d1(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x32, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x5d6a9(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rcx
leaq 0x22adf(%rip), %rsi     # 0x389c3d
movb $0x0, %al
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x300d10
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x5e14f(%rip), %rdx     # 0x3c52d0
callq 0x2fd8d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2f0d10
movq -0x28(%rbp), %rdi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: fill_scaffolds(usc_t*, unsigned long, ma_ug_t*, long, char const*)
void fill_scaffolds(usc_t *a, uint64_t a_n, ma_ug_t *raw_g, int64_t min_arc_len, const char *bin_file)
{   
    scaf_mul_t ss; uint32_t k, occ = 0;
    reload_uu(&UL_INF, raw_g, asm_opt.output_file_name, bin_file);
    // reload_uovl(&UL_INF, asm_opt.output_file_name);
    // filter_ul_ug(raw_g);
    // free(UL_INF.ridx.idx.a); UL_INF.ridx.idx.n = UL_INF.ridx.idx.m = 0;
    // free(UL_INF.ridx.occ.a); UL_INF.ridx.occ.n = UL_INF.ridx.occ.m = 0;
    // gen_ul_vec_rid_t(&UL_INF, NULL, raw_g);
    ss.a = a; ss.a_n = a_n; ss.ug = raw_g;
    kt_for(asm_opt.thread_num, gen_scaffold_id, &ss, a_n);
    for (k = 0; k < a_n; k++) {
        if(a[k].ulid == ((uint32_t)-1)) continue;
        // if(a[k].raw_eof + min_arc_len <= a[k].raw_sof) {///has an overlap longer than min_arc_len; 
        if(a[k].raw_eof <= a[k].raw_sof) {
            continue;///no need ul, could directly use hifi
        }
        // if(a[k].raw_eof <= a[k].raw_sof) continue;///no need UL reads
        // fprintf(stderr, "[M::%s] ulid::%u(%c), dd::%u\n", 
        // __func__, a[k].ulid>>1, "+-"[a[k].ulid&1], UL_INF.a[a[k].ulid>>1].dd);
        UL_INF.a[a[k].ulid>>1].dd = 4;///load
        occ++;
    }

    // fprintf(stderr, "[M::%s] occ::%u\n", __func__, occ);
    if(occ) load_scaf_base(&UL_INF, asm_opt.output_file_name, bin_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x5d61a(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rcx
leaq 0x5e1cb(%rip), %rdi     # 0x3c53b8
callq 0x367100
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x5d5e7(%rip), %rax     # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x10(%rbp), %rcx
leaq 0xc1(%rip), %rsi        # 0x3672e0
leaq -0x40(%rbp), %rdx
callq 0x16d710
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpq -0x10(%rbp), %rax
jae 0x3672b6
movq -0x8(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x1, 0x4(%rax)
jne 0x36724e
jmp 0x3672a8
movq -0x8(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
movl -0x44(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
ja 0x367274
jmp 0x3672a8
leaq 0x5e13d(%rip), %rax     # 0x3c53b8
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movl -0x44(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl 0x4(%rcx), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movb $0x4, 0x50(%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x36722f
cmpl $0x0, -0x48(%rbp)
je 0x3672d7
leaq 0x5d535(%rip), %rax     # 0x3c47f8
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rdx
leaq 0x5e0e6(%rip), %rdi     # 0x3c53b8
callq 0x364e80
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)