LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: gen_spec_rc_edge(asg_t*, ug_opt_t*, unsigned int, unsigned int, asg_arc_t*, ma_hit_t**)
int32_t gen_spec_rc_edge(asg_t *rg, ug_opt_t *uopt, uint32_t v, uint32_t w, asg_arc_t *t, ma_hit_t **te)
{
    uint32_t k, qn, tn; int32_t r; ma_hit_t_alloc *s = &(uopt->reverse_sources[v>>1]); asg_arc_t p;
    for (k = 0; k < s->length; k++) {
        qn = Get_qn(s->buffer[k]); tn = Get_tn(s->buffer[k]);
        if(tn != (w>>1)) continue;
        r = ma_hit2arc(&(s->buffer[k]), rg->seq[qn].len, rg->seq[tn].len, uopt->max_hang, asm_opt.max_hang_rate, uopt->min_ovlp, &p);
        if(r < 0) continue;
        if((p.ul>>32) != v || p.v != w) continue;
        *t = p; t->ou = 0; if(te) (*te) = &(s->buffer[k]);
        return 1;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x48(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x36801d
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
shrq $0x20, %rax
movl %eax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl -0x20(%rbp), %ecx
shrl %ecx
cmpl %ecx, %eax
je 0x367f32
jmp 0x36800f
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl -0x34(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x38(%rbp), %ecx
movl (%rax,%rcx,8), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x3c(%rbp), %ecx
movl (%rax,%rcx,8), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rax
movl 0x40(%rax), %ecx
leaq 0x5c87f(%rip), %rax     # 0x3c47f8
movss 0x158(%rax), %xmm0
movq -0x18(%rbp), %rax
movl 0x44(%rax), %r8d
leaq -0x60(%rbp), %r9
callq 0x31a080
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jge 0x367f9d
jmp 0x36800f
movq -0x60(%rbp), %rax
shrq $0x20, %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jne 0x367fb5
movl -0x58(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x367fb7
jmp 0x36800f
movq -0x28(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movw 0x10(%rax), %cx
andw $0xc000, %cx            # imm = 0xC000
orw $0x0, %cx
movw %cx, 0x10(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x368006
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movl -0x34(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x368024
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x367edf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: push_scaff_node(ma_hit_t_alloc*, unsigned long, unsigned long, unsigned long, asg_t*)
void push_scaff_node(ma_hit_t_alloc *src, uint64_t v, uint64_t w, uint64_t ol, asg_t *ng)
{
    uint64_t vl = ng->seq[v>>1].len, wl = ng->seq[w>>1].len; 
    ma_hit_t arc, arc1;
    arc.qns = (v>>1)<<32; 
    if(!(v&1)) {
        arc.qns += vl - ol; arc.qe = vl;
    } else {
        arc.qns += 0; arc.qe = ol;
    }
    arc.tn = w>>1;
    if(!(w&1)) {
        arc.ts = 0; arc.te = ol;
    } else {
        arc.ts = wl - ol; arc.te = wl;
    }

    arc.rev = (v^w)&1; arc.el = 0;
    arc.ml = arc.no_l_indel = arc.bl = 0;

    add_ma_hit_t_alloc(&(src[v>>1]), &arc);
    set_reverse_overlap(&arc1, &arc);
    add_ma_hit_t_alloc(&(src[w>>1]), &arc1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
movl (%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
movl (%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
shrq %rax
shlq $0x20, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x3685bf
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x58(%rbp)
jmp 0x3685d2
movq -0x60(%rbp), %rax
addq $0x0, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rax
shrq %rax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x3685fa
movl $0x0, -0x50(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x4c(%rbp)
jmp 0x36860c
movq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
xorq -0x18(%rbp), %rax
andq $0x1, %rax
movl %eax, %eax
movl %eax, %ecx
movq -0x48(%rbp), %rax
andq $0x1, %rcx
shlq $0x1f, %rcx
movabsq $-0x80000001, %rdx      # imm = 0xFFFFFFFF7FFFFFFF
andq %rdx, %rax
orq %rcx, %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movabsq $-0x7fffffff00000001, %rax # imm = 0x80000000FFFFFFFF
andq -0x48(%rbp), %rax
orq $0x0, %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x3f(%rbp)
movq -0x48(%rbp), %rax
andq $-0x40000001, %rax      # imm = 0xBFFFFFFF
orq $0x0, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0xcd340
leaq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xce230
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
shrq %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0xcd340
addq $0x90, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: prt_usg_t(ul_resolve_t*, usg_t*, char const*)
void prt_usg_t(ul_resolve_t *uidx, usg_t *ng, const char *cmd)
{
    ma_ug_t *ug = gen_debug_hybrid_ug(uidx, ng);
    print_debug_gfa(uidx->sg, ug, uidx->uopt->coverage_cut, cmd, 
    uidx->uopt->sources, uidx->uopt->ruIndex, uidx->uopt->max_hang, uidx->uopt->min_ovlp, 0, 0, 0);
    ma_ug_destroy(ug);
    // exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36bc00
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x40(%rax), %r10d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x44(%rax), %eax
xorl %r11d, %r11d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
callq 0x115910
movq -0x20(%rbp), %rdi
callq 0xcd6f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: gen_hybrid_ug(ul_resolve_t*, usg_t*)
ma_ug_t *gen_hybrid_ug(ul_resolve_t *uidx, usg_t *ng)
{
    // fprintf(stderr, "[M::%s::] ng->n::%u\n", __func__, (uint32_t)ng->n);
    ma_ug_t *ug = ma_ug_hybrid_gen(ng); 
    // fprintf(stderr, "[M::%s::] ug->g->n_seq::%u\n", __func__, (uint32_t)ug->g->n_seq);
    uint32_t i; ma_utg_t *u; kvec_asg_arc_t_warp e; kv_init(e.a); e.i = 0;
    for (i = 0; i < ug->u.n; i++) {
        ug->g->seq[i].c = PRIMARY_LABLE;
        u = &(ug->u.a[i]);
        if(u->m == 0) continue;
        // fprintf(stderr, "+[M::%s::] i::%u\n", __func__, i);
        merge_hybrid_utg_content(u, uidx->l1_ug, uidx->sg, ng, &e);
        // fprintf(stderr, "-[M::%s::] i::%u\n", __func__, i);
        ug->g->seq[i].len = u->len;
    }
    kv_destroy(e.a);
    return ug;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x359c70
movq %rax, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x36ef18
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movb $0x0, 0x4(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x36eeba
jmp 0x36ef0a
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rcx
leaq -0x48(%rbp), %r8
callq 0x361380
movq -0x28(%rbp), %rax
movl (%rax), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,8), %edx
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
andl $0x80000000, %edx       # imm = 0x80000000
orl %esi, %edx
movl %edx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36ee74
movq -0x38(%rbp), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: gen_utg_telo(ma_utg_t*, telo_end_t*)
uint32_t gen_utg_telo(ma_utg_t *u, telo_end_t *te)
{
    uint32_t i;
    for (i = 0; i < u->n; ++i) {
        if(te->hh[u->a[i]>>33]) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x36ef86
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl -0x1c(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x21, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x36ef79
movl $0x1, -0x4(%rbp)
jmp 0x36ef8d
jmp 0x36ef7b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36ef43
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: renew_ul2_utg(ul_resolve_t*)
void renew_ul2_utg(ul_resolve_t *uidx)
{
    ul2ul_idx_t *z = &(uidx->uovl);
    if(uidx->uovl.cc.iug_a) {
        uint32_t k;
        for (k = 0; k < z->i_ug->u.n; k++) free(uidx->uovl.cc.iug_a[k].a);
    }
    renew_utg(&(z->i_ug), z->i_g, NULL); 
    free(z->i_ug->g->seq_vis); CALLOC(z->i_ug->g->seq_vis, z->i_ug->g->n_seq*2);
    renew_u2g_cov(uidx, uidx->uopt->te); 
    renew_u2g_bg(uidx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f0, %rax            # imm = 0x1F0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x260(%rax)
je 0x37068a
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x370688
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x37064f
jmp 0x37068a
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6030
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
shll %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rsi
callq 0x372800
movq -0x8(%rbp), %rdi
callq 0x373160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_ulg_spec_ovlp(ul_resolve_t*, unsigned long, unsigned long)
ul2ul_t* get_ulg_spec_ovlp(ul_resolve_t *uidx, uint64_t uv, uint64_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(uidx->uovl.item_idx[qid] == (uint32_t)-1) return NULL;
    ul2ul_item_t *o = &(uidx->uovl.a[uidx->uovl.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 0x230(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x371912
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0x371931
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x371992
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x371999
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x371999
movq -0x58(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movl -0x2c(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x3719ce
movq $0x0, -0x8(%rbp)
jmp 0x371a50
movq -0x10(%rbp), %rax
movq 0x1f0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x220(%rcx), %rcx
movl -0x2c(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movl 0x1c(%rcx), %ecx
cmpq %rcx, %rax
jae 0x371a48
movq -0x38(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x40(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x30(%rbp), %eax
je 0x371a25
jmp 0x371a3a
movq -0x38(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x40(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x371a50
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x3719fd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: worker_integer_postprecess(void*, long, int)
static void worker_integer_postprecess(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);
    // 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_gen_ovlp(uidx, buf, i, it, uidx->uovl.uln);
}

// 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 0x374a88
jmp 0x374af1
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 0x374aad
jmp 0x374acc
leaq 0x266e6(%rip), %rdi     # 0x39b19a
leaq 0x216fe(%rip), %rsi     # 0x3961b9
movl $0x1b36, %edx           # imm = 0x1B36
leaq 0x26924(%rip), %rcx     # 0x39b3eb
callq 0x2130
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x208(%rax), %rax
movl %eax, %r8d
callq 0x337210
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: str_occ_w(ul_str_t*, ul_vec_t*, ma_ug_t*)
uint64_t str_occ_w(ul_str_t *str, ul_vec_t *raw, ma_ug_t *ug)
{
    uint64_t occ, k; uc_block_t *z;
    for (k = occ = 0; k < str->cn; k++) {
        z = &(raw->bb.a[str->a[k]>>32]);
        assert(((z->hid<<1)+z->rev)==((uint32_t)str->a[k]));
        occ += ug_occ_w(z->ts, z->te, &(ug->u.a[z->hid]));
    }
    return occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x37512b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
shll %eax
movq -0x30(%rbp), %rcx
movb 0x20(%rcx), %cl
shrb $0x5, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl %ecx, %eax
jne 0x3750c7
jmp 0x3750e6
leaq 0x25de1(%rip), %rdi     # 0x39aeaf
leaq 0x210e4(%rip), %rsi     # 0x3961b9
movl $0x41f3, %edx           # imm = 0x41F3
leaq 0x25dfa(%rip), %rcx     # 0x39aedb
callq 0x2130
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x30(%rbp), %rax
movl (%rax), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdx
callq 0x327090
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x375054
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: gen_cul_g_t(ul_resolve_t*)
void gen_cul_g_t(ul_resolve_t *uidx)
{
    ma_ug_t *ug = uidx->l1_ug; uint64_t k; ul_str_idx_t *str_idx = &(uidx->pstr);
    CALLOC(uidx->cg, 1);
    uidx->cg->n[0] = uidx->idx->n; uidx->cg->n[1] = ug->g->n_seq; 
    uidx->cg->tot = uidx->cg->n[0] + uidx->cg->n[1];
    uidx->cg->g = asg_init();
    for (k = 0; k < uidx->cg->tot; k++) {
        if(k < uidx->cg->n[0]) {
            asg_seq_set(uidx->cg->g, k, str_occ_w(&(str_idx->str.a[k]), &(uidx->idx->a[k]), ug), 
                                                                        ((str_idx->str.a[k].cn>1)?0:1));
        } else {
            asg_seq_set(uidx->cg->g, k, ug->u.a[k-uidx->cg->n[0]].n, 0);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x190, %rax            # imm = 0x190
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1e8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
addq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rcx, 0x18(%rax)
callq 0xcd150
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rcx, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1e8(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jae 0x375316
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1e8(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3752c3
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x48(%rax), %rsi
imulq $0x58, -0x18(%rbp), %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x375030
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movl %eax, %edx
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x1, %r8d
cmovgl %eax, %ecx
callq 0xcd8f0
jmp 0x375303
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x1e8(%rdx), %rdx
subq 0x8(%rdx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %edx
xorl %ecx, %ecx
callq 0xcd8f0
jmp 0x375305
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x37520c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: init_ulg_opt_t(ulg_opt_t*, ug_opt_t*, long, double, double, double, double, double, long, long, bub_label_t*, unsigned int)
void init_ulg_opt_t(ulg_opt_t *z, ug_opt_t *uopt, int64_t clean_round, 
double min_path_drop_ratio, double max_path_drop_ratio,
double min_ovlp_drop_ratio, double max_ovlp_drop_ratio, double hom_check_drop_rate, 
int64_t max_tip, int64_t max_tip_hifi, bub_label_t *b_mask_t, uint32_t is_trio)
{
    z->tipsLen = uopt->tipsLen;
    z->tip_drop_ratio = uopt->tip_drop_ratio;
    z->stops_threshold = uopt->stops_threshold;
    z->chimeric_rate = uopt->chimeric_rate;
    z->drop_ratio = uopt->drop_ratio;


    z->b_mask_t = b_mask_t;
    z->clean_round = clean_round;
    z->min_path_drop_ratio = min_path_drop_ratio;
    z->max_path_drop_ratio = max_path_drop_ratio;
    z->min_ovlp_drop_ratio = min_ovlp_drop_ratio;
    z->max_ovlp_drop_ratio = max_ovlp_drop_ratio;
    z->hom_check_drop_rate = hom_check_drop_rate;
    z->max_tip = max_tip;
    z->max_tip_hifi = max_tip_hifi;
    z->is_trio = is_trio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm4, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movss 0x20(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movss 0x38(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movss 0x3c(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x58(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x50(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x50(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movl 0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: renew_paf1(ma_hit_t_alloc*, unsigned long*, unsigned long, unsigned long)
void renew_paf1(ma_hit_t_alloc *paf, uint64_t *a, uint64_t an, uint64_t len)
{
    uint64_t i, k, qn, tn; ma_hit_t arc;
    arc.qns = 0; arc.qe = len;
    arc.tn = 0; arc.ts = 0; arc.te = len;
    arc.rev = arc.el = arc.ml = arc.no_l_indel = arc.bl = 0;

    for (i = 0; i < an; i++) {
        qn = ((uint32_t)a[i]);
        for (k = 0; k < an; k++) {
            tn = ((uint32_t)a[k]);
            update_qtn(&arc, qn, tn); 
            add_ma_hit_t_alloc(&(paf[qn]), &arc);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x60(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x58(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x54(%rbp)
movabsq $-0x7fffffff00000001, %rax # imm = 0x80000000FFFFFFFF
andq -0x50(%rbp), %rax
orq $0x0, %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x47(%rbp)
movq -0x50(%rbp), %rax
andq $-0x40000001, %rax      # imm = 0xBFFFFFFF
orq $0x0, %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
andq -0x50(%rbp), %rax
orq $0x0, %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x376631
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x37661e
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x37dc20
movq -0x8(%rbp), %rdi
imulq $0x18, -0x38(%rbp), %rax
addq %rax, %rdi
leaq -0x68(%rbp), %rsi
callq 0xcd340
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3765ce
jmp 0x376620
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3765aa
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: destroy_integer_t(integer_t*)
void destroy_integer_t(integer_t *z)
{
    free(z->f.a); free(z->p.a); free(z->o.a); free(z->u.a);
    free(z->vis.a); free(z->sc.a); free(z->snp.a); free(z->res_dump.a);
    free(z->q.a); free(z->t.a); free(z->b.a); 
    
    free(z->pg.seq.a); free(z->pg.arc.a); free(z->pg.idx.a); free(z->pg.e_idx.a);
    free(z->pg.srt_b.ind.a);
    free(z->pg.srt_b.stack.a);
    free(z->pg.srt_b.res.a);
    free(z->pg.srt_b.res2nid.a);
    free(z->pg.srt_b.aln.a);

    free(z->pg.bb.a.a);
    free(z->pg.bb.S.a);
    free(z->pg.bb.T.a);
    free(z->pg.bb.b.a);
    free(z->pg.bb.e.a);
    free(z->pg.bb.us.a);

    free(z->pg.bb.dp.ref.a);
    free(z->pg.bb.dp.pat.a);
    free(z->pg.bb.dp.pat_cor.a);
    free(z->pg.bb.dp.g_flt.a);
    free(z->pg.bb.dp.m_dir.a);
    free(z->pg.bb.dp.m_score.a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x210(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x228(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x240(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x288(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: usg_t_destroy(usg_t*)
void usg_t_destroy(usg_t *g) {
    uint32_t k;
    for (k = 0; k < g->mp.n; k++) {
        free(g->mp.a[k].a);
    }
    free(g->mp.a);

    for (k = 0; k < g->n; k++) {
        free(g->a[k].arc[0].a); free(g->a[k].arc[1].a);
        free(g->a[k].arc_mm[0].a); free(g->a[k].arc_mm[1].a);
    }
    free(g->a);
    
    free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x378aa5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x378a73
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x378b39
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movq 0x68(%rax), %rdi
callq 0x2210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x378ab9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: renew_R_to_U(asg_t*, ma_hit_t_alloc*, ma_hit_t_alloc*, long, ma_sub_t*, R_to_U*, int, int)
void renew_R_to_U(asg_t *ng, ma_hit_t_alloc* src, ma_hit_t_alloc* r_src, int64_t n_read, ma_sub_t *coverage_cut, 
R_to_U* ruIndex, int max_hang, int min_ovlp)
{
    sset_aux s; memset(&s, 0, sizeof(s)); 
    kt_for(asm_opt.thread_num, clear_ma_hit_t_alloc, src, n_read);
    kt_for(asm_opt.thread_num, clear_ma_hit_t_alloc, r_src, n_read);

    s.g = NULL; s.cov = coverage_cut;
    kt_for(asm_opt.thread_num, reset_ma_sub_t, &s, n_read);

    ma_hit_contained_advance(src, n_read, coverage_cut, ruIndex, max_hang, min_ovlp);

    // s.g = ng; s.cov = coverage_cut;
    // kt_for(asm_opt.thread_num, reset_ma_sub_t, &s, n_read);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2100
leaq 0x4b9eb(%rip), %rax     # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x81(%rip), %rsi        # 0x378ea0
callq 0x16d710
leaq 0x4b9cd(%rip), %rax     # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x63(%rip), %rsi        # 0x378ea0
callq 0x16d710
movq $0x0, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x4b99f(%rip), %rax     # 0x3c47f8
movl 0x7c(%rax), %edi
movq -0x20(%rbp), %rcx
leaq 0xa9(%rip), %rsi        # 0x378f10
leaq -0x68(%rbp), %rdx
callq 0x16d710
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl 0x10(%rbp), %r8d
movl 0x18(%rbp), %r9d
callq 0xd0a10
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: usg_topocut_aux_del(ma_ug_t*, unsigned int, int, asg64_v*)
int usg_topocut_aux_del(ma_ug_t *ug, uint32_t v, int max_ext, asg64_v *b)
{
	int32_t n_ext; 
	for (n_ext = 0; n_ext < max_ext && v != (uint32_t)-1; ) {
		if (usg_topocut_aux_unambi1(ug->g, v^1) == (uint32_t)-1) break;
        if(b) kv_push(uint64_t, *b, v); n_ext += ug->u.a[v>>1].n;
		v = usg_topocut_aux_unambi1(ug->g, v);
	}
	return n_ext;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x1d(%rbp)
jge 0x37a4b4
cmpl $-0x1, -0xc(%rbp)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x37a4c0
jmp 0x37a5ad
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
xorl $0x1, %esi
callq 0x37a3c0
cmpl $-0x1, %eax
jne 0x37a4dd
jmp 0x37a5ad
cmpq $0x0, -0x18(%rbp)
je 0x37a576
jmp 0x37a4ea
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x37a552
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x37a517
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x28(%rbp)
jmp 0x37a522
movl $0x2, %eax
movq %rax, -0x28(%rbp)
jmp 0x37a522
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x37a576
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x37a3c0
movl %eax, -0xc(%rbp)
jmp 0x37a49d
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: cal_utg_occ(ma_ug_t*, unsigned int)
uint32_t cal_utg_occ(ma_ug_t *ug, uint32_t begNode)
{
    uint32_t v = begNode, w, kv, occ = 0; ma_utg_t *u;

    while (1) {
        kv = get_real_length(ug->g, v, NULL);
        u = &(ug->u.a[v>>1]); occ += u->n; 
        if(kv!=1) break;
        ///kv must be 1 here
        kv = get_real_length(ug->g, v, &w);
        if(get_real_length(ug->g, w^1, NULL)!=1) break;
        v = w;
        if(v == begNode) break;
    }
    return occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x10(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x166b50
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x18(%rbp)
je 0x37a622
jmp 0x37a66c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x10(%rbp), %esi
leaq -0x14(%rbp), %rdx
callq 0x166b50
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %esi
xorl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x166b50
cmpl $0x1, %eax
je 0x37a657
jmp 0x37a66c
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x37a667
jmp 0x37a66c
jmp 0x37a5dc
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_specfic_edge(asg_t*, unsigned int, unsigned int)
inline asg_arc_t* get_specfic_edge(asg_t *g, uint32_t v, uint32_t w)
{
    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 (&av[k]);
    return NULL;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%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, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x37be65
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x37be40
jmp 0x37be5a
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x37be58
jmp 0x37be65
jmp 0x37be5a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x37be1d
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x37be81
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x37be89
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_bg_flag(ul_resolve_t*, unsigned int, unsigned int)
inline uint32_t get_bg_flag(ul_resolve_t *uidx, uint32_t v, uint32_t w)
{
    asg_t *g = uidx->uovl.bg.bg; asg_arc_t *av; uint32_t k, nv; 
    if(g->seq[v>>1].del || g->seq[w>>1].del) return bg_unavailable;

    av = asg_arc_a(g, v); nv = asg_arc_n(g, v);
    for (k = 0; k < nv; k++) {
        if(av[k].v == w) break;
    }
    if(k >= nv) return bg_unavailable;
    if(av[k].ou == 3) return bg_correct;
    if(av[k].ou == 2) return bg_wrong;
    return bg_ambiguous;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x278(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x37d311
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x18(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x37d31d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37d3ef
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%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 -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0x37d389
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x37d37c
jmp 0x37d389
jmp 0x37d37e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x37d35c
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jb 0x37d39a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37d3ef
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movw 0x10(%rax), %ax
andw $0x3fff, %ax            # imm = 0x3FFF
movzwl %ax, %eax
cmpl $0x3, %eax
jne 0x37d3c1
movl $0x1, -0x4(%rbp)
jmp 0x37d3ef
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movw 0x10(%rax), %ax
andw $0x3fff, %ax            # imm = 0x3FFF
movzwl %ax, %eax
cmpl $0x2, %eax
jne 0x37d3e8
movl $0x2, -0x4(%rbp)
jmp 0x37d3ef
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: get_usg_arc(usg_t*, unsigned int, unsigned int)
inline usg_arc_t* get_usg_arc(usg_t *g, uint32_t v, uint32_t w)
{
    usg_arc_t *av = usg_arc_a(g, v); uint32_t nv = usg_arc_n(g, v), k;
    for (k = 0; k < nv; k++) {
        if(av[k].v == w) break;
    }

    if(k < nv) return (&av[k]);
    return NULL;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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, -0x20(%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, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x37d4a0
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x37d493
jmp 0x37d4a0
jmp 0x37d495
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x37d473
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x37d4bc
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x37d4c4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: undel_arcs(usg_t*, unsigned int, unsigned int*)
inline int undel_arcs(usg_t *g, uint32_t v, uint32_t* v_s)
{
    uint32_t i, nv = usg_arc_n(g, v), kv; 
    usg_arc_t *av = usg_arc_a(g, v);
    for (i = kv = 0; i < nv; i++) {
        if(av[i].del) continue;
        if(v_s) v_s[kv] = av[i].v;
        kv++; 
    }
    return kv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -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, -0x20(%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, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x37d8b4
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x37d87e
jmp 0x37d8a9
cmpq $0x0, -0x18(%rbp)
je 0x37d8a0
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37d85b
movl -0x24(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/gfa_ut.cpp
// Function: usg_arc_occ(usg_t*, unsigned int, unsigned int*)
inline uint32_t usg_arc_occ(usg_t *g, uint32_t v, uint32_t *res)
{
    uint32_t i, kv, nv = usg_arc_n(g, v);; 
    usg_arc_t *av = usg_arc_a(g, v);
    for (i = kv = 0; i < nv; i++) {
        if(av[i].del) continue;
        if(res) res[kv] = av[i].v;
        kv++;
    }
    return kv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -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, -0x24(%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, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x37dc14
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x37dbde
jmp 0x37dc09
cmpq $0x0, -0x18(%rbp)
je 0x37dc00
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37dbbb
movl -0x20(%rbp), %eax
popq %rbp
retq
nopl (%rax)