LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/./Correct.h
// Function: InitHaplotypeEvdience(haplotype_evdience_alloc*)
inline void InitHaplotypeEvdience(haplotype_evdience_alloc* h)
{
    
    h->overlap = 0;
    h->snp_matrix_size = 0;   
    h->snp_matrix = NULL;
    h->r_snp_size = 0;
    h->r_snp = NULL;
    kv_init(h->snp_stat);
    kv_init(h->snp_srt);
    h->nn_snp = 0;
    // h->snp_stat = NULL;
    // h->snp = 0;
    // h->snp_stat_size = 0;
    // h->available_snp = 0;


    h->sub_list_start = 0;
    h->sub_list_length = 0;
    h->length = 0;
    h->size = 100;
    h->list = (haplotype_evdience*)calloc(h->size, sizeof(haplotype_evdience));

    /****************************may have bugs********************************/
    memset(h->flag, 0, WINDOW_MAX_SIZE * sizeof(uint8_t));
    /****************************may have bugs********************************/


    // h->dp.max = NULL;
    // h->dp.colum = NULL;
    // h->dp.colum_len = NULL;
    // h->dp.matrix_size = 0;
    // h->dp.snp_num = 0;
    // h->dp.snp_size = 0;
    h->dp.snp_num = 0;
    h->dp.max = NULL;
    h->dp.max_for_sort = NULL;
    h->dp.visit = NULL;
    h->dp.snp_size = 0;
    h->dp.backtrack = NULL;
    h->dp.backtrack_size = 0;
    h->dp.backtrack_length = NULL;
    h->dp.buffer = NULL;
    h->dp.max_buffer = NULL;

    init_SNP_IDs(&(h->dp.SNP_IDs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1d8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1d0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1e8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x228(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x218(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x240(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x238(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x248(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x230(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x64, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edi
movl $0x18, %esi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x2100
movq -0x8(%rbp), %rax
movl $0x0, 0x250(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x260(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x268(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x258(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x270(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x280(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x288(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x278(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x290(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x298(%rax)
movq -0x8(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
addq $0x60, %rdi
callq 0x1c7e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/./Correct.h
// Function: destoryHaplotypeEvdience(haplotype_evdience_alloc*)
inline void destoryHaplotypeEvdience(haplotype_evdience_alloc* h)
{
    free(h->list);
    // free(h->snp_stat);
    kv_destroy(h->snp_stat);
    kv_destroy(h->snp_srt);
    free(h->snp_matrix);
    free(h->r_snp);
    free(h->dp.backtrack);
    free(h->dp.max);
    free(h->dp.max_for_sort);
    free(h->dp.visit);
    free(h->dp.backtrack_length);
    free(h->dp.buffer);
    free(h->dp.max_buffer);
    destory_SNP_IDs(&(h->dp.SNP_IDs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x248(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x280(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x290(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x298(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
addq $0x60, %rdi
callq 0x1c870
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chhylp123[P]hifiasm/./Correct.h
// Function: if_exact_match(char*, long long, char*, long long, long long, long long, long long, long long)
inline int if_exact_match(char* x, long long xLen, char* y, long long yLen, long long xBeg, long long xEnd, long long yBeg, long long yEnd)
{
    long long overlapLen = xEnd - xBeg + 1;

    if(yEnd - yBeg + 1 == overlapLen)
    {
        if(memcmp(x+xBeg, y+yBeg, overlapLen)==0) return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rax
subq 0x10(%rbp), %rax
addq $0x1, %rax
cmpq -0x40(%rbp), %rax
jne 0x1c683
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq 0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x20b0
cmpl $0x0, %eax
jne 0x1c681
movl $0x1, -0x4(%rbp)
jmp 0x1c68a
jmp 0x1c683
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chhylp123[P]hifiasm/./Correct.h
// Function: init_SNP_IDs(Snp_ID_Vector_Alloc*)
inline void init_SNP_IDs(Snp_ID_Vector_Alloc* SNP_IDs)
{
    SNP_IDs->max_snp_id = -1;
    SNP_IDs->buffer_length = 0;
    SNP_IDs->buffer_size = 1000;
    SNP_IDs->buffer = (uint32_t*)malloc(sizeof(uint32_t) * SNP_IDs->buffer_size);

    SNP_IDs->IDs_length = 0;
    SNP_IDs->IDs_size = 10;
    SNP_IDs->IDs = (Snp_ID_Vector*)calloc(SNP_IDs->IDs_size, sizeof(Snp_ID_Vector));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x3e8, 0x20(%rax)      # imm = 0x3E8
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
shlq $0x2, %rdi
callq 0x2270
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0xa, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1c, %esi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chhylp123[P]hifiasm/Assembly.cpp
// Function: get_cigar_errors(Cigar_record*)
inline int get_cigar_errors(Cigar_record* cigar)
{
    int i;
    int total_errors = 0;
    for (i = 0; i < (long long)cigar->length; i++)
    {
        if (Get_Cigar_Type(cigar->record[i]) > 0)
        {
            total_errors = total_errors + Get_Cigar_Length(cigar->record[i]);
        }
    }
    return total_errors;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x1ca92
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jbe 0x1ca85
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
shrl $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x1ca87
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ca46
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: init_overlap_region_alloc(overlap_region_alloc*)
void init_overlap_region_alloc(overlap_region_alloc* list)
{
    list->size = 1000;
    list->length = 0;
    ///list->list = (overlap_region*)malloc(sizeof(overlap_region)*list->size);
    list->list = (overlap_region*)calloc(list->size, sizeof(overlap_region));
    uint64_t i;
    for (i = 0; i < list->size; i++) { 
        init_fake_cigar(&(list->list[i].f_cigar));
        init_window_list_alloc(&(list->list[i].w_list));
        init_window_list_alloc(&(list->list[i].boundary_cigars));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x3e8, 0x8(%rax)       # imm = 0x3E8
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xa8, %esi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1e0b5
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x38, %rdi
callq 0x1e0c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x48, %rdi
callq 0x1e0f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x78, %rdi
callq 0x1e0f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e048
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: clear_overlap_region_alloc(overlap_region_alloc*)
void clear_overlap_region_alloc(overlap_region_alloc* list)
{
    list->length = 0;
    list->mapped_overlaps_length = 0;
    uint64_t i = 0;
    for (i = 0; i < list->size; i++) {   
        clear_fake_cigar(&(list->list[i].f_cigar));
        clear_window_list_alloc(&(list->list[i].w_list));
        clear_window_list_alloc(&(list->list[i].boundary_cigars));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1e1c1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x38, %rdi
callq 0x1e1d0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x48, %rdi
callq 0x1e1f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x78, %rdi
callq 0x1e1f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e154
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: destory_overlap_region_alloc(overlap_region_alloc*)
void destory_overlap_region_alloc(overlap_region_alloc* list)
{
    uint64_t i = 0;
    for (i = 0; i < list->size; i++) {
        destory_fake_cigar(&(list->list[i].f_cigar));
        destory_window_list_alloc(&(list->list[i].w_list));
        destory_window_list_alloc(&(list->list[i].boundary_cigars));
    }
    free(list->list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1e2a9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x38, %rdi
callq 0x1e2c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x48, %rdi
callq 0x1e2f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0xa8, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x78, %rdi
callq 0x1e2f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e23c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: get_fake_gap_shift(Fake_Cigar*, int)
int get_fake_gap_shift(Fake_Cigar* x, int index)
{
    uint32_t tmp = ((uint32_t)(x->buffer[index]));
    int result;
    if(tmp & ((uint32_t)1))
    {
        tmp = tmp >> 1;
        result = tmp;
        result = result * -1;
    }
    else
    {
        tmp = tmp >> 1;
        result = tmp;
    }
    
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1e37f
movl -0x10(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $-0x1, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1e38d
movl -0x10(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: gen_fake_cigar(Fake_Cigar*, overlap_region*, long, k_mer_hit*, long)
void gen_fake_cigar(Fake_Cigar* z, overlap_region *o, int64_t apend_be, k_mer_hit* hit, int64_t n_hit)
{
    int64_t k, dq, dr, dd, pdd; z->length = 0;
    if(apend_be == 1) add_fake_cigar(z, o->x_pos_s, 0, NULL);
    for (k = 0, pdd = INT32_MAX; k < n_hit; k++) {
        dq = hit[k].self_offset - o->x_pos_s; 
        dr = hit[k].offset - o->y_pos_s; 
        dd = dr - dq;
        // if(print) {
        //     fprintf(stderr, "[M::k->%lu] x::%u, y::%u, cnt::%u, dd::%ld, pdd::%ld, z->n::%u\n", 
        //         k, hit[k].self_offset, hit[k].offset, hit[k].cnt&(0xffu), dd, pdd, z->length);
        // }
        if(dd != pdd) {
            pdd = dd;
            add_fake_cigar(z, hit[k].self_offset, pdd, NULL);
        }
    }
    
    if((apend_be == 1) && (get_fake_gap_pos(z, z->length-1)!=((int64_t)o->x_pos_e))) {
        add_fake_cigar(z, o->x_pos_e, get_fake_gap_shift(z, z->length-1), NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
cmpq $0x1, -0x18(%rbp)
jne 0x1e3e4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1e500
movq $0x0, -0x30(%rbp)
movq $0x7fffffff, -0x50(%rbp) # imm = 0x7FFFFFFF
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x1e496
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x1e483
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
movq -0x50(%rbp), %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1e500
jmp 0x1e485
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1e3f4
cmpq $0x1, -0x18(%rbp)
jne 0x1e4f5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
subl $0x1, %esi
callq 0x1e320
cltq
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
je 0x1e4f5
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
subl $0x1, %esi
callq 0x1e340
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1e500
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: resize_fake_cigar(Fake_Cigar*, unsigned long, void*)
void resize_fake_cigar(Fake_Cigar* x, uint64_t size, void *km)
{
    if (size > x->size) {
        x->size = size;
        if(!km) {
            REALLOC(x->buffer, x->size);
        }
        else {
            KREALLOC(km, x->buffer, x->size);
        }
		
    }
    x->length = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x1f896
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x1f86d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1f894
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x30e740
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1f896
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: append_overlap_region_alloc_debug(overlap_region_alloc*, overlap_region*)
void append_overlap_region_alloc_debug(overlap_region_alloc* list, overlap_region* tmp)
{
   
    if (list->length + 1 > list->size)
    {
        list->size = list->size * 2;
        list->list = (overlap_region*)realloc(list->list, sizeof(overlap_region)*list->size);
    }

    
    list->list[list->length].x_id = tmp->x_id;
    list->list[list->length].x_pos_e = tmp->x_pos_e;
    list->list[list->length].x_pos_s = tmp->x_pos_s;
    list->list[list->length].x_pos_strand = tmp->x_pos_strand;

    list->list[list->length].y_id = tmp->y_id;
    list->list[list->length].y_pos_e = tmp->y_pos_e;
    list->list[list->length].y_pos_s = tmp->y_pos_s;
    list->list[list->length].y_pos_strand = tmp->y_pos_strand;

    list->list[list->length].shared_seed = tmp->shared_seed;

    list->length++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x20fab
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq -0x8(%rbp), %rax
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 -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0xa8, 0x10(%rdx), %rdx
addq %rdx, %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: get_chainLen(long long, long long, long long, long long, long long, long long)
long long get_chainLen(long long x_beg, long long x_end, long long xLen, 
                       long long y_beg, long long y_end, long long yLen)
{
    if(x_beg <= y_beg)
    {
        y_beg = y_beg - x_beg;
        x_beg = 0;
    }
    else
    {
        x_beg = x_beg - y_beg;
        y_beg = 0;
    }

    long long x_right_length = xLen - x_end - 1;
    long long y_right_length = yLen - y_end - 1;


    if(x_right_length <= y_right_length)
    {
        x_end = xLen - 1;
        y_end = y_end + x_right_length;        
    }
    else
    {
        x_end = x_end + y_right_length;
        y_end = yLen - 1;
    }

    return x_end - x_beg + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jg 0x215bc
movq -0x20(%rbp), %rax
subq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x215d0
movq -0x8(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x21614
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2162c
movq -0x10(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
addq $0x1, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: append_window_list(overlap_region*, unsigned long, unsigned long, int, int, int, int, int, int, int, void*)
void append_window_list(overlap_region* region, uint64_t x_start, uint64_t x_end, int y_start, int y_end, int error,
                        int extra_begin, int extra_end, int error_threshold, int blockLen, void *km)
{
    window_list *p = NULL;
    kv_pushp(window_list, region->w_list, &p);

    p->x_start = x_start;
    p->x_end = x_end;
    p->y_start = y_start;
    p->y_end = y_end;
    p->error = error;
    p->extra_begin = extra_begin;
    p->extra_end = extra_end;
    p->error_threshold = error_threshold;
    p->cidx = p->clen = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x22da0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x22d65
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x22d70
movl $0x2, %eax
movq %rax, -0x38(%rbp)
jmp 0x22d70
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
shlq $0x5, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x48(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x48(%rdx)
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x24(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x14(%rax)
movl 0x10(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x10(%rax)
movl 0x18(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x12(%rax)
movl 0x20(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: test_single_list(Candidates_list*, k_mer_pos*, unsigned long, unsigned long, unsigned long)
void test_single_list(Candidates_list* candidates, k_mer_pos* n_list, uint64_t n_lengh, uint64_t end_pos, uint64_t strand)
{
    uint64_t i;
    long long j = 0;
    for (i = 0; i < n_lengh; i++)
    {
        
        for (; j < candidates->length; j++)
        {
            if (
                n_list[i].offset == (uint64_t)candidates->list[j].offset
                &&
                n_list[i].readID == candidates->list[j].readID
                &&
                end_pos == (uint64_t)candidates->list[j].self_offset
                &&
                strand == candidates->list[j].strand
            )
            {
                break;
            }   
        }

        if (j == candidates->length)
        {
            fprintf(stderr, "ERROR 4\n");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x22f80
jmp 0x22e8c
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x22f47
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x38(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jne 0x22f34
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x38(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jne 0x22f34
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x38(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
cmpq %rcx, %rax
jne 0x22f34
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x38(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl (%rcx), %ecx
shrl $0x1f, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jne 0x22f34
jmp 0x22f47
jmp 0x22f36
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x22e8c
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x22f6d
movq 0x3a1084(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x35f28a(%rip), %rsi    # 0x3821f0
movb $0x0, %al
callq 0x22a0
jmp 0x22f6f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x22e7c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: destory_Chain_Data(Chain_Data*)
void destory_Chain_Data(Chain_Data* x)
{
    free(x->score);
    free(x->pre);
    free(x->indels);
    free(x->self_length);
    free(x->occ);
	free(x->tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: init_Candidates_list(Candidates_list*)
void init_Candidates_list(Candidates_list* l)
{
    l->length = 0;
    l->size = 0;
    l->list = NULL;
    init_Chain_Data(&(l->chainDP));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x22f90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: destory_Candidates_list_buf(void*, Candidates_list*, int)
void destory_Candidates_list_buf(void *km, Candidates_list* l, int is_z)
{
    kfree(km, l->list);
    kfree(km, l->chainDP.score);
    kfree(km, l->chainDP.pre);
    kfree(km, l->chainDP.indels);
    kfree(km, l->chainDP.self_length);
    kfree(km, l->chainDP.occ);
    kfree(km, l->chainDP.tmp);
    if(is_z) memset(l, 0, sizeof(*l));
}

// 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
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x30e2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x30e2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x30e2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x30e2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x30e2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x30e2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x30e2d0
cmpl $0x0, -0x14(%rbp)
je 0x2318f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: cal_bw(k_mer_hit const*, k_mer_hit const*, double, long, long)
inline int32_t cal_bw(const k_mer_hit *ai, const k_mer_hit *aj, double bw_rate, int64_t sf_l, int64_t ot_l)
{
    ///ai is the suffix of aj
    int64_t sf_s = aj->self_offset, sf_e = ai->self_offset + 1;
    int64_t ot_s = aj->offset, ot_e = ai->offset + 1;
    int64_t sf_r = sf_l - sf_e, ot_r = ot_l - ot_e;
    if(sf_s <= ot_s) sf_s = 0;
    else sf_s -= ot_s;

    if(sf_r <= ot_r) sf_e = sf_l;
    else sf_e += ot_r;

    return (sf_e - sf_s)*bw_rate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
subq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x2b36b
movq $0x0, -0x30(%rbp)
jmp 0x2b37a
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jg 0x2b38e
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x2b39a
movq -0x58(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
cvtsi2sd %rax, %xmm0
mulsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chhylp123[P]hifiasm/Hash_Table.cpp
// Function: hit_long_gap(k_mer_hit*, k_mer_hit*, long, double, long)
inline int64_t hit_long_gap(k_mer_hit *a, k_mer_hit *b, int64_t max_lgap, double small_bw_rate, int64_t min_small_bw)
{
    int64_t dq, dr, dd, dm;
    dq = b->self_offset-a->self_offset;
    dr = b->offset-a->offset;
	dd = dq>=dr? ((dq)-(dr)): ((dr)-(dq));
    if(max_lgap>=0) {
        if(dd <= max_lgap) return 1;
        return 0;
    } else {
        dm = dq>=dr?dr:dq;
        if((dd > (dm*small_bw_rate)) && (dd > min_small_bw)) return 0;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jl 0x2b819
movq -0x38(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x2b825
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x2b852
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jg 0x2b848
movq $0x1, -0x8(%rbp)
jmp 0x2b8a9
movq $0x0, -0x8(%rbp)
jmp 0x2b8a9
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jl 0x2b866
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x2b86e
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
cvtsi2sdq -0x48(%rbp), %xmm0
cvtsi2sdq -0x50(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2b8a1
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x2b8a1
movq $0x0, -0x8(%rbp)
jmp 0x2b8a9
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/POA.cpp
// Function: init_Edge_alloc(Edge_alloc*)
void init_Edge_alloc(Edge_alloc* list)
{
	if (list->list == NULL) {
		list->size = INIT_EDGE_SIZE;
		list->length = 0;
		list->delete_length = 0;
		list->list = (Edge*)malloc(sizeof(Edge)*list->size);
	} else {
		list->length = 0;
		list->delete_length = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2b904
movq -0x8(%rbp), %rax
movq $0x32, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
imulq $0x38, 0x8(%rax), %rdi
callq 0x2270
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2b91c
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/POA.cpp
// Function: append_Edge_alloc(Edge_alloc*, unsigned long, unsigned long, unsigned long, unsigned long)
void append_Edge_alloc(Edge_alloc* list,  uint64_t in_node, uint64_t out_node, uint64_t weight, uint64_t length)
{
	if (list->length + 1 > list->size) {
		uint64_t old_size = list->size;
		list->size = list->size + INCREASE_EDGE_SIZE;
		list->list = (Edge*)realloc(list->list, sizeof(Edge)*list->size);
		memset(&list->list[old_size], 0, (list->size - old_size) * sizeof(Edge));
	}

	list->list[list->length].in_node = in_node;
	list->list[list->length].out_node = out_node;
	list->list[list->length].weight = weight;
	list->list[list->length].length = length;
	list->list[list->length].num_insertions = 0;
	list->list[list->length].self_edge_ID = list->length;

	list->length++;
}

// 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 -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x2ba27
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x5, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x38, 0x8(%rax), %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0x38, -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x30(%rbp), %rax
imulq $0x38, %rax, %rdx
xorl %esi, %esi
callq 0x2100
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x38, 0x10(%rdx), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x38, 0x10(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x38, 0x10(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x38, 0x10(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
imulq $0x38, 0x10(%rcx), %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
imulq $0x38, 0x10(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/POA.cpp
// Function: add_and_check_bi_direction_edge(Graph*, Node*, Node*, unsigned long, unsigned long)
int add_and_check_bi_direction_edge(Graph* graph, Node* in_node, Node* out_node, uint64_t weight, uint64_t flag)
{
    Edge* e_forward;
    Edge* e_backward;

    //if there are no edge from in_node to out_node
    if(!get_bi_Edge(graph, in_node, out_node, &e_forward, &e_backward))
    {
        append_Edge_alloc(&(Output_Edges((*in_node))), (*in_node).ID, (*out_node).ID, weight, flag);
        append_Edge_alloc(&(Input_Edges((*out_node))), (*in_node).ID, (*out_node).ID, weight, flag);

        Output_Edges((*in_node)).list[Output_Edges((*in_node)).length - 1].reverse_edge_ID 
        = Input_Edges((*out_node)).length - 1;

        Input_Edges((*out_node)).list[Input_Edges((*out_node)).length - 1].reverse_edge_ID
        = Output_Edges((*in_node)).length - 1;

        return 1;
    }
    else//if there is an edge from in_node to out_node, do nothing
    {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x2c680
cmpq $0x0, %rax
jne 0x2bbd4
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x2b990
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x2b990
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x50(%rdx), %rdx
subq $0x1, %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
subq $0x1, %rcx
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rdx
movq 0x70(%rdx), %rdx
subq $0x1, %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x30(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2bbdb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/POA.cpp
// Function: add_bi_direction_edge(Graph*, Node*, Node*, unsigned long, unsigned long)
void add_bi_direction_edge(Graph* graph, Node* in_node, Node* out_node, uint64_t weight, uint64_t flag)
{

    append_Edge_alloc(&(Output_Edges((*in_node))), (*in_node).ID, (*out_node).ID, weight, flag);
    append_Edge_alloc(&(Input_Edges((*out_node))), (*in_node).ID, (*out_node).ID, weight, flag);

    Output_Edges((*in_node)).list[Output_Edges((*in_node)).length - 1].reverse_edge_ID 
    = Input_Edges((*out_node)).length - 1;

    Input_Edges((*out_node)).list[Input_Edges((*out_node)).length - 1].reverse_edge_ID
    = Output_Edges((*in_node)).length - 1;
}

// 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 -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2b990
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2b990
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x50(%rdx), %rdx
subq $0x1, %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x70(%rdx), %rdx
subq $0x1, %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/POA.cpp
// Function: remove_and_check_bi_direction_edge_from_nodes(Graph*, Node*, Node*)
int remove_and_check_bi_direction_edge_from_nodes(Graph* graph, Node* in_node, Node* out_node)
{
    Edge* e_forward;
    Edge* e_backward;

    //if there are no edge from in_node to out_node
    //1. remove these two edges
    //2. increase the edge_list.delete_length in both in_node and out_node
    if(get_bi_Edge(graph, in_node, out_node, &e_forward, &e_backward))
    {
        e_forward->in_node = (uint64_t)-1;
        e_forward->out_node = (uint64_t)-1;
        e_forward->weight = (uint64_t)-1;
        e_forward->length = (uint64_t)-1;
        e_forward->num_insertions = (uint64_t)-1;
        e_forward->self_edge_ID = (uint64_t)-1;
        e_forward->reverse_edge_ID = (uint64_t)-1;


        e_backward->in_node = (uint64_t)-1;
        e_backward->out_node = (uint64_t)-1;
        e_backward->weight = (uint64_t)-1;
        e_backward->length = (uint64_t)-1;
        e_backward->num_insertions = (uint64_t)-1;
        e_backward->self_edge_ID = (uint64_t)-1;
        e_backward->reverse_edge_ID = (uint64_t)-1;

        Output_Edges(*in_node).delete_length++;
        Input_Edges((*out_node)).delete_length++;

        return 1;
    }
    else//if there is an edge from in_node to out_node, do nothing
    {
        return 0;
    }
}

// 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
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x2c680
cmpq $0x0, %rax
je 0x2bdb6
movq -0x28(%rbp), %rax
movq $-0x1, (%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x28(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x30(%rax)
movq -0x30(%rbp), %rax
movq $-0x1, (%rax)
movq -0x30(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $-0x1, 0x20(%rax)
movq -0x30(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x30(%rbp), %rax
movq $-0x1, 0x28(%rax)
movq -0x30(%rbp), %rax
movq $-0x1, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x78(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2bdbd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/POA.cpp
// Function: remove_and_check_bi_direction_edge_from_edge(Graph*, Edge*)
int remove_and_check_bi_direction_edge_from_edge(Graph* graph, Edge* e)
{
    Edge* e_forward;
    Edge* e_backward;

    if(If_Edge_Exist(*e))
    {
        get_bi_direction_edges(graph, e, &e_forward, &e_backward);
        Output_Edges(G_Node(*graph, e_forward->in_node)).delete_length++;
        Input_Edges(G_Node(*graph, e_forward->out_node)).delete_length++;

        e_forward->in_node = (uint64_t)-1;
        e_forward->out_node = (uint64_t)-1;
        e_forward->weight = (uint64_t)-1;
        e_forward->length = (uint64_t)-1;
        e_forward->num_insertions = (uint64_t)-1;
        e_forward->self_edge_ID = (uint64_t)-1;
        e_forward->reverse_edge_ID = (uint64_t)-1;


        e_backward->in_node = (uint64_t)-1;
        e_backward->out_node = (uint64_t)-1;
        e_backward->weight = (uint64_t)-1;
        e_backward->length = (uint64_t)-1;
        e_backward->num_insertions = (uint64_t)-1;
        e_backward->self_edge_ID = (uint64_t)-1;
        e_backward->reverse_edge_ID = (uint64_t)-1;

        return 1;
    }
    else
    {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
je 0x2bef8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x2c720
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, (%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x30(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, (%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x28(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x30(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2beff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/POA.cpp
// Function: destory_Node_alloc(Node_alloc*)
void destory_Node_alloc(Node_alloc* list)
{
	uint64_t i;
	for (i = 0; i < list->size; i++) {
		destory_Edge_alloc(&list->list[i].deletion_edges);
		destory_Edge_alloc(&list->list[i].insertion_edges);
		destory_Edge_alloc(&list->list[i].mismatch_edges);
	}
	free(list->list);
	free(list->sort.list);
	free(list->sort.visit);
	free(list->sort.iterative_buffer);
	free(list->sort.iterative_buffer_visit);
}

// 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 0x40(%rcx), %rax
jae 0x2bfe1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rdi
addq $0x40, %rdi
callq 0x2b960
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rdi
addq $0x60, %rdi
callq 0x2b960
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rdi
addq $0x20, %rdi
callq 0x2b960
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2bf74
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/POA.cpp
// Function: clear_Node_alloc(Node_alloc*)
void clear_Node_alloc(Node_alloc* list)
{
	uint64_t i =0;
	for (i = 0; i < list->length; i++) { // TODO: is this list->size or list->length? The original version is list->length.
		clear_Edge_alloc(&list->list[i].insertion_edges);
		clear_Edge_alloc(&list->list[i].mismatch_edges);
		clear_Edge_alloc(&list->list[i].deletion_edges);
	}
	list->length = 0;
	list->delete_length = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x2c0b9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rdi
addq $0x60, %rdi
callq 0x2b930
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rdi
addq $0x20, %rdi
callq 0x2b930
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rdi
addq $0x40, %rdi
callq 0x2b930
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2c04c
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)