LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/hic.cpp
// Function: hic_analysis(ma_ug_t*, asg_t*, trans_chain*, ug_opt_t*, mmhap_t**, kvec_pe_hit**)
void hic_analysis(ma_ug_t *ug, asg_t* read_g, trans_chain* t_ch, ug_opt_t *opt, mmhap_t **rh, kvec_pe_hit **rhits)
{
    ug_index = NULL;
    int exist = (asm_opt.load_index_from_disk? 
                    load_hc_pt_index(&ug_index, ug, asm_opt.output_file_name) : 0);
    if(exist == 0) ug_index = build_unitig_index(ug, asm_opt.hic_mer_length, asm_opt.hap_occ, 0, asm_opt.thread_num);
    if(exist == 0) write_hc_pt_index(ug_index, asm_opt.output_file_name);
    ug_index->ug = ug;
    ug_index->read_g = read_g;
    ug_index->t_ch = t_ch;
    ///test_unitig_index(ug_index, ug);
    if(!rh) hic_short_align(asm_opt.hic_reads[0], asm_opt.hic_reads[1], ug_index, opt, rhits);
    else hic_short_align_mmhap(asm_opt.hic_reads[0], asm_opt.hic_reads[1], ug_index, opt, rhits, rh);
    // else hic_short_align_poy(asm_opt.hic_reads[0], asm_opt.hic_reads[1], ug_index, opt);
    
    
    destory_hc_pt_index(ug_index);free(ug_index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, 0x1b7ef5(%rip) # 0x3c55d0
leaq 0x1b7116(%rip), %rax    # 0x3c47f8
cmpl $0x0, 0xf0(%rax)
je 0x20d70b
movq -0x8(%rbp), %rsi
leaq 0x1b7102(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdx
leaq 0x1b7ecf(%rip), %rdi    # 0x3c55d0
callq 0x1c0060
movl %eax, -0x38(%rbp)
jmp 0x20d712
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x20d712
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x20d758
movq -0x8(%rbp), %rdi
leaq 0x1b70cf(%rip), %rax    # 0x3c47f8
movl 0x84(%rax), %esi
leaq 0x1b70c2(%rip), %rax    # 0x3c47f8
movslq 0x1b8(%rax), %rdx
leaq 0x1b70b4(%rip), %rax    # 0x3c47f8
movslq 0x7c(%rax), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x1c1a30
movq %rax, 0x1b7e78(%rip)    # 0x3c55d0
cmpl $0x0, -0x34(%rbp)
jne 0x20d775
movq 0x1b7e6b(%rip), %rdi    # 0x3c55d0
leaq 0x1b708c(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rsi
callq 0x1bfd80
movq -0x8(%rbp), %rcx
movq 0x1b7e50(%rip), %rax    # 0x3c55d0
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x1b7e42(%rip), %rax    # 0x3c55d0
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq 0x1b7e33(%rip), %rax    # 0x3c55d0
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x20d7d4
leaq 0x1b7049(%rip), %rax    # 0x3c47f8
movq 0x50(%rax), %rdi
leaq 0x1b703e(%rip), %rax    # 0x3c47f8
movq 0x58(%rax), %rsi
movq 0x1b7e0b(%rip), %rdx    # 0x3c55d0
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x209b10
jmp 0x20d802
leaq 0x1b701d(%rip), %rax    # 0x3c47f8
movq 0x50(%rax), %rdi
leaq 0x1b7012(%rip), %rax    # 0x3c47f8
movq 0x58(%rax), %rsi
movq 0x1b7ddf(%rip), %rdx    # 0x3c55d0
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x20d140
movq 0x1b7dc7(%rip), %rdi    # 0x3c55d0
callq 0x1c0490
movq 0x1b7dbb(%rip), %rdi    # 0x3c55d0
callq 0x2210
addq $0x40, %rsp
popq %rbp
retq
// File: chhylp123[P]hifiasm/hic.cpp
// Function: ug_occ_hap_w(unsigned long, unsigned long, ma_utg_t*)
uint64_t ug_occ_hap_w(uint64_t is, uint64_t ie, ma_utg_t *u)
{
    uint64_t l, i, us, ue, occ;
    for (i = l = occ = 0; i < u->n; i++) {
        us = l; ue = l + Get_READ_LENGTH(R_INF, (u->a[i]>>33));
        if(is <= us && ie >= ue) {
            if((R_INF.trio_flag[u->a[i]>>33] == FATHER) || (R_INF.trio_flag[u->a[i]>>33] == MOTHER)) {
                occ++;
            }
        }
        if(us >= ie) break;
        l += (uint32_t)u->a[i];
    }
    return occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x20d938
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
leaq 0x1b7a61(%rip), %rcx    # 0x3c52d0
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq -0x28(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
shrq $0x21, %rdx
addq (%rcx,%rdx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x20d901
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x20d901
leaq 0x1b7a26(%rip), %rax    # 0x3c52d0
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x21, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x20d8f3
leaq 0x1b79fe(%rip), %rax    # 0x3c52d0
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x21, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
jne 0x20d8ff
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x20d901
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x20d90d
jmp 0x20d938
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x20d848
movq -0x40(%rbp), %rax
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/hic.cpp
// Function: hic_pre_analysis(ma_ug_t*, asg_t*, trans_chain*, ug_opt_t*, kvec_pe_hit**)
spg_t *hic_pre_analysis(ma_ug_t *ug, asg_t* read_g, trans_chain* t_ch, ug_opt_t *opt, kvec_pe_hit **rhits)
{
    ug_index = NULL;
    int exist = (asm_opt.load_index_from_disk? 
                    load_hc_pt_index(&ug_index, ug, asm_opt.output_file_name) : 0);
    if(exist == 0) ug_index = build_unitig_index(ug, asm_opt.hic_mer_length, asm_opt.hap_occ, 0, asm_opt.thread_num);
    if(exist == 0) write_hc_pt_index(ug_index, asm_opt.output_file_name);
    ug_index->ug = ug;
    ug_index->read_g = read_g;
    ug_index->t_ch = t_ch;
    return hic_short_pre_align(asm_opt.hic_reads[0], asm_opt.hic_reads[1], ug_index, opt, rhits);    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, 0x1b5b89(%rip) # 0x3c55d0
leaq 0x1b4daa(%rip), %rax    # 0x3c47f8
cmpl $0x0, 0xf0(%rax)
je 0x20fa77
movq -0x8(%rbp), %rsi
leaq 0x1b4d96(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdx
leaq 0x1b5b63(%rip), %rdi    # 0x3c55d0
callq 0x1c0060
movl %eax, -0x30(%rbp)
jmp 0x20fa7e
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x20fa7e
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x20fac4
movq -0x8(%rbp), %rdi
leaq 0x1b4d63(%rip), %rax    # 0x3c47f8
movl 0x84(%rax), %esi
leaq 0x1b4d56(%rip), %rax    # 0x3c47f8
movslq 0x1b8(%rax), %rdx
leaq 0x1b4d48(%rip), %rax    # 0x3c47f8
movslq 0x7c(%rax), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x1c1a30
movq %rax, 0x1b5b0c(%rip)    # 0x3c55d0
cmpl $0x0, -0x2c(%rbp)
jne 0x20fae1
movq 0x1b5aff(%rip), %rdi    # 0x3c55d0
leaq 0x1b4d20(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rsi
callq 0x1bfd80
movq -0x8(%rbp), %rcx
movq 0x1b5ae4(%rip), %rax    # 0x3c55d0
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x1b5ad6(%rip), %rax    # 0x3c55d0
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq 0x1b5ac7(%rip), %rax    # 0x3c55d0
movq %rcx, 0x10(%rax)
leaq 0x1b4ce4(%rip), %rax    # 0x3c47f8
movq 0x50(%rax), %rdi
leaq 0x1b4cd9(%rip), %rax    # 0x3c47f8
movq 0x58(%rax), %rsi
movq 0x1b5aa6(%rip), %rdx    # 0x3c55d0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x20aa90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: hap_ID(bench_idx*, unsigned long, unsigned long*, unsigned long*)
void hap_ID(bench_idx* idx, uint64_t ID, uint64_t* hapID, uint64_t* uID)
{
    uint64_t i;
    (*hapID) = (*uID) = (uint64_t)-1;
    for (i = 0; i < idx->ug_idx.n; i++)
    {
        if(ID >= idx->ug_idx.a[i].uID_start && ID < idx->ug_idx.a[i].uID_end)
        {
            (*hapID) = i;
            (*uID) = ID - idx->ug_idx.a[i].uID_start;
            return;
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $-0x1, (%rax)
movq -0x18(%rbp), %rax
movq $-0x1, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2104bd
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
imulq $0x28, -0x28(%rbp), %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jb 0x2104ad
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
imulq $0x28, -0x28(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jae 0x2104ad
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x28(%rbp), %rdx
addq %rdx, %rax
subq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2104bf
jmp 0x2104af
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x210442
jmp 0x2104bf
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: destory_bench_idx(bench_idx*)
void destory_bench_idx(bench_idx* idx)
{
    uint64_t i;
    for (i = 0; i < idx->ug_idx.n; i++)
    {
        free(idx->ug_idx.a[i].r_idx);
    }
    kv_destroy(idx->ug_idx);
    kv_destroy(idx->regions);
    destory_hc_links(&(idx->link));
}

// 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 (%rcx), %rax
jae 0x211488
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 0x211454
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xfcce0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: hic_benchmark(ma_ug_t*, asg_t*)
void hic_benchmark(ma_ug_t *ug, asg_t* read_g)
{
    char *output_file_name = (char*)calloc(strlen(asm_opt.output_file_name) + 25, 1);
	sprintf(output_file_name, "%s.bench", asm_opt.output_file_name);
    ug_index = NULL;
    int exist = load_hc_pt_index(&ug_index, ug, output_file_name);
    if(exist == 0) ug_index = build_unitig_index(ug, asm_opt.hic_mer_length, asm_opt.hap_occ, 0, asm_opt.thread_num);
    if(exist == 0) write_hc_pt_index(ug_index, output_file_name);
    ug_index->ug = ug;
    ug_index->read_g = read_g;

    hic_short_align_bench(asm_opt.hic_reads[0], asm_opt.hic_reads[1], output_file_name, ug_index);

    free(output_file_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1b3161(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x19, %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1b3138(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdx
leaq 0x17c1de(%rip), %rsi    # 0x38d8a9
movb $0x0, %al
callq 0x2050
movq $0x0, 0x1b3ef3(%rip) # 0x3c55d0
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1b3ee4(%rip), %rdi    # 0x3c55d0
callq 0x1c0060
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x211734
movq -0x8(%rbp), %rdi
leaq 0x1b30f3(%rip), %rax    # 0x3c47f8
movl 0x84(%rax), %esi
leaq 0x1b30e6(%rip), %rax    # 0x3c47f8
movslq 0x1b8(%rax), %rdx
leaq 0x1b30d8(%rip), %rax    # 0x3c47f8
movslq 0x7c(%rax), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x1c1a30
movq %rax, 0x1b3e9c(%rip)    # 0x3c55d0
cmpl $0x0, -0x1c(%rbp)
jne 0x21174a
movq 0x1b3e8f(%rip), %rdi    # 0x3c55d0
movq -0x18(%rbp), %rsi
callq 0x1bfd80
movq -0x8(%rbp), %rcx
movq 0x1b3e7b(%rip), %rax    # 0x3c55d0
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x1b3e6d(%rip), %rax    # 0x3c55d0
movq %rcx, 0x8(%rax)
leaq 0x1b308a(%rip), %rax    # 0x3c47f8
movq 0x50(%rax), %rdi
leaq 0x1b307f(%rip), %rax    # 0x3c47f8
movq 0x58(%rax), %rsi
movq -0x18(%rbp), %rdx
movq 0x1b3e48(%rip), %rcx    # 0x3c55d0
callq 0x2114c0
movq -0x18(%rbp), %rdi
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: hc_hash_long(unsigned long*, unsigned long*, unsigned long)
inline uint64_t hc_hash_long(uint64_t x[4], uint64_t* skip, uint64_t k)
{
	///compare forward k-mer and reverse complementary strand
	(*skip) = get_k_direction(x);
    if((*skip) == (uint64_t)-1) return (*skip);
    if (k <= 32) return ((x[(*skip)<<1|0]<<32)|(x[(*skip)<<1|1]));
	return yak_hash64_64(x[(*skip)<<1|0]) + yak_hash64_64(x[(*skip)<<1|1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x214f40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $-0x1, (%rax)
jne 0x212fd1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x213056
cmpq $0x20, -0x20(%rbp)
ja 0x21300e
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shlq %rcx
orq $0x0, %rcx
movq (%rax,%rcx,8), %rax
shlq $0x20, %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
shlq %rdx
orq $0x1, %rdx
orq (%rcx,%rdx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x213056
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shlq %rcx
orq $0x0, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2117c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shlq %rcx
orq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2117c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: chhylp123[P]hifiasm/hic.cpp
// Function: interpret_pos(ha_ug_index const*, s_hit*, unsigned long*, unsigned long*, unsigned long*, unsigned long*, unsigned long*, unsigned long*)
inline void interpret_pos(const ha_ug_index* idx, s_hit *p, uint64_t* rev, uint64_t* uID, 
uint64_t* ref_p, uint64_t* self_p, uint64_t* exact_len, uint64_t* total_len)
{
    (*rev) = p->ref>>63;
    (*uID) = (p->ref << 1) >> (64 - idx->uID_bits);
    (*self_p) = (uint32_t)p->off_cnt;
    ///(*exact_len) = p->off_cnt >> 32;
    (*exact_len) = (p->off_cnt>>32) & ((uint64_t)65535);
    if(total_len != NULL)
    {
        ///(*exact_len) = (p->off_cnt>>32) & ((uint64_t)65535);
        (*total_len) = (p->off_cnt>>48) + (*exact_len);
    }
    if((p->ref & idx->pos_mode)>>(idx->pos_bits - 1))
    {
        (*ref_p) = (*self_p) - (p->ref&(idx->pos_mode>>1));
    }
    else
    {
        (*ref_p) = (*self_p) + (p->ref&(idx->pos_mode));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
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 -0x10(%rbp), %rax
movq (%rax), %rcx
shrq $0x3f, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shlq %rax
movq -0x8(%rbp), %rdx
movl $0x40, %ecx
subq 0x18(%rdx), %rcx
shrq %cl, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %eax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x20, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x18(%rbp)
je 0x213608
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x30, %rcx
movq 0x10(%rbp), %rax
addq (%rax), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
andq 0x30(%rcx), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
shrq %cl, %rax
cmpq $0x0, %rax
je 0x213654
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x30(%rdx), %rdx
shrq %rdx
andq %rdx, %rax
subq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x213674
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
andq 0x30(%rdx), %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: get_phase_status(H_partition*, unsigned int)
inline int get_phase_status(H_partition* hap, uint32_t uID)
{
    int d = -2;
    if(hap->hap[uID] & hap->m[0]) d = 1;
    if(hap->hap[uID] & hap->m[1]) d = -1;
    if(hap->hap[uID] & hap->m[2]) d = 0;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xfffffffe, -0x10(%rbp) # imm = 0xFFFFFFFE
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
andl 0x18(%rcx), %eax
cmpl $0x0, %eax
je 0x214613
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
andl 0x1c(%rcx), %eax
cmpl $0x0, %eax
je 0x214634
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
andl 0x20(%rcx), %eax
cmpl $0x0, %eax
je 0x214655
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: get_k_direction(unsigned long*)
inline uint64_t get_k_direction(uint64_t x[4])
{
    if(x[1] != x[3]) 
    {
        return x[1] < x[3]? 0 : 1;
    }
    else if(x[0] != x[2])
    {
        return x[0] < x[2]? 0 : 1;
    }
    else
    {
        return (uint64_t)-1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x214f7f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovbl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x214fbc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x214fb4
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovbl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x214fbc
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chhylp123[P]hifiasm/hic.cpp
// Function: is_unreliable_hits(long long, long long, long long, unsigned long, trans_chain*)
inline int is_unreliable_hits(long long rev, long long ref_p, long long tLen, uint64_t uID, trans_chain* t_ch)
{
    uint64_t i;
    long long p_beg, p_end;
    bed_in* p = NULL;
    if(rev)
    {
        p_end = ref_p;
        p_beg = p_end + 1 - tLen;
    }
    else
    {
        p_beg = ref_p; 
        p_end = p_beg + tLen - 1;
    }
    if(p_beg < 0) p_beg = 0;
    if(p_end < 0) p_end = 0;

    p = &(t_ch->bed.a[uID]);
    for (i = 0; i < p->n; i++)
    {
        if(inter_interval(p_beg, p_end, p->a[i].beg, p->a[i].end, NULL, NULL)) break;
    }
    if(p->n > 0 && i < p->n) return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x215415
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
subq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x21542d
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x40(%rbp)
jge 0x21543c
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x21544b
movq $0x0, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2154d5
movq -0x40(%rbp), %rax
movl %eax, %edi
movq -0x48(%rbp), %rax
movl %eax, %esi
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, %edx
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x1670e0
cmpl $0x0, %eax
je 0x2154c5
jmp 0x2154d5
jmp 0x2154c7
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x215467
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x2154f5
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2154f5
movl $0x1, -0x4(%rbp)
jmp 0x2154fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: mc_opt_init(mc_opt_t*, int, double, unsigned long)
void mc_opt_init(mc_opt_t *opt, int32_t n_perturb, double f_perturb, uint64_t seed)
{
	memset(opt, 0, sizeof(mc_opt_t));
	opt->n_perturb = n_perturb;
	opt->f_perturb = f_perturb;
	opt->max_iter = 1000;
	opt->seed = seed;
	opt->n_s_perturb = n_perturb;
	opt->n_b_perturb = n_perturb*0.5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2100
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x3e8, (%rax)          # imm = 0x3E8
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0x16baf3(%rip), %xmm1   # 0x382270
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: mc_merge_dup(mc_g_t*)
void mc_merge_dup(mc_g_t *mg) // MUST BE sorted
{
	uint32_t i, j, k, st;
	w_t w;
	for (st = 0, i = 1, k = 0; i <= mg->e->ma.n; ++i) {
		if (i == mg->e->ma.n || mg->e->ma.a[i].x != mg->e->ma.a[st].x) {
			if (i - st > 1) {
				for (j = st, w = 0; j < i; ++j) {
					w += mg->e->ma.a[j].w;
				}
				mg->e->ma.a[k] = mg->e->ma.a[st];
				mg->e->ma.a[k++].w = w;
			} else mg->e->ma.a[k++] = mg->e->ma.a[st];
			st = i;
		}
	}
	mg->e->ma.n = k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x18(%rcx), %rax
ja 0x216930
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x18(%rcx), %rax
je 0x21681b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq 0x28(%rcx), %rcx
movl -0x18(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
je 0x216920
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x1, %eax
jbe 0x2168d6
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x216870
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movl -0x10(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x216838
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rcx
movl -0x18(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
jmp 0x21691a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rcx
movl -0x18(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movl %edx, %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x216922
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2167bd
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: init_mc_g_t(ma_ug_t*, asg_t*, signed char*, unsigned int)
mc_g_t *init_mc_g_t(ma_ug_t *ug, asg_t *read_g, int8_t *s, uint32_t renew_s)
{
	mc_g_t *p = NULL; CALLOC(p, 1);
	p->ug = ug;
	p->rg = read_g;
	kv_init(p->s);
	if(s)
	{
		p->s.a = s;
		p->s.n = ug->g->n_seq;
		p->s.m = 0;
		if(renew_s) memset(p->s.a, 0, p->s.n);
	}
	else
	{
		CALLOC(p->s.a, ug->g->n_seq);
		p->s.n = p->s.m = ug->g->n_seq;
	} 
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2140
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x216ca5
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x216ca3
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
xorl %esi, %esi
callq 0x2100
jmp 0x216cf1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x2140
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: get_mb_edge(mb_match_t const*, unsigned int, unsigned int)
static mb_edge_t *get_mb_edge(const mb_match_t *ma, uint32_t sid1, uint32_t sid2)
{
	mb_edge_t *o = pt_a(*ma, sid1);
	uint32_t n = pt_n(*ma, sid1), k;
	for (k = 0; k < n; ++k)
		if (((uint32_t)o[k].x) == sid2)
			return &(o[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 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%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 0x2171fc
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpl -0x18(%rbp), %eax
jne 0x2171ef
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x217204
jmp 0x2171f1
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2171bd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: mb_edges_idx(mb_match_t*)
static void mb_edges_idx(mb_match_t *ma)
{
	uint32_t st, i;
	kv_resize(uint64_t, ma->idx, ma->n_seq);
	ma->idx.n = ma->n_seq;
	memset(ma->idx.a, 0, ma->idx.n*sizeof(uint64_t));
	for (st = 0, i = 1; i <= ma->ma.n; ++i)
		if (i == ma->ma.n || (ma->ma.a[i].x>>32) != (ma->ma.a[st].x>>32))
			ma->idx.a[ma->ma.a[st].x>>32] = (uint64_t)st << 32 | (i - st), st = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %ecx
cmpq %rcx, %rax
jae 0x218c80
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, %ecx
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
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x218c82
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2100
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x218d5e
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x218d0f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
shrq $0x20, %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0xc(%rbp), %edx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
shrq $0x20, %rcx
cmpq %rcx, %rax
je 0x218d4e
movl -0xc(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, %eax
orq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0xc(%rbp), %esi
imulq $0x28, %rsi, %rsi
addq %rsi, %rcx
movq (%rcx), %rcx
shrq $0x20, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x218d50
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x218cba
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: mb_edges_symm(mb_match_t*)
uint32_t mb_edges_symm(mb_match_t *ma)
{
	uint8_t *del = NULL;
	uint32_t i, k, n = 0;
	mb_edge_t *t = NULL, *m = NULL;
	CALLOC(del, ma->ma.n);

	for (i = 0; i < ma->ma.n; ++i) {
		m = &ma->ma.a[i];
		if (ma_x(*m) == ma_y(*m))
		{
			del[i] = 1, ++n;///self overlap
			continue;
		}
		t = get_mb_edge(ma, ma_y(*m), ma_x(*m));
		if(!t)
		{
			del[i] = 1, ++n;///self overlap
			continue;
		} 
		normalize_mb_edge(m, t);
	}

	if (n > 0) {
		for (i = k = 0; i < ma->ma.n; ++i)
			if (!del[i]) ma->ma.a[k++] = ma->ma.a[i];
		ma->ma.n = k;
		mb_edges_idx(ma);
	}

	free(del);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x218e69
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x218e0e
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x218e5b
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movl %eax, %edx
callq 0x217170
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x218e4e
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x218e5b
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x219580
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x218db8
cmpl $0x0, -0x1c(%rbp)
jbe 0x218ef6
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x218ee0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x218ed3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl -0x14(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movl %eax, %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movl $0x28, %edx
callq 0x2180
jmp 0x218ed5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x218e81
movl -0x18(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x218b90
movq -0x10(%rbp), %rdi
callq 0x2210
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: destory_mc_g_t(mc_g_t**)
void destory_mc_g_t(mc_g_t **p)
{
	if(!p || !(*p)) return;
	if((*p)->s.m == 0) (*p)->s.a = NULL;
	kv_destroy((*p)->s);
	if((*p)->e)
	{
		kv_destroy((*p)->e->idx);
		kv_destroy((*p)->e->ma);
		free((*p)->e->cc);
		free((*p)->e);
	}
	free((*p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x218f2d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x218f32
jmp 0x218fc5
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x218f4f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x218fb9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: destory_mb_g_t(mb_g_t**)
void destory_mb_g_t(mb_g_t **p)
{
	if(!p || !(*p)) return;
	kv_destroy((*p)->e->idx);
	kv_destroy((*p)->e->ma);
	free((*p)->e->cc);
	free((*p)->e);

	kv_destroy((*p)->u->bid);
	kv_destroy((*p)->u->idx);
	kv_destroy((*p)->u->u);
	free((*p)->u);

	free((*p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x218fed
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x218ff2
jmp 0x219092
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: mc_edges_symm(mc_match_t*)
uint32_t mc_edges_symm(mc_match_t *ma)
{
	uint8_t *del = NULL;
	uint32_t i, k, n = 0;
	mc_edge_t *t = NULL, *m = NULL;
	CALLOC(del, ma->ma.n);

	for (i = 0; i < ma->ma.n; ++i) {
		m = &ma->ma.a[i];
		if (ma_x(*m) == ma_y(*m))
		{
			del[i] = 1, ++n;///self overlap
			continue;
		}
		t = get_mc_edge(ma, ma_y(*m), ma_x(*m));
		if(!t)
		{
			del[i] = 1, ++n;///self overlap
			continue;
		} 
		normalize_mc_edge(m, t);
	}

	if (n > 0) {
		for (i = k = 0; i < ma->ma.n; ++i)
			if (!del[i]) ma->ma.a[k++] = ma->ma.a[i];
		ma->ma.n = k;
		mc_edges_idx(ma);
	}

	free(del);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x219199
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x21913e
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21918b
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movl %eax, %edx
callq 0x219240
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x21917e
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21918b
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2192e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2190e8
cmpl $0x0, -0x1c(%rbp)
jbe 0x21922a
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x219214
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x219207
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movl -0x14(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x18(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl %edx, %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x219209
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2191b1
movl -0x18(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x2193a0
movq -0x10(%rbp), %rdi
callq 0x2210
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: get_mc_edge(mc_match_t const*, unsigned int, unsigned int)
static mc_edge_t *get_mc_edge(const mc_match_t *ma, uint32_t sid1, uint32_t sid2)
{
	mc_edge_t *o = pt_a(*ma, sid1);
	uint32_t n = pt_n(*ma, sid1), k;
	for (k = 0; k < n; ++k)
		if (((uint32_t)o[k].x) == sid2)
			return &(o[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 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%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 0x2192cc
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpl -0x18(%rbp), %eax
jne 0x2192bf
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2192d4
jmp 0x2192c1
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x21928d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: normalize_mc_edge(mc_edge_t*, mc_edge_t*)
static void normalize_mc_edge(mc_edge_t *a, mc_edge_t *b)
{
	if(a->w >= b->w)
	{
		b->x = (uint32_t)a->x;
		b->x <<= 32;
		b->x |= (a->x>>32);
		b->w = a->w;
	}
	else
	{
		a->x = (uint32_t)b->x;
		a->x <<= 32;
		a->x |= (b->x>>32);
		a->w = b->w;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jb 0x219349
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
shlq $0x20, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
shrq $0x20, %rcx
movq -0x10(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x219390
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
shlq $0x20, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: normalize_mb_edge(mb_edge_t*, mb_edge_t*)
static void normalize_mb_edge(mb_edge_t *a, mb_edge_t *b)
{
	if(a->w >= b->w)
	{
		b->x = (uint32_t)a->x;
		b->x <<= 32;
		b->x |= (a->x>>32);
		b->w[0] = a->w[0];
		b->w[3] = a->w[3];
		b->w[1] = a->w[2];
		b->w[2] = a->w[1];
	}
	else
	{
		a->x = (uint32_t)b->x;
		a->x <<= 32;
		a->x |= (b->x>>32);
		a->w[0] = b->w[0];
		a->w[3] = b->w[3];
		a->w[1] = b->w[2];
		a->w[2] = b->w[1];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jb 0x219620
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
shlq $0x20, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
shrq $0x20, %rcx
movq -0x10(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0x21969d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
shlq $0x20, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: destroy_mc_bp_t(mc_bp_t**)
void destroy_mc_bp_t(mc_bp_t **bp)
{
	uint32_t i;
	for (i = 0; i < (*bp)->n_thread; i++)
	{
		free((*bp)->vis[i].a);
	}
	free((*bp)->idx);
	free((*bp)->res);
	free((*bp)->lock);
	free((*bp));
}

// 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
movq (%rcx), %rcx
cmpq 0x20(%rcx), %rax
jae 0x21b9ec
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x21b9b3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/rcut.cpp
// Function: mc_svaux_destroy(mc_svaux_t*)
void mc_svaux_destroy(mc_svaux_t *b)
{
	b->s = NULL;
	kv_destroy(b->cc_edge); free(b->cc_node);
	free(b->s); free(b->s_opt);
	free(b->z); free(b->z_opt);
	free(b->bfs); free(b->bfs_mark);
	free(b->f);
	free(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)