LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/horder.cpp
// Function: update_ug_by_layout(horder_t*, sc_lay_t*, ma_ug_t*)
void update_ug_by_layout(horder_t *h, sc_lay_t *sl, ma_ug_t* i_ug)
{
    uint32_t i;
    lay_t *p = NULL;
    ma_utg_t *pu = NULL;
    ma_ug_t *sug = NULL;
    kvec_t_u64_warp n_avoids; kv_init(n_avoids.a);
    sug = (ma_ug_t*)calloc(1, sizeof(ma_ug_t));
    for (i = 0; i < sl->n; i++)
    {
        p = &(sl->a[i]);
        kv_pushp(ma_utg_t, sug->u, &pu);
        generate_scaffold(pu, p, i_ug?i_ug:h->ug, h->r_g);
    }
    ma_ug_destroy(h->ug);
    h->ug = sug;
    kv_destroy(n_avoids.a);
    update_avoids(h, sl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x2140
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x24529a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x24521c
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2451e4
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x60(%rbp)
jmp 0x2451ef
movl $0x2, %eax
movq %rax, -0x60(%rbp)
jmp 0x2451ef
movq -0x60(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rax
imulq $0x28, 0x8(%rax), %rsi
callq 0x2360
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x245261
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x245270
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
callq 0x244810
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x245191
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0xcd6f0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x48(%rbp), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x245050
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/horder.cpp
// Function: renew_scaffold(horder_t*)
void renew_scaffold(horder_t *h)
{
    double index_time = yak_realtime();
    while (1)
    {
        update_u_hits(&(h->u_hits), &(h->r_hits), h->ug, h->r_g);
        if(!break_scaffold(h, 5, 15, (uint64_t)-1, (uint64_t)-1, 2500000, 1, NULL)) break;
        print_N50(h->ug);
    }
    fprintf(stderr, "[M::%s::%.3f] \n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
callq 0x234c00
movq -0x8(%rbp), %rdi
movl $0x5, %esi
movl $0xf, %edx
movq $-0x1, %r8
movl $0x2625a0, %r9d         # imm = 0x2625A0
xorl %eax, %eax
movq %r8, %rcx
movl $0x1, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x23ee60
cmpq $0x0, %rax
jne 0x245c1e
jmp 0x245c30
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x232ca0
jmp 0x245bb6
movq 0x17e3a9(%rip), %rax    # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1b7ca0
movq -0x18(%rbp), %rdi
subsd -0x10(%rbp), %xmm0
leaq 0x146a64(%rip), %rsi    # 0x38c6b7
leaq 0x148b5b(%rip), %rdx    # 0x38e7b5
movb $0x1, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/horder.cpp
// Function: output_hic_rtg(ma_ug_t*, asg_t*, ug_opt_t*, char*)
void output_hic_rtg(ma_ug_t *ug, asg_t *rg, ug_opt_t *opt, char* output_file_name)
{
    char* gfa_name = (char*)malloc(strlen(output_file_name)+50);
    sprintf(gfa_name, "%s.all.noseq.gfa", output_file_name);
    FILE* output_file = fopen(gfa_name, "w");
    ma_ug_print_simple(ug, rg, opt->coverage_cut, opt->sources, opt->ruIndex, "utg", output_file);
    fclose(output_file);
    free(gfa_name);
}

// 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), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x32, %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1483e4(%rip), %rsi    # 0x38e854
movb $0x0, %al
callq 0x2050
movq -0x28(%rbp), %rdi
leaq 0x152f50(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x30(%rbp), %rax
leaq 0x1464f3(%rip), %r9     # 0x38c9a8
movq %rax, (%rsp)
callq 0xf1c10
movq -0x30(%rbp), %rdi
callq 0x21a0
movq -0x28(%rbp), %rdi
callq 0x2210
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/horder.cpp
// Function: cpy_u_hits(kvec_pe_hit*, kvec_pe_hit*, unsigned int)
void cpy_u_hits(kvec_pe_hit *u_hits, kvec_pe_hit *i_hits, uint32_t u_n)
{
    uint64_t i;
    memset(u_hits, 0, sizeof(kvec_pe_hit));
    u_hits->pos_mode = i_hits->pos_mode;
    u_hits->uID_bits = i_hits->uID_bits;
    u_hits->a.n = u_hits->a.m = i_hits->a.n;
    MALLOC(u_hits->a.a, u_hits->a.n);
    memcpy(u_hits->a.a, i_hits->a.a, u_hits->a.n*sizeof(pe_hit));
    for (i = 0; i < u_hits->a.n; i++) u_hits->a.a[i].id = 1;
    idx_hits(u_hits, u_n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x2100
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
shlq $0x5, %rdi
callq 0x2270
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
shlq $0x5, %rdx
callq 0x2180
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2487f2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq $0x1, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2487bc
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x233240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/horder.cpp
// Function: renew_scaffold_utg(horder_t*, sc_lay_t*, ma_ug_t*)
void renew_scaffold_utg(horder_t *h, sc_lay_t *sl, ma_ug_t* i_ug)
{
    double index_time = yak_realtime();
    h_covs b; kv_init(b);
    while (1)
    {
        update_u_hits(&(h->u_hits), &(h->r_hits), h->ug, h->r_g);
        if(!break_scaffold(h, 5, 15, 15, 25, 2500000, 1, &b)) break;
        update_sc_lay(sl, &b);
        update_ug_by_layout(h, sl, i_ug);
        print_N50(h->ug);
    }
    fprintf(stderr, "[M::%s::%.3f] \n", __func__, yak_realtime()-index_time);
    kv_destroy(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x1b7ca0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
callq 0x234c00
movq -0x8(%rbp), %rdi
movl $0x5, %esi
movl $0xf, %ecx
movl $0x19, %r8d
movl $0x2625a0, %r9d         # imm = 0x2625A0
leaq -0x38(%rbp), %rax
movq %rcx, %rdx
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x23ee60
cmpq $0x0, %rax
jne 0x248dbb
jmp 0x248dee
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x248810
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x245130
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x232ca0
jmp 0x248d56
movq 0x17b1eb(%rip), %rax    # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x1b7ca0
movq -0x40(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
leaq 0x1438a6(%rip), %rsi    # 0x38c6b7
leaq 0x145d15(%rip), %rdx    # 0x38eb2d
movb $0x1, %al
callq 0x22a0
movq -0x38(%rbp), %rdi
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/horder.cpp
// Function: scf_g(sc_lay_t*, ma_ug_t*)
spg_t *scf_g(sc_lay_t *sl, ma_ug_t* ug)
{
    spg_t *scg = NULL; CALLOC(scg, 1); scg->ug = ug;    
    uint64_t i, k;
    lay_t *p = NULL;
    for (i = 0; i < sl->n; i++){
        p = &(sl->a[i]);
        kv_push(uint64_t, scg->idx, (uint64_t)scg->dst.n << 32 | (p->n>>1));
        for (k = 0; k < p->n; k+=2) kv_push(uint32_t, scg->dst, p->a[k]);        
    }
    return scg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x2140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x249014
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x248f04
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x248ec9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x248ed4
movl $0x2, %eax
movq %rax, -0x38(%rbp)
jmp 0x248ed4
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
shlq $0x20, %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
shrq %rax
orq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, (%rax,%rcx,8)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x249001
jmp 0x248f59
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x248fc2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x248f87
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x248f92
movl $0x2, %eax
movq %rax, -0x40(%rbp)
jmp 0x248f92
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
shlq $0x2, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rsi
movq 0x20(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x20(%rsi)
movl %edx, (%rax,%rcx,4)
jmp 0x248ff0
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x248f45
jmp 0x249003
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x248e76
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/horder.cpp
// Function: horder_utg(kvec_pe_hit*, unsigned long, unsigned long, asg_t*, ma_ug_t*, bubble_type*, ug_opt_t*)
spg_t *horder_utg(kvec_pe_hit *i_hits, uint64_t i_hits_uid_bits, uint64_t i_hits_pos_mode, 
asg_t *i_rg, ma_ug_t* i_ug, bubble_type* bub, ug_opt_t *opt)
{
    horder_t *h = NULL; CALLOC(h, 1);
    sc_lay_t sl; kv_init(sl);
    get_r_hits(i_hits, &(h->r_hits), i_rg, i_ug, bub, i_hits_uid_bits, i_hits_pos_mode);
    h->r_g = copy_read_graph(i_rg);
    horder_clean_sg_by_utg(h->r_g, i_ug);///udate rg by ug
    h->ug = copy_untig_graph(i_ug); asg_destroy(h->ug->g); h->ug->g = NULL;
    cpy_u_hits(&(h->u_hits), i_hits, h->ug->u.n);

    update_scg(h, NULL);
    layout_scg(h, ((double)1)/((double)0.75), 19, &sl);
    renew_scaffold_utg(h, &sl, i_ug);
    
    spg_t *scg = scf_g(&sl, i_ug);
    destory_sc_lay_t(&sl);
    destory_horder_t(&h);
    return scg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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, -0x38(%rbp)
movl $0x1, %edi
movl $0xe0, %esi
callq 0x2140
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %r9
movq -0x18(%rbp), %rax
movq %rax, (%rsp)
callq 0x234040
movq -0x20(%rbp), %rdi
callq 0x10b830
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x38(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2354a0
movq -0x28(%rbp), %rdi
callq 0x10ba70
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x38(%rbp), %rax
movq 0xc8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0xcd170
movq -0x38(%rbp), %rax
movq 0xc8(%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0xc8(%rax), %rax
movq (%rax), %rax
movl %eax, %edx
callq 0x248720
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x241640
movq -0x38(%rbp), %rdi
movsd 0x145025(%rip), %xmm0   # 0x38e168
movl $0x13, %esi
leaq -0x50(%rbp), %rdx
callq 0x245880
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x248d20
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x248e30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x245820
leaq -0x38(%rbp), %rdi
callq 0x249190
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/horder.cpp
// Function: destory_horder_t(horder_t**)
void destory_horder_t(horder_t **h)
{
    kv_destroy((*h)->r_hits.a);
    kv_destroy((*h)->r_hits.idx);
    kv_destroy((*h)->r_hits.occ);

    kv_destroy((*h)->u_hits.a);
    kv_destroy((*h)->u_hits.idx);
    kv_destroy((*h)->u_hits.occ);

    kv_destroy((*h)->avoid);

    osg_destroy((*h)->sg.g);

    ma_ug_destroy((*h)->ug);
    asg_destroy((*h)->r_g);
    free((*h));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x80(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xd8(%rax), %rdi
callq 0x23f890
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rdi
callq 0xcd6f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xd0(%rax), %rdi
callq 0xcd170
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
// File: chhylp123[P]hifiasm/horder.cpp
// Function: ha_aware_order(kvec_pe_hit*, asg_t*, ma_ug_t*, ma_ug_t*, kv_u_trans_t*, ug_opt_t*, unsigned int)
void ha_aware_order(kvec_pe_hit *r_hits, asg_t *rg, ma_ug_t *ug_fa, ma_ug_t *ug_mo, kv_u_trans_t *ref, 
ug_opt_t *opt, uint32_t round)
{
    horder_t *h = NULL; CALLOC(h, 1);
    h->r_hits = *r_hits;
    h->r_g = rg;
    scaffold_ug(h, ug_fa, opt, round, asm_opt.output_file_name, FATHER);
    scaffold_ug(h, ug_mo, opt, round, asm_opt.output_file_name, MOTHER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
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)
movq $0x0, -0x38(%rbp)
movl $0x1, %edi
movl $0xe0, %esi
callq 0x2140
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movl $0x58, %edx
callq 0x2180
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl 0x10(%rbp), %ecx
leaq 0x17a97f(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %r8
movl $0x1, %r9d
callq 0x2460e0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl 0x10(%rbp), %ecx
leaq 0x17a95a(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %r8
movl $0x2, %r9d
callq 0x2460e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: destroy_cns_gfa(cns_gfa*)
void destroy_cns_gfa(cns_gfa *p)
{
    size_t k;
    for (k = 0; k < p->m; k++) {
        kv_destroy(p->a[k].arc);
    }
    free(p->a); kdq_destroy(uint32_t, p->q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x24af79
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x2210
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x24af44
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x24afa0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: destroy_ec_ovec_buf_t(ec_ovec_buf_t*)
void destroy_ec_ovec_buf_t(ec_ovec_buf_t *p)
{
    uint32_t k; ec_ovec_buf_t0 *z = NULL;
    for (k = 0; k < p->n; k++) {
        z = &(p->a[k]); z->rr = 0;
        destory_UC_Read(&z->self_read);
        destory_UC_Read(&z->ovlp_read);
        destory_Candidates_list(&z->clist);
	    destory_overlap_region_alloc(&z->olist);

        // destory_fake_cigar(&(z->tmp.f_cigar));
        // free(z->tmp.w_list.a); free(z->tmp.w_list.c.a);

        // kv_destroy(z->r_buf.a);
        kv_destroy(z->k_flag.a);
        kv_destroy(z->sp);
        kv_destroy(z->pidx);
	    kv_destroy(z->v64);
        kv_destroy(z->v32);
        kv_destroy(z->v16);
        kv_destroy(z->v8q);
        kv_destroy(z->v8t);
        destroy_bit_extz_t(&(z->exz));

        ha_abuf_destroy(z->ab);
        
        destoryHaplotypeEvdience(&z->hap);
        destroy_cns_gfa(&(z->cns));

    }
    free(p->a); free(p->cr); free(p);

    // fprintf(stderr, "[M::%s-chains] #->%lld\n", __func__, asm_opt.num_bases);
    // fprintf(stderr, "[M::%s-passed-chains-0] #->%lld\n", __func__, asm_opt.num_corrected_bases);
    // fprintf(stderr, "[M::%s-cis-chains-1] #->%lld\n", __func__, asm_opt.num_recorrected_bases);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x24b133
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x5c0, %rcx, %rcx      # imm = 0x5C0
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x18(%rbp), %rdi
callq 0x9670
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x9670
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x230c0
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
callq 0x1e220
movq -0x18(%rbp), %rax
movq 0x558(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x578(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x4b8(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x4e0(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x4f8(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x510(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x528(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x540(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
callq 0x1c4e0
movq -0x18(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x1a0680
movq -0x18(%rbp), %rdi
addq $0xf8, %rdi
callq 0x1c520
movq -0x18(%rbp), %rdi
addq $0x580, %rdi            # imm = 0x580
callq 0x24af30
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x24affb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: prt_chain(overlap_region_alloc*)
void prt_chain(overlap_region_alloc *o)
{
    uint64_t k;
    for (k = 0; k < o->length; k++) {
        fprintf(stderr, "[M::%s]\t#%u\tlen::%lu\t%u\t%u\t%c\t#%u\tlen::%lu\t%u\t%u\tsc::%d\taln::%u\terr::%u\n", __func__, o->list[k].x_id, Get_READ_LENGTH(R_INF, o->list[k].x_id), o->list[k].x_pos_s, o->list[k].x_pos_e+1, "+-"[o->list[k].y_pos_strand], 
                                                                                        o->list[k].y_id, Get_READ_LENGTH(R_INF, o->list[k].y_id), o->list[k].y_pos_s, o->list[k].y_pos_e+1, o->list[k].shared_seed, o->list[k].align_length, o->list[k].non_homopolymer_errors);
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x24b31f
movq 0x178e4a(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x38(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %ecx
leaq 0x17a11c(%rip), %rax    # 0x3c52d0
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl (%rdx), %edx
movq (%rax,%rdx,8), %r8
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x38(%rbp), %rdx
addq %rdx, %rax
movl 0x4(%rax), %r9d
movq -0x30(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x38(%rbp), %rdx
addq %rdx, %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl 0x1c(%rdx), %edx
movl %edx, %esi
leaq 0x137c7f(%rip), %rdx    # 0x382e9b
movsbl (%rdx,%rsi), %r13d
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl 0x10(%rdx), %r12d
leaq 0x17a092(%rip), %rdx    # 0x3c52d0
movq 0x18(%rdx), %rdx
movq -0x30(%rbp), %rsi
movq (%rsi), %rsi
imulq $0xa8, -0x38(%rbp), %r10
addq %r10, %rsi
movl 0x10(%rsi), %esi
movq (%rdx,%rsi,8), %r15
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl 0x14(%rdx), %r14d
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl 0x18(%rdx), %ebx
addl $0x1, %ebx
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl 0x24(%rdx), %r11d
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl 0x28(%rdx), %r10d
movq -0x30(%rbp), %rdx
movq (%rdx), %rdx
imulq $0xa8, -0x38(%rbp), %rsi
addq %rsi, %rdx
movl 0x30(%rdx), %edx
movl %edx, -0x3c(%rbp)
leaq 0x1438e4(%rip), %rsi    # 0x38ebb8
leaq 0x143926(%rip), %rdx    # 0x38ec01
movl %eax, (%rsp)
movl -0x3c(%rbp), %eax
movl %r13d, 0x8(%rsp)
movl %r12d, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movl %r14d, 0x20(%rsp)
movl %ebx, 0x28(%rsp)
movl %r11d, 0x30(%rsp)
movl %r10d, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movb $0x0, %al
callq 0x22a0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x24b17d
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: fetch_aux_ovlp(overlap_region_alloc*)
overlap_region *fetch_aux_ovlp(overlap_region_alloc* ol) /// exactly same to gen_aux_ovlp
{
	if (ol->length + 1 >= ol->size) {
		uint64_t sl = ol->size;
        ol->size = ol->length + 1;
        kroundup64(ol->size);
        REALLOC(ol->list, ol->size);
        /// need to set new space to be 0
        memset(ol->list + sl, 0, sizeof(overlap_region)*(ol->size - sl));
	}
    ///debug for memory
    // if(ol->length + 1 >= ol->size) {
    //     fprintf(stderr, "[M::%s] length::%lu, size::%lu\n", __func__, ol->length, ol->size);
    // }
	return &(ol->list[ol->length+1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x24b473
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0xa8, 0x8(%rax), %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x10(%rbp), %rax
imulq $0xa8, %rax, %rdx
xorl %esi, %esi
callq 0x2100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq $0x1, %rcx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: push_cns_c1(cns_gfa*, unsigned long, char*, unsigned long, unsigned int, asg32_v*, unsigned long, unsigned int)
uint32_t push_cns_c1(cns_gfa *cns, uint64_t s0, char *tstr, uint64_t tl, uint32_t plus0, asg32_v* b32, uint64_t max_trace, uint32_t rid)
{
    if(tl <= 0) return s0;
    uint32_t rr = plus0, k, re = s0; 
    k = trace_cns_bp(cns, s0, tstr, tl, b32, plus0, &re, max_trace, 1);
    if(k > 0) rr = 1;

    // if(s0 == 2863) {
    //     fprintf(stderr, "[M::%s] (%.*s)\ts0::%lu\tk::%u\ttl::%lu\tre::%u\n", __func__, tstr?((int)(tl)):0, tstr, s0, k, tl, re);
    // }
    //     fprintf(stderr, "[M::%s] s0::%u, s::%u\n", __func__, k-1, k);
        //     prt_cns_arc(cns, k-1, __func__); prt_cns_arc(cns, k, __func__);

    for (; k < tl; k++) {///the weight of (s0 -> tstr[0]) might be 0
        re = add_cns_arc_bp(cns, re, seq_nt6_table[(uint32_t)(tstr[k])], rr, rid, 1); rr = 1;
    }
    
    return re;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
ja 0x24d52a
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x24d5d6
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq 0x10(%rbp), %rax
leaq -0x44(%rbp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
callq 0x24ce70
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jbe 0x24d57d
movl $0x1, -0x3c(%rbp)
jmp 0x24d57f
movl -0x40(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x24d5d0
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x20(%rbp), %rax
movl -0x40(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1770ab(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %edx
movl -0x3c(%rbp), %ecx
movl 0x18(%rbp), %r8d
movl $0x1, %r9d
callq 0x26ce10
movl %eax, -0x44(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x24d57f
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: prt_cigar0(unsigned long, long)
void prt_cigar0(uint64_t in, int64_t len)
{
    int64_t k; uint64_t mp;
    char cm[4]; cm[0] = 'M'; cm[1] = 'S'; cm[2] = 'I'; cm[3] = 'D';  
    for (k = 0; k < len; k++) {
        mp = len - 1 - k; mp <<= 1;
        fprintf(stderr, "%c", cm[(in >> mp)&3]);
    }
    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x4d, -0x24(%rbp)
movb $0x53, -0x23(%rbp)
movb $0x49, -0x22(%rbp)
movb $0x44, -0x21(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x24ed97
movq -0x10(%rbp), %rax
subq $0x1, %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq 0x17527c(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq %cl, %rax
andq $0x3, %rax
movsbl -0x24(%rbp,%rax), %edx
leaq 0x140247(%rip), %rsi    # 0x38efc9
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x24ed38
movq 0x175242(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x137c80(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: prt_bp0(unsigned long, long)
void prt_bp0(uint64_t in, int64_t len)
{
    int64_t k; uint64_t mp;
    char cm[4]; cm[0] = 'A'; cm[1] = 'C'; cm[2] = 'G'; cm[3] = 'T';  
    for (k = 0; k < len; k++) {
        mp = len - 1 - k; mp <<= 1;
        fprintf(stderr, "%c", cm[(in >> mp)&3]);
    }
    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x41, -0x24(%rbp)
movb $0x43, -0x23(%rbp)
movb $0x47, -0x22(%rbp)
movb $0x54, -0x21(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x24ee47
movq -0x10(%rbp), %rax
subq $0x1, %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq 0x1751cc(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq %cl, %rax
andq $0x3, %rax
movsbl -0x24(%rbp,%rax), %edx
leaq 0x140197(%rip), %rsi    # 0x38efc9
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x24ede8
movq 0x175192(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x137bd0(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_cigar_xlen(overlap_region*)
uint32_t cal_cigar_xlen(overlap_region *in)
{
    assert(in->w_list.n == 1);
    uint32_t cn = in->w_list.a[0].clen; uint16_t *a = in->w_list.c.a + in->w_list.a[0].cidx;
    uint32_t ci, len, xk, yk; uint16_t c, b; asg16_v scc; scc.n = scc.m = cn; scc.a = a;

    ci = 0; xk = yk = 0;
    while (ci < cn) {
        ci = pop_trace_bp(&scc, ci, &c, &b, &len);
        if(c != 2) xk += len;
        if(c != 3) yk += len;
    }

    return xk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x48(%rax)
jne 0x253499
jmp 0x2534b8
leaq 0x13bb8d(%rip), %rdi    # 0x38f02d
leaq 0x13b764(%rip), %rsi    # 0x38ec0b
movl $0x81f, %edx            # imm = 0x81F
leaq 0x13bb8c(%rip), %rcx    # 0x38f03f
callq 0x2130
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movl 0x18(%rcx), %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x253554
movl -0x1c(%rbp), %esi
leaq -0x48(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x26db30
movl %eax, -0x1c(%rbp)
movzwl -0x2a(%rbp), %eax
cmpl $0x2, %eax
je 0x253540
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movzwl -0x2a(%rbp), %eax
cmpl $0x3, %eax
je 0x253552
movl -0x20(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x25350b
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_cigar_xlen_fhc(overlap_region*)
uint32_t cal_cigar_xlen_fhc(overlap_region *in)
{
    assert(in->w_list.n == 1);
    uint32_t cn = in->w_list.a[0].clen; uint16_t *a = in->w_list.c.a + in->w_list.a[0].cidx;
    uint32_t ci, len, xk, yk; uint16_t c, bq, bt; asg16_v scc; scc.n = scc.m = cn; scc.a = a;

    ci = 0; xk = yk = 0;
    while (ci < cn) {
        ci = pop_trace_bp_f(&scc, ci, &c, &bq, &bt, &len);
        if(c != 2) xk += len;
        if(c != 3) yk += len;
    }

    return xk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x48(%rax)
jne 0x253579
jmp 0x253598
leaq 0x13baad(%rip), %rdi    # 0x38f02d
leaq 0x13b684(%rip), %rsi    # 0x38ec0b
movl $0x82f, %edx            # imm = 0x82F
leaq 0x13bad6(%rip), %rcx    # 0x38f069
callq 0x2130
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movl 0x18(%rcx), %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x253638
movl -0x1c(%rbp), %esi
leaq -0x48(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x2e(%rbp), %r8
leaq -0x20(%rbp), %r9
callq 0x1b53f0
movl %eax, -0x1c(%rbp)
movzwl -0x2a(%rbp), %eax
cmpl $0x2, %eax
je 0x253624
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movzwl -0x2a(%rbp), %eax
cmpl $0x3, %eax
je 0x253636
movl -0x20(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x2535eb
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: push_nec_re(overlap_region*, asg16_v*)
void push_nec_re(overlap_region *in, asg16_v *ou)
{
    assert(in->w_list.n == 1);
    uint32_t n1 = in->w_list.a[0].clen;
    if(n1 > ou->m) {
        REALLOC(ou->a, n1); ou->m = n1;
    }
    ou->n = n1;
    memcpy(ou->a, in->w_list.c.a + in->w_list.a[0].cidx, n1*sizeof((*(in->w_list.c.a))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x48(%rax)
jne 0x255aad
jmp 0x255acc
leaq 0x139579(%rip), %rdi    # 0x38f02d
leaq 0x139150(%rip), %rsi    # 0x38ec0b
movl $0x97c, %edx            # imm = 0x97C
leaq 0x139750(%rip), %rcx    # 0x38f217
callq 0x2130
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x255b14
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
shlq %rsi
callq 0x2360
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x18(%rax), %eax
shlq %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
shlq %rdx
callq 0x2180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_updated_trace_len(asg16_v*, unsigned long*, unsigned long*)
void cal_updated_trace_len(asg16_v *sc, uint64_t *ql, uint64_t *tl)
{
    uint64_t ck = 0, qk = 0, tk = 0; uint32_t len; uint16_t c, bq, bt;
    while (ck < sc->n) {
        ck = pop_trace_bp_f(sc, ck, &c, &bq, &bt, &len);
        if(c != 2) qk += len;
        if(c != 3) tk += len;
    }
    *ql = qk; *tl = tk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2650d8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
leaq -0x36(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x3a(%rbp), %r8
leaq -0x34(%rbp), %r9
callq 0x1b53f0
movl %eax, %eax
movq %rax, -0x20(%rbp)
movzwl -0x36(%rbp), %eax
cmpl $0x2, %eax
je 0x2650c2
movl -0x34(%rbp), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movzwl -0x36(%rbp), %eax
cmpl $0x3, %eax
je 0x2650d6
movl -0x34(%rbp), %eax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x26507c
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_update_ec_multiple(ec_ovec_buf_t*, unsigned long, unsigned long)
void cal_update_ec_multiple(ec_ovec_buf_t *b, uint64_t n_thre, uint64_t n_a)
{
    double tt0 = yak_realtime_0();
    uint64_t k, num_ec_o = 0, num_nec_o = 0; 

    for (k = 0; k < n_thre; ++k) b->a[k].cnt[0] = b->a[k].cnt[1] = 0;

    kt_for(n_thre, worker_update_dc_ec, b, n_a);///debug_for_fix

    for (k = 0; k < n_thre; ++k) {
        num_ec_o += b->a[k].cnt[0]; num_nec_o += b->a[k].cnt[1];
    }

    fprintf(stderr, "[M::pec::%.3f] # exact o: %lu; # non-exact o: %lu\n", yak_realtime_0()-tt0, num_ec_o, num_nec_o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x1b7cc0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x267768
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x28(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x28(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc0(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x267716
movq -0x10(%rbp), %rax
movl %eax, %edi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xa3(%rip), %rsi        # 0x267820
callq 0x16d710
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2677e4
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x28(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq 0xc0(%rax), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x28(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq 0xc8(%rax), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26778a
movq 0x15c7f5(%rip), %rax    # 0x3c3fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x1b7cc0
movq -0x40(%rbp), %rdi
subsd -0x20(%rbp), %xmm0
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0x12897d(%rip), %rsi    # 0x39018c
movb $0x1, %al
callq 0x22a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: worker_update_dc_ec(void*, long, int)
static void worker_update_dc_ec(void *data, long i, int tid)
{
    ec_ovec_buf_t0 *b = &(((ec_ovec_buf_t*)data)->a[tid]);
    uint64_t k; ma_hit_t *z;
    // fprintf(stderr, "-0-[M::%s-beg] rid->%ld\n", __func__, i);
    // if (memcmp("m64012_190921_234837/139067658/ccs", Get_NAME((R_INF), i), Get_NAME_LENGTH((R_INF),i)) == 0) {
    //     fprintf(stderr, "-0-[M::%s-beg] rid->%ld\n", __func__, i);
    // } else if (memcmp("m64012_190921_234837/28968323/ccs", Get_NAME((R_INF), i), Get_NAME_LENGTH((R_INF),i)) == 0) {
    //     fprintf(stderr, "-1-[M::%s-beg] rid->%ld\n", __func__, i);
    // } else {
    //     return;
    // }
    // if(i != 2851) return;

    // if(scb.a[i].m < scc.a[i].n) {
    //     scb.a[i].m = scc.a[i].n;
    //     REALLOC(scb.a[i].a, scb.a[i].m);
    // }
    // scb.a[i].n = scc.a[i].n;
    // memcpy(scb.a[i].a, scc.a[i].a, scc.a[i].n*sizeof((*(scb.a[i].a))));


    if(!(R_INF.paf[i].length)) return;
    recover_UC_Read(&b->self_read, &R_INF, i);
    for (k = 0; k < R_INF.paf[i].length; k++) {
        z = &(R_INF.paf[i].buffer[k]);
        if((z->el) && (quick_exact_match(z, &R_INF, &b->self_read, &b->ovlp_read, &scc))) {
            z->el = 1; b->cnt[0]++;
        } else {
            z->el = 0; b->cnt[1]++;
        }
    }

    refresh_ec_ovec_buf_t0(b, REFRESH_N);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x5c0, %rcx, %rcx      # imm = 0x5C0
addq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq 0x15da7d(%rip), %rax    # 0x3c52d0
movq 0x78(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpl $0x0, 0xc(%rax)
jne 0x26786a
jmp 0x26795c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x15da57(%rip), %rsi    # 0x3c52d0
callq 0xa380
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq 0x15da3f(%rip), %rcx    # 0x3c52d0
movq 0x78(%rcx), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jae 0x26794e
leaq 0x15da20(%rip), %rax    # 0x3c52d0
movq 0x78(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
imulq $0x28, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x20(%rax)
je 0x26791d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x20, %rcx
leaq 0x15d9e4(%rip), %rsi    # 0x3c52d0
leaq 0x15dce5(%rip), %r8     # 0x3c55d8
callq 0x259bc0
cmpl $0x0, %eax
je 0x26791d
movq -0x30(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc0(%rax)
jmp 0x26793b
movq -0x30(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rax)
jmp 0x26793d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x267886
movq -0x20(%rbp), %rdi
movl $0x80, %esi
callq 0x26e2d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_ec_r(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*)
void cal_ec_r(uint64_t n_thre, uint64_t round, uint64_t n_round, uint64_t n_a, uint64_t is_sv, uint64_t *tot_b, uint64_t *tot_e)
{
    // write_ec_reads("ec0.fa");

    // fprintf(stderr, "[M::%s]\tn_thre::%lu, round::%lu, n_round::%lu, n_a::%lu, is_sv::%lu\n", __func__, n_thre, round, n_round, n_a, is_sv);

    ec_ovec_buf_t *b = NULL; uint64_t k, is_cr = (round&1);
    (*tot_b) = (*tot_e) = 0;


    b = gen_ec_ovec_buf_t(n_thre);
    (*tot_e) += cal_ec_multiple(b, n_thre, n_a, tot_b); ///exit(1);
    sl_ec_r(n_thre, n_a);

    for (k = 0; k < n_round; k++) {
        (*tot_e) += cal_sec_ec_multiple(b, n_thre, n_a, k);
        sl_ec_r(n_thre, n_a);
    }

    cal_update_ec_multiple(b, n_thre, n_a);///update overlaps

    // if(is_sv) kt_for(n_thre, worker_hap_dc_ec, b, n_a);///update overlaps
    

    if((!is_sv) || (is_sv && is_cr)) {
        kt_for(n_thre, worker_hap_post_rev, b, n_a);
    }

    // cal_sec_ec_multiple(b, n_thre, n_a, -1);

    // gen_sec_ec_multiple(b, n_thre, n_a);

    destroy_ec_ovec_buf_t(b);

    // write_ec_reads("ec16.fa");

    // uint64_t z;
    // for (z = 0; z < scc.n; z++) {
    //     if(scc.f[z]) continue;
    //     fprintf(stderr, "[M::%s]\tid::%lu::%.*s\n", __func__, z, (int)Get_NAME_LENGTH(R_INF, z), Get_NAME((R_INF), z));
    // }
}

// 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, -0x38(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0x24ac00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x266b70
movq %rax, %rcx
movq 0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x269b70
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x269b1b
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x2685f0
movq %rax, %rcx
movq 0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x269b70
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x269ad4
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2676e0
cmpq $0x0, -0x28(%rbp)
je 0x269b41
cmpq $0x0, -0x28(%rbp)
je 0x269b5b
cmpq $0x0, -0x48(%rbp)
je 0x269b5b
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x18a(%rip), %rsi       # 0x269ce0
callq 0x16d710
movq -0x38(%rbp), %rdi
callq 0x24afe0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: sl_ec_r(unsigned long, unsigned long)
void sl_ec_r(uint64_t n_thre, uint64_t n_a)
{
    sl_v *b = NULL; uint64_t k; MALLOC(b, n_thre);
    for (k = 0; k < n_thre; k++) {
        b[k].a = NULL; b[k].n = b[k].m = 0;
        init_UC_Read(&b[k].z); kv_init(b[k].q);
    }

    kt_for(n_thre, worker_sl_ec, b, n_a);///debug_for_fix

    for (k = 0; k < n_thre; k++) {
        free(b[k].a); destory_UC_Read(&b[k].z); kv_destroy(b[k].q);
    }
    free(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
imulq $0x50, -0x8(%rbp), %rdi
callq 0x2270
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x269c49
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
imulq $0x50, -0x20(%rbp), %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x9850
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x269b9e
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xc52(%rip), %rsi       # 0x26a8b0
callq 0x16d710
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x269cc2
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rdi
imulq $0x50, -0x20(%rbp), %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x9670
movq -0x18(%rbp), %rax
imulq $0x50, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x2210
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x269c6b
movq -0x18(%rbp), %rdi
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)