LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: prt_gen_scaf_path_lst(unsigned long*, unsigned long, unsigned long, ma_ug_t*, ma_ug_t*)
uint64_t prt_gen_scaf_path_lst(uint64_t *a, uint64_t n, uint64_t is_circle, ma_ug_t *hu1, ma_ug_t *hu2)
{
    uint64_t k, nl, el, tl, id, rev, ui, uid; ma_utg_t *u;
    for (k = nl = el = tl = 0; k < n; k++) {
        nl += (a[k]>>32); id = ((uint32_t)a[k])>>1;
        u = ((id<hu1->u.n)?&(hu1->u.a[id]):&(hu2->u.a[id-hu1->u.n]));
        el += u->len;
    }
    tl = el + nl;
    fprintf(stderr, "[M::%s]tot::%lu\tel::%lu\tnl::%lu\tis_c::%lu\t#::%lu\t%s\n", __func__, tl, el, nl, is_circle, n, ((n>1)?"scf":"ctg"));
    for (k = 0; k < n; k++) {
        id = ((uint32_t)a[k])>>1; rev = ((uint32_t)a[k])&1;
        u = ((id<hu1->u.n)?&(hu1->u.a[id]):&(hu2->u.a[id-hu1->u.n]));
        ui = ((id<hu1->u.n)?1:2); nl = (a[k]>>32);
        uid = ((id<hu1->u.n)?(id):(id-hu1->u.n));
        fprintf(stderr, "[M::%s] h%lutg%.6lu%c(%c)\tlen::%u\tNs::%lu\n", __func__,
        ui, uid+1, "lc"[u->circ], "+-"[rev], u->len, nl);
    }
    return tl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r10
movq %rsi, %r15
movq %rdi, %r12
testq %rsi, %rsi
jne 0xb90c
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0xb953
movq (%r14), %rax
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r8d, %r8d
movq (%r12,%rcx,8), %rdx
movl %edx, %esi
shrl %esi
movq %rsi, %rdi
subq %rax, %rdi
jae 0xb931
imulq $0x28, %rsi, %rsi
addq 0x10(%r14), %rsi
jmp 0xb939
imulq $0x28, %rdi, %rsi
addq 0x10(%rbx), %rsi
shrq $0x20, %rdx
addq %rdx, %r9
movl (%rsi), %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
addq %rdx, %r8
incq %rcx
cmpq %rcx, %r15
jne 0xb917
leaq (%r9,%r8), %rcx
movq 0x289682(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
cmpq $0x2, %r15
leaq 0x22abfd(%rip), %rax    # 0x236569
leaq 0x22abfa(%rip), %r11    # 0x23656d
cmovaeq %rax, %r11
subq $0x8, %rsp
leaq 0x22c171(%rip), %rsi    # 0x237af3
leaq 0x22c19f(%rip), %rdx    # 0x237b28
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
pushq %r11
pushq %r15
pushq %r10
callq 0x22b0
addq $0x20, %rsp
testq %r15, %r15
je 0xba49
xorl %ebp, %ebp
movq (%r12,%rbp,8), %r10
movl %r10d, %r8d
shrl %r8d
movq (%r14), %rdx
movq %r8, %rax
subq %rdx, %rax
jae 0xb9cd
imulq $0x28, %r8, %rax
addq 0x10(%r14), %rax
xorl %edx, %edx
pushq $0x1
jmp 0xb9d7
imulq $0x28, %rax, %rax
addq 0x10(%rbx), %rax
pushq $0x2
popq %rcx
movl %r10d, %esi
andl $0x1, %esi
shrq $0x20, %r10
movq 0x2895f7(%rip), %rdi    # 0x294fe0
movq (%rdi), %rdi
subq %rdx, %r8
incq %r8
movl (%rax), %r11d
movl %r11d, %eax
shrl $0x1f, %eax
leaq 0x228d39(%rip), %rdx    # 0x23473b
movsbl (%rax,%rdx), %r9d
leaq 0x2268c5(%rip), %rax    # 0x2322d3
movsbl (%rsi,%rax), %r13d
andl $0x7fffffff, %r11d      # imm = 0x7FFFFFFF
subq $0x8, %rsp
leaq 0x22c119(%rip), %rsi    # 0x237b3e
leaq 0x22c0fc(%rip), %rdx    # 0x237b28
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %r13
callq 0x22b0
addq $0x20, %rsp
incq %rbp
cmpq %rbp, %r15
jne 0xb9aa
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: output_read_graph(asg_t*, ma_sub_t*, char*, long long)
void output_read_graph(asg_t *sg, ma_sub_t* coverage_cut, char* output_file_name, long long n_read)
{
    fprintf(stderr, "Writing read GFA to disk... \n");
    char* gfa_name = (char*)malloc(strlen(output_file_name)+25);
    sprintf(gfa_name, "%s.read.gfa", output_file_name);
    FILE* output_file = fopen(gfa_name, "w");
    ma_sg_print(sg, &R_INF, coverage_cut, output_file);
    free(gfa_name);
    fclose(output_file);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28956c(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x22c2a1(%rip), %rdi    # 0x237d1f
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
movq %r15, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %r12
leaq 0x22c299(%rip), %rsi    # 0x237d3d
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x23cc2a(%rip), %rsi    # 0x2486e2
movq %r12, %rdi
callq 0x2210
movq %rax, %r15
leaq 0x28a766(%rip), %rsi    # 0x296230
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0xb8ca0
movq %r12, %rdi
callq 0x2220
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_ma_hit_ts(ma_hit_t_alloc*, long long, char*)
void write_ma_hit_ts(ma_hit_t_alloc* x, long long n_read, char* read_file_name)
{
    fprintf(stderr, "Writing ma_hit_ts to disk... \n");
    char* index_name = (char*)malloc(strlen(read_file_name)+15);
    sprintf(index_name, "%s.bin", read_file_name);
    FILE* fp = fopen(index_name, "w");
    long long i, k;
    fwrite(&n_read, sizeof(n_read), 1, fp);


    for (i = 0; i < n_read; i++)
    {
        fwrite(&(x[i].is_fully_corrected), sizeof(x[i].is_fully_corrected), 1, fp);
        fwrite(&(x[i].is_abnormal), sizeof(x[i].is_abnormal), 1, fp);
        fwrite(&(x[i].length), sizeof(x[i].length), 1, fp);
        for (k = 0; k < x[i].length; k++)
        {
            write_ma(x[i].buffer + k, fp);
        }  
        // fwrite(x[i].buffer, sizeof((*(x[i].buffer))), x[i].length, fp);
    }


    free(index_name);
    fflush(fp);    
    fclose(fp);
    fprintf(stderr, "ma_hit_ts has been written.\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %rsi, (%r12)
movq 0x28917a(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x22bf14(%rip), %rdi    # 0x237d84
pushq $0x1e
popq %rsi
pushq $0x1
popq %r13
movq %r13, %rdx
callq 0x2410
movq %r15, %rdi
callq 0x2090
leaq 0xf(%rax), %rdi
callq 0x2280
movq %rax, %r14
leaq 0x2247b1(%rip), %rsi    # 0x23064b
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x23c834(%rip), %rsi    # 0x2486e2
movq %r14, (%rsp)
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
pushq $0x8
popq %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %rax, %rcx
callq 0x2410
movq (%r12), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jle 0xbf4b
xorl %r12d, %r12d
imulq $0x18, %r12, %r13
leaq (%rbx,%r13), %rbp
addq $0xc, %rbp
movsbl 0x4(%rbp), %edi
movq %r15, %rsi
callq 0x2270
movsbl 0x5(%rbp), %edi
movq %r15, %rsi
callq 0x2270
movq %rbp, %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x2410
cmpl $0x0, (%rbp)
je 0xbf41
addq %rbx, %r13
xorl %ebp, %ebp
xorl %r14d, %r14d
movq (%r13), %rdi
addq %rbp, %rdi
movq %r15, %rsi
callq 0xe12b5
incq %r14
movl 0xc(%r13), %eax
addq $0x28, %rbp
cmpq %rax, %r14
jb 0xbf22
incq %r12
cmpq 0x8(%rsp), %r12
jne 0xbedf
movq (%rsp), %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2200
movq %r15, %rdi
callq 0x2190
movq 0x289075(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x22be2e(%rip), %rdi    # 0x237da3
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2410
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_all_data_to_disk(ma_hit_t_alloc*, ma_hit_t_alloc*, All_reads*, char*)
void write_all_data_to_disk(ma_hit_t_alloc* sources, ma_hit_t_alloc* reverse_sources, All_reads *RNF, char* output_file_name)
{   
	char* gfa_name = (char*)malloc(strlen(output_file_name)+25);
	sprintf(gfa_name, "%s.ec", output_file_name);
	write_All_reads(RNF, gfa_name);

    if((ha_opt_triobin(&asm_opt)) && (asm_opt.fn_bin_yak[0] && asm_opt.fn_bin_yak[1])) {
        write_yak_binning(asm_opt.output_file_name, asm_opt.fn_bin_yak[0], asm_opt.fn_bin_yak[1]);
    }

	sprintf(gfa_name, "%s.ovlp.source", output_file_name);
	write_ma_hit_ts(sources, RNF->total_reads, gfa_name);

	sprintf(gfa_name, "%s.ovlp.reverse", output_file_name);
	write_ma_hit_ts(reverse_sources, RNF->total_reads, gfa_name);

	free(gfa_name);
    fprintf(stderr, "bin files have been written.\n");
    if(asm_opt.bin_only) exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %rcx, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
callq 0x2280
movq %rax, %r12
leaq 0x224c3f(%rip), %rsi    # 0x230ec8
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
movq %r12, %rsi
callq 0x3546
leaq 0x2894b0(%rip), %rbp    # 0x295758
movq 0x20(%rbp), %rsi
movq 0x28(%rbp), %rdx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movb $0x1, %al
cmpb $0x1, %cl
jne 0xc2d4
cmpq $0x0, 0x30(%rbp)
je 0xc2f1
cmpq $0x0, 0x38(%rbp)
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
andb %cl, %al
cmpb $0x1, %al
jne 0xc2f1
movq 0x10(%rbp), %rdi
callq 0xc0ba
leaq 0x22bb31(%rip), %rsi    # 0x237e29
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x50(%r14), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0xbe42
leaq 0x22bb1d(%rip), %rsi    # 0x237e38
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x50(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xbe42
movq %r12, %rdi
callq 0x2220
movq 0x288c9a(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x22baf8(%rip), %rdi    # 0x237e48
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
cmpb $0x0, 0x24e(%rbp)
jne 0xc373
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: output_tangles(unsigned int, unsigned int, unsigned int*, unsigned int, char const*)
void output_tangles(uint32_t startID, uint32_t endId, uint32_t* a, uint32_t n, const char* lable)
{
    kvec_t(uint32_t) u_vecs;
    u_vecs.a = a, u_vecs.n = n;

    fprintf(stderr, "\n%sstartID: %u, dir: %u\n", lable, startID>>1, startID&1);
    fprintf(stderr, "%sendID: %u, dir: %u\n", lable, endId>>1, endId&1);
    uint32_t ijk;
    for (ijk = 0; ijk < u_vecs.n; ijk++)
    {
        fprintf(stderr, "%stangleID: %u, dir: %u\n", lable, u_vecs.a[ijk]>>1, u_vecs.a[ijk]&1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %r8d
movq 0x288514(%rip), %r12    # 0x294fe0
movq (%r12), %rdi
movl %r8d, %ecx
shrl %ecx
andl $0x1, %r8d
leaq 0x22b894(%rip), %rsi    # 0x238374
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
movl %r15d, %ecx
shrl %ecx
andl $0x1, %r15d
leaq 0x22b88f(%rip), %rsi    # 0x23838d
movq %rbx, %rdx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x22b0
testl %ebp, %ebp
je 0xcb41
movl %ebp, %r13d
leaq 0x22b88a(%rip), %r15    # 0x2383a3
xorl %ebp, %ebp
movq (%r12), %rdi
movl (%r14,%rbp,4), %r8d
movl %r8d, %ecx
shrl %ecx
andl $0x1, %r8d
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22b0
incq %rbp
cmpq %rbp, %r13
jne 0xcb1b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: write_debug_graph(asg_t*, ma_hit_t_alloc*, ma_sub_t*, char*, ma_hit_t_alloc*, R_to_U*, all_ul_t*)
int write_debug_graph(asg_t *sg, ma_hit_t_alloc* sources, ma_sub_t* coverage_cut, 
char* output_file_name, ma_hit_t_alloc* reverse_sources, R_to_U* ruIndex, all_ul_t *ul_r_inf)
{

    char* gfa_name = (char*)malloc(strlen(output_file_name)+55);

    ////write_All_reads(&R_INF, gfa_name);
    sprintf(gfa_name, "%s.all.debug.source", output_file_name);
    write_debug_ma_hit_ts(sources, R_INF.total_reads, gfa_name);
    sprintf(gfa_name, "%s.all.debug.reverse", output_file_name);
    write_debug_ma_hit_ts(reverse_sources, R_INF.total_reads, gfa_name);
    if(coverage_cut) {
        sprintf(gfa_name, "%s.all.debug.coverage_cut", output_file_name);
        write_coverage_cut(coverage_cut, gfa_name, R_INF.total_reads);
    }
    sprintf(gfa_name, "%s.all.debug.ruIndex", output_file_name);
    write_ruIndex(ruIndex, gfa_name);
    if(sg) {
        sprintf(gfa_name, "%s.all.debug.asg_t", output_file_name);
        write_asg_t(sg, gfa_name);
    }
    if(ul_r_inf) {
        sprintf(gfa_name, "%s.all.debug.ul.rinfor", output_file_name);
        write_all_ul_t(ul_r_inf, gfa_name, NULL);
    }
    free(gfa_name);
    fprintf(stderr, "debug_graph has been written.\n");
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq %rcx, %rdi
callq 0x2090
leaq 0x37(%rax), %rdi
callq 0x2280
movq %rax, %r14
leaq 0x22b266(%rip), %rsi    # 0x23892a
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x288b58(%rip), %r15    # 0x296230
movq 0x50(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xbf8e
leaq 0x22b250(%rip), %rsi    # 0x23893e
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x50(%r15), %rsi
movq %rbp, %rdi
movq %r14, %rdx
callq 0xbf8e
testq %r13, %r13
je 0xd732
leaq 0x22b23d(%rip), %rsi    # 0x238953
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x50(%r15), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0xf24ef
movq 0x50(%rsp), %r13
leaq 0x22b22f(%rip), %rsi    # 0x23896d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xf258e
movq 0x10(%rsp), %r15
testq %r15, %r15
je 0xd781
leaq 0x22b219(%rip), %rsi    # 0x238982
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
movq %r14, %rsi
callq 0xf27ad
testq %r13, %r13
je 0xd7a7
leaq 0x22b208(%rip), %rsi    # 0x238995
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2050
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1e6781
movq %r14, %rdi
callq 0x2220
movq 0x28782a(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x22b1ec(%rip), %rdi    # 0x2389ac
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x2410
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: print_utg_hap(ma_ug_t*, asg_t*, unsigned int, ma_hit_t_alloc*, R_to_U*)
void print_utg_hap(ma_ug_t *ug, asg_t* read_g, uint32_t uid, ma_hit_t_alloc* reverse_sources, 
R_to_U* ruIndex)
{
    
    uint32_t k, rId, qn, i, is_Unitig;
    ma_utg_t* u = &(ug->u.a[uid]);
    fprintf(stderr, "\nuid: %u, u->n: %u\n", uid, u->n);
    for (k = 0; k < u->n; k++)
    {
        rId = u->a[k]>>33;
        fprintf(stderr, "self[%u]: %u\n", k, rId);
    }

    for (k = 0; k < u->n; k++)
    {
        qn = u->a[k]>>33;
        fprintf(stderr, "****self[%u]: %u, Len: %u\n", k, qn, reverse_sources[qn].length);
        for (i = 0; i < reverse_sources[qn].length; i++)
        {
            rId = Get_tn(reverse_sources[qn].buffer[i]);
            if(read_g->seq[rId].del == 1)
            {
                ///get the id of read that contains it 
                get_R_to_U(ruIndex, rId, &rId, &is_Unitig);
                if(rId == (uint32_t)-1 || is_Unitig == 1 || read_g->seq[rId].del == 1) continue;
            }
            fprintf(stderr, "hap[%u]: %u\n", i, rId);
        }
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rsi, %r15
movq 0x10(%rdi), %rbp
movl %edx, %eax
imulq $0x28, %rax, %r14
movq 0x2877d9(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
movl 0x10(%rbp,%r14), %ecx
leaq 0x22b257(%rip), %rsi    # 0x238a6d
xorl %eax, %eax
callq 0x22b0
cmpl $0x0, 0x10(%rbp,%r14)
je 0xd92d
addq %r14, %rbp
leaq 0x22b24e(%rip), %r12    # 0x238a81
xorl %r13d, %r13d
movq %rbp, %r14
movq 0x2877a0(%rip), %rbp    # 0x294fe0
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rcx
shrq $0x21, %rcx
movq (%rbp), %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x22b0
incq %r13
movl 0x10(%r14), %eax
cmpq %rax, %r13
jb 0xd840
testl %eax, %eax
je 0xd92d
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rcx
shrq $0x21, %rcx
movq 0x287755(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
imulq $0x18, %rcx, %r13
movq 0x8(%rsp), %r14
movl 0xc(%r14,%r13), %r8d
leaq 0x22b1ec(%rip), %rsi    # 0x238a8f
movl %ebp, %edx
xorl %eax, %eax
callq 0x22b0
movl 0xc(%r14,%r13), %eax
testl %eax, %eax
je 0xd918
addq 0x8(%rsp), %r13
pushq $0xc
popq %r14
xorl %r12d, %r12d
movq (%r13), %rcx
movl (%rcx,%r14), %ecx
movq 0x20(%r15), %rdx
cmpl $0x0, (%rdx,%rcx,8)
jns 0xd8eb
cmpq %rcx, (%rbx)
jbe 0xd90a
movq 0x8(%rbx), %rsi
movslq (%rsi,%rcx,4), %rcx
testq %rcx, %rcx
js 0xd90a
cmpl $0x0, (%rdx,%rcx,8)
js 0xd90a
movq 0x2876ee(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x22b1ae(%rip), %rsi    # 0x238aaa
movl %r12d, %edx
xorl %eax, %eax
callq 0x22b0
movl 0xc(%r13), %eax
incq %r12
movl %eax, %ecx
addq $0x28, %r14
cmpq %rcx, %r12
jb 0xd8c1
incq %rbp
movq 0x10(%rsp), %r14
movl 0x10(%r14), %eax
cmpq %rax, %rbp
jb 0xd878
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Overlaps.cpp
// Function: prt_dbg_gfa(asg_t*, char const*, ma_sub_t*, ma_hit_t_alloc*, R_to_U*, long, long)
void prt_dbg_gfa(asg_t *sg, const char *suffix, ma_sub_t *cov, ma_hit_t_alloc* src, R_to_U* ruIndex, int64_t max_hang, int64_t min_ovlp)
{
    char *o_file = get_outfile_name(asm_opt.output_file_name);
    char* gfa_name; MALLOC(gfa_name, strlen(o_file)+strlen(suffix)+50); sprintf(gfa_name, "%s.%s", o_file, suffix);
    print_debug_gfa(sg, NULL, cov, gfa_name, src, ruIndex, max_hang, min_ovlp, 0, 0, 1);
    free(gfa_name); free(o_file);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movl 0x50(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x2864e8(%rip), %rax    # 0x295758
movq 0x10(%rax), %rdi
callq 0x104233
movq %rax, %r14
movq %rax, %rdi
callq 0x2090
movq %rax, %rbx
movq %r15, %rdi
callq 0x2090
leaq (%rbx,%rax), %rdi
addq $0x32, %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x229d6c(%rip), %rsi    # 0x239012
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2050
subq $0x8, %rsp
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq 0x8(%rsp), %r9
pushq $0x1
pushq $0x0
pushq $0x0
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0xa5f3
addq $0x30, %rsp
movq %rbx, %rdi
callq 0x2220
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_peak_line(int, int, int, long)
void print_peak_line(int c, int x, int exceed, int64_t cnt)
{
	int j;
	if (c >= 0) fprintf(stderr, "[M::%s] %5d: ", __func__, c);
	else fprintf(stderr, "[M::%s] %5s: ", __func__, "rest");
	for (j = 0; j < x; ++j) fputc('*', stderr);
	if (exceed) fputc('>', stderr);
	fprintf(stderr, " %lld\n", (long long)cnt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %ecx
movq 0x282f7d(%rip), %r12    # 0x294fe0
movq (%r12), %rdi
testl %ecx, %ecx
js 0x12082
leaq 0x227696(%rip), %rsi    # 0x239708
leaq 0x22769d(%rip), %rdx    # 0x239716
xorl %eax, %eax
callq 0x22b0
jmp 0x1209e
leaq 0x22769d(%rip), %rsi    # 0x239726
leaq 0x227686(%rip), %rdx    # 0x239716
leaq 0x22769d(%rip), %rcx    # 0x239734
xorl %eax, %eax
callq 0x22b0
testl %r14d, %r14d
jle 0x120b8
pushq $0x2a
popq %r15
movq (%r12), %rsi
movl %r15d, %edi
callq 0x2270
decl %r14d
jne 0x120a7
testl %ebp, %ebp
je 0x120c8
movq (%r12), %rsi
pushq $0x3e
popq %rdi
callq 0x2270
movq (%r12), %rdi
leaq 0x226bef(%rip), %rsi    # 0x238cc2
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_peak(long long*, long long, long long)
void print_peak(long long* cov_buf, long long cov_buf_length, long long max_i)
{
    long long i;
    const long long hist_max = 100;
    // print histogram
	for (i = 0; i < cov_buf_length; ++i) 
    {
		long long x, exceed = 0;
		x = (int)((double)hist_max * cov_buf[i] / cov_buf[max_i] + .499);
		if (x > hist_max) exceed = 1, x = hist_max; // may happen if cnt[2] is higher
		if (i > max_i && x == 0) break;
		print_peak_line(i, x, exceed, cov_buf[i]);
	}
	{
		long long x, exceed = 0;
		long long rest = 0;
		for (; i < cov_buf_length; ++i) rest += cov_buf[i];
		x = (int)((double)hist_max * rest / cov_buf[max_i] + .499);
		if (x > hist_max) exceed = 1, x = hist_max;
		print_peak_line(-1, x, exceed, rest);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
pushq $0x64
popq %rbx
testq %rsi, %rsi
jle 0x12152
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x227599(%rip), %xmm0   # 0x2396b0
cvtsi2sdq (%r15,%r14,8), %xmm1
divsd %xmm1, %xmm0
addsd 0x21bee7(%rip), %xmm0   # 0x22e010
cvttsd2si %xmm0, %esi
cmpq %r14, %rbp
jle 0x12136
testl %esi, %esi
je 0x12154
xorl %edx, %edx
cmpl $0x64, %esi
cmovgel %ebx, %esi
setg %dl
movl %ebp, %edi
callq 0x1204a
incq %rbp
cmpq %rbp, %r13
jne 0x12106
jmp 0x12168
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq %r13, %rbp
jge 0x12168
addq (%r15,%rbp,8), %r12
incq %rbp
cmpq %rbp, %r13
jne 0x1215c
cvtsi2sd %r12, %xmm0
mulsd 0x22753b(%rip), %xmm0   # 0x2396b0
cvtsi2sdq (%r15,%r14,8), %xmm1
divsd %xmm1, %xmm0
addsd 0x21be89(%rip), %xmm0   # 0x22e010
cvttsd2si %xmm0, %eax
xorl %edx, %edx
cmpl $0x65, %eax
setge %dl
cmpl $0x64, %eax
cmovll %eax, %ebx
pushq $-0x1
popq %rdi
movl %ebx, %esi
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1204a
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_debug_unitig(ma_utg_t*, unsigned long*, char const*)
void print_debug_unitig(ma_utg_t *xReads, uint64_t* position_index, const char* infor)
{
    uint32_t k;
    fprintf(stderr, "\n%s: n = %u\n", infor, xReads->n);
    for (k = 0; k < xReads->n; k++)
    {
        fprintf(stderr, "(%u)v: %u, len: %u, index: %u, pos: %u\n", 
        k, (uint32_t)(xReads->a[k]>>32), (uint32_t)xReads->a[k], (uint32_t)(position_index[xReads->a[k]>>33]),
        (uint32_t)(position_index[xReads->a[k]>>33]>>32));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x282e12(%rip), %r13    # 0x294fe0
movq (%r13), %rdi
movl 0x10(%r14), %ecx
leaq 0x22755c(%rip), %rsi    # 0x239739
xorl %eax, %eax
callq 0x22b0
cmpl $0x0, 0x10(%r14)
je 0x12236
leaq 0x227554(%rip), %r15    # 0x239746
xorl %r12d, %r12d
movq (%r13), %rdi
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %r8
movq %r8, %rcx
shrq $0x20, %rcx
movq %r8, %rax
shrq $0x21, %rax
movq (%rbx,%rax,8), %r9
movq %r9, %rax
shrq $0x20, %rax
movl %eax, (%rsp)
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x22b0
incq %r12
movl 0x10(%r14), %eax
cmpq %rax, %r12
jb 0x121f5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_asg_arc_t_offset(asg_arc_t_offset*, long long, char const*)
void print_asg_arc_t_offset(asg_arc_t_offset* x, long long n, const char* info)
{
    fprintf(stderr,"\n\n(%s)n: %lld\n", info, n);
    long long i, x_off, y_off;
    for (i = 0; i < n; i++)
    {
        x_off = (long long)(x[i].Off>>32);
        y_off = (long long)((uint32_t)x[i].Off);
        fprintf(stderr, "i: %lld, x_off: %lld, y_off: %lld, weight: %lu, rev: %u, ol: %u\n", 
        i, x_off, y_off, (unsigned long)x[i].weight, x[i].x.el, x[i].x.ol);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x282d84(%rip), %r13    # 0x294fe0
movq (%r13), %rdi
leaq 0x227507(%rip), %rsi    # 0x23976e
movq %rbx, %rcx
xorl %eax, %eax
callq 0x22b0
testq %rbx, %rbx
jle 0x122c6
addq $0x20, %r14
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
leaq 0x2274f7(%rip), %r15    # 0x23977d
xorl %r12d, %r12d
movq -0x8(%r14), %rcx
movq (%r14), %r9
movl %ecx, %r8d
shrq $0x20, %rcx
movq (%r13), %rdi
movzbl -0xe(%r14), %r10d
movl -0x14(%r14), %r11d
andl %ebp, %r11d
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x22b0
popq %rcx
popq %rdx
incq %r12
addq $0x28, %r14
cmpq %r12, %rbx
jne 0x12289
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_chain_data(int*, int*, int*, long long)
void print_chain_data(int32_t* Scores, int32_t* Pres, int32_t* Begs, long long n)
{
    fprintf(stderr,"*****\nn_chain: %lld\n", n);
    long long i;
    for (i = 0; i < n; i++)
    {
        fprintf(stderr, "i: %lld, Scores: %d, Pres: %d, Begs: %d\n", 
        i, Scores[i], Pres[i], Begs[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x282bac(%rip), %r13    # 0x294fe0
movq (%r13), %rdi
leaq 0x22740d(%rip), %rsi    # 0x23984c
movq %rcx, %rdx
xorl %eax, %eax
callq 0x22b0
testq %rbx, %rbx
jle 0x12479
xorl %ebp, %ebp
movq (%r13), %rdi
movl (%r12,%rbp,4), %ecx
movl (%r15,%rbp,4), %r8d
movl (%r14,%rbp,4), %r9d
leaq 0x2273fa(%rip), %rsi    # 0x239861
movq %rbp, %rdx
xorl %eax, %eax
callq 0x22b0
incq %rbp
cmpq %rbp, %rbx
jne 0x12450
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_all_purge_ovlp(ma_ug_t*, hap_overlaps_list*, char const*)
void print_all_purge_ovlp(ma_ug_t *ug, hap_overlaps_list* all_ovlp, const char* cmd)
{
    fprintf(stderr, "\n%s--->ug->u.n: %u\n", cmd, (uint32_t)ug->u.n);
    uint32_t v, uId, i;
    for (v = 0; v < all_ovlp->num; v++)
    {
        uId = v;
        for (i = 0; i < all_ovlp->x[uId].a.n; i++)
        {
            print_hap_paf(ug, &(all_ovlp->x[uId].a.a[i]));
        }
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x282b40(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
movl (%r14), %ecx
leaq 0x2275fd(%rip), %rsi    # 0x239aaa
xorl %eax, %eax
callq 0x22b0
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x12501
movq (%rbx), %rax
xorl %r15d, %r15d
pushq $0x1
popq %rbp
imulq $0x18, %r15, %r12
cmpq $0x0, (%rax,%r12)
je 0x124f7
movl %ebp, %r13d
xorl %esi, %esi
shlq $0x6, %rsi
addq 0x10(%rax,%r12), %rsi
movq %r14, %rdi
callq 0x122d5
movl %r13d, %esi
movq (%rbx), %rax
incl %r13d
cmpq %rsi, (%rax,%r12)
ja 0x124d4
movl 0x8(%rbx), %ecx
incq %r15
movl %ecx, %edx
cmpq %rdx, %r15
jb 0x124c4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/Purge_Dups.cpp
// Function: print_p_g_t_interval(p_g_t*, hap_cov_t*)
void print_p_g_t_interval(p_g_t* pg, hap_cov_t *cov)
{
    fprintf(stderr, "----------[M::%s]----------\n", __func__);
    uint32_t i, v, sid, eid;
    p_node_t *t = NULL;
    ma_utg_t *u = NULL;

    for (v = 0; v < pg->pg_het_node.n; v++)
    {
        t = &(pg->pg_het_node.a[v]);
        sid = t->nodeBeg;
        eid = t->nodeEnd;

        u = &(pg->ug->u.a[t->c_ug_id]);
        fprintf(stderr, "\nu->n=%u, sid=%u, eid=%u, h_status=%u\n", 
                                                (uint32_t)u->n, sid, eid, t->h_status);
        for (i = sid; i <= eid; i++)
        {
            fprintf(stderr, "id:i:%u------>utg%.6ul\n", 
                        (uint32_t)(u->a[i]>>33), (get_origin_uid(u->a[i]>>32, cov->t_ch, NULL, NULL)>>1)+1);
        }
    }
    fprintf(stderr, "----------[M::%s]----------\n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x2827b3(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x22a5c8(%rip), %rsi    # 0x23cdff
leaq 0x2272e3(%rip), %rdx    # 0x239b21
xorl %eax, %eax
callq 0x22b0
cmpq $0x0, 0x8(%r15)
je 0x12916
leaq 0x227306(%rip), %r12    # 0x239b5d
xorl %eax, %eax
xorl %r14d, %r14d
movq %r15, 0x8(%rsp)
movq (%r15), %rcx
movq 0x18(%r15), %rsi
imulq $0x1c, %rax, %rax
movl 0x8(%rsi,%rax), %ebp
movl 0xc(%rsi,%rax), %r13d
movq 0x10(%rcx), %r15
movl 0x18(%rsi,%rax), %ecx
imulq $0x28, %rcx, %rdx
movq 0x282758(%rip), %rcx    # 0x294fe0
movq (%rcx), %rdi
movq %rdx, 0x10(%rsp)
movl 0x10(%r15,%rdx), %edx
movl 0x14(%rsi,%rax), %r9d
leaq 0x227295(%rip), %rsi    # 0x239b36
movl %ebp, %ecx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x22b0
cmpl %r13d, %ebp
ja 0x12901
addq 0x10(%rsp), %r15
movq 0x18(%r15), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rdx
shrq $0x21, %rdx
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq $-0x1, (%rsi,%rdx,8)
je 0x128e6
movq (%rax), %rax
movl (%rax,%rdx,4), %ecx
shrl %ecx
incl %ecx
movq 0x2826f3(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x22b0
incl %ebp
cmpl %r13d, %ebp
jbe 0x128b7
incl %r14d
movq %r14, %rax
movq 0x8(%rsp), %r15
cmpq %r14, 0x8(%r15)
ja 0x12861
movq 0x2826c3(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x22a4d8(%rip), %rsi    # 0x23cdff
leaq 0x2271f3(%rip), %rdx    # 0x239b21
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ft_ul_gen(hifiasm_opt_t const*, ma_utg_v*, int, int, int)
void *ha_ft_ul_gen(const hifiasm_opt_t *asm_opt, ma_utg_v *us, int k, int w, int cutoff)
{
	yak_ft_t *flt_tab;
    ha_ct_t *h;
	///HAF_COUNT_EXACT ---> no bf; HAF_COUNT_ALL ---> no minimizer
	h = ha_count(asm_opt, HAF_COUNT_ALL|HAF_UG_READ, !(asm_opt->flag&HA_F_NO_HPC), k, w, NULL, NULL, NULL, us, 0, NULL, 0);
	
	// cutoff = (int)(asm_opt->hom_cov * asm_opt->high_factor);
    if (cutoff > YAK_MAX_COUNT - 1) cutoff = YAK_MAX_COUNT - 1;
	// fprintf(stderr, "[M::%s::] cutoff->%d\n\n", __func__, cutoff);
	ha_ct_shrink(h, cutoff, YAK_MAX_COUNT, asm_opt->thread_num);
	flt_tab = gen_hh(h, asm_opt->max_kmer_cnt);
	ha_ct_destroy(h);
	fprintf(stderr, "[M::%s::%.3f*%.2f@%.3fGB] ==> filtered out %ld k-mers occurring %d or more times\n", __func__,
            yak_realtime(), yak_cpu_usage(), yak_peakrss_in_gb(), (long)kh_size(flt_tab), cutoff);
	return (void*)flt_tab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movl %ecx, %r8d
movl %edx, %ecx
movq %rdi, %r14
movl (%rdi), %edx
notl %edx
andl $0x1, %edx
movq %rsi, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x20(%rsp)
andl $0x0, 0x18(%rsp)
movl $0x82, %esi
xorl %r9d, %r9d
callq 0x119f0d
movq %rax, %r15
movl $0xffe, %ebx            # imm = 0xFFE
cmpl %ebx, %ebp
cmovll %ebp, %ebx
movl 0x7c(%r14), %ecx
movq %rax, %rdi
movl %ebx, %esi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x137e4
movl 0xb0(%r14), %esi
movq %r15, %rdi
callq 0x11a641
movq %rax, %r14
movq %r15, %rdi
callq 0x11a823
movq 0x281856(%rip), %rax    # 0x294fe0
movq (%rax), %r15
callq 0x1365ef
movsd %xmm0, 0x40(%rsp)
callq 0x1366b8
movsd %xmm0, 0x38(%rsp)
callq 0x136685
movaps %xmm0, %xmm2
movl 0x4(%r14), %ecx
leaq 0x2267e8(%rip), %rsi    # 0x239f9e
leaq 0x226833(%rip), %rdx    # 0x239ff0
movq %r15, %rdi
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movl %ebx, %r8d
movb $0x3, %al
callq 0x22b0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ct_shrink(ha_ct_t*, int, int, int)
static void ha_ct_shrink(ha_ct_t *h, int min, int max, int n_thread)
{
	int i;
	shrink_aux_t a;
	a.h = h, a.min = min, a.max = max;
	///still start 4096 threads
	kt_for(n_thread, worker_ct_shrink, &a, 1<<h->pre);
	for (i = 0, h->tot = 0; i < 1<<h->pre; ++i)
		h->tot += kh_size(h->h[i].h);
	fprintf(stderr, "[M::%s::%.3f*%.2f] ==> counted %ld distinct minimizer k-mers\n", __func__,
			yak_realtime(), yak_cpu_usage(), (long)h->tot);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %eax
movq %rdi, %rbx
leaq 0x8(%rsp), %r8
movq %rdi, 0x8(%r8)
movl %esi, (%r8)
movl %edx, 0x4(%r8)
movb 0x4(%rdi), %cl
pushq $0x1
popq %rdx
shll %cl, %edx
movslq %edx, %rcx
leaq 0x10ae28(%rip), %rsi    # 0x11e63a
movl %eax, %edi
movq %r8, %rdx
callq 0x108f2c
andq $0x0, 0x10(%rbx)
movl 0x4(%rbx), %ecx
cmpq $0x1f, %rcx
je 0x1384c
pushq $0x1
popq %rax
shlq %cl, %rax
movq 0x20(%rbx), %rdx
xorl %ecx, %ecx
movq (%rdx), %rsi
movl 0x4(%rsi), %esi
addq %rsi, %rcx
addq $0x10, %rdx
decq %rax
jne 0x13836
movq %rcx, 0x10(%rbx)
movq 0x28178d(%rip), %rax    # 0x294fe0
movq (%rax), %r14
callq 0x1365ef
movsd %xmm0, (%rsp)
callq 0x1366b8
movaps %xmm0, %xmm1
movq 0x10(%rbx), %rcx
leaq 0x2267b8(%rip), %rsi    # 0x23a02b
leaq 0x226d95(%rip), %rdx    # 0x23a60f
movq %r14, %rdi
movsd (%rsp), %xmm0
movb $0x2, %al
callq 0x22b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_ft_ug_gen(hifiasm_opt_t const*, ma_utg_v*, int, int, int, int, int)
void *ha_ft_ug_gen(const hifiasm_opt_t *asm_opt, ma_utg_v *us, int is_HPC, int k, int w, int min_freq, int max_freq)
{
	yak_ft_t *flt_tab;
	ha_ct_t *h;
	///HAF_COUNT_EXACT ---> no bf; HAF_COUNT_ALL ---> no minimizer
	h = ha_count(asm_opt, HAF_COUNT_ALL|HAF_UG_READ|HAF_COUNT_EXACT, is_HPC, k, w, NULL, NULL, NULL, us, 0, NULL, 0);
	ha_ct_shrink(h, min_freq, max_freq>YAK_MAX_COUNT-1?YAK_MAX_COUNT-1:max_freq, asm_opt->thread_num);
	flt_tab = gen_hh(h, YAK_MAX_COUNT);
	ha_ct_destroy(h);
	return (void*)flt_tab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq %rdi, %r14
movl 0x60(%rsp), %ebp
movq %rsi, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x20(%rsp)
andl $0x0, 0x18(%rsp)
movl $0x83, %esi
xorl %r9d, %r9d
callq 0x119f0d
movq %rax, %r15
movl $0xffe, %edx            # imm = 0xFFE
cmpl %edx, %ebp
cmovll %ebp, %edx
movl 0x7c(%r14), %ecx
movq %rax, %rdi
movl %ebx, %esi
callq 0x137e4
movq %r15, %rdi
movl $0xfff, %esi            # imm = 0xFFF
callq 0x11a641
movq %rax, %rbx
movq %r15, %rdi
callq 0x11a823
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/htab.cpp
// Function: ha_pt_ug_gen(hifiasm_opt_t const*, void const*, ma_utg_v*, int, int, int, int)
ha_pt_t *ha_pt_ug_gen(const hifiasm_opt_t *asm_opt, const void *flt_tab, ma_utg_v *us, int is_HPC, int k, int w, int min_freq)
{
	ha_ct_t *ct;
	ha_pt_t *pt;
	///HAF_COUNT_EXACT: no bf
	ct = ha_count(asm_opt, HAF_COUNT_EXACT|HAF_UG_READ, is_HPC, k, w, NULL, flt_tab, NULL, us, 0, NULL, 1);
	fprintf(stderr, "[M::%s::%.3f*%.2f] ==> counted %ld distinct minimizer k-mers\n", __func__,
			yak_realtime(), yak_cpu_usage(), (long)ct->tot);
	///minimizer with YAK_MAX_COUNT occ may apper > YAK_MAX_COUNT times, so it may lead to overflow at ha_pt_gen
	ha_ct_shrink(ct, min_freq, YAK_MAX_COUNT - 1, asm_opt->thread_num);

	pt = ha_pt_gen(ct, asm_opt->thread_num, 1);
	ha_count(asm_opt, HAF_COUNT_EXACT|HAF_UG_READ, is_HPC, k, w, pt, flt_tab, NULL, us, 0, NULL, 1);
	//ha_pt_sort(pt, asm_opt->thread_num);
	fprintf(stderr, "[M::%s::%.3f*%.2f] ==> indexed %ld positions\n", __func__,
			yak_realtime(), yak_cpu_usage(), (long)pt->tot_pos);
	return pt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, 0x10(%rsp)
movq %rsi, (%rsp)
movq %rdi, %r13
subq $0x30, %rsp
andq $0x0, 0x20(%rsp)
pushq $0x1
popq %rax
andl $0x0, 0x18(%rsp)
movl %eax, 0x28(%rsp)
andq $0x0, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, (%rsp)
movl $0x81, %esi
movl %ecx, %edx
movl %r8d, %ecx
movl %r9d, %r8d
xorl %r9d, %r9d
callq 0x119f0d
addq $0x30, %rsp
movq %rax, %rbx
movq 0x28134b(%rip), %rax    # 0x294fe0
movq (%rax), %r14
callq 0x1365ef
movsd %xmm0, 0x8(%rsp)
callq 0x1366b8
movaps %xmm0, %xmm1
movq 0x10(%rbx), %rcx
leaq 0x226375(%rip), %rsi    # 0x23a02b
leaq 0x2263e7(%rip), %rdx    # 0x23a0a4
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x22b0
movl 0x7c(%r13), %ecx
movq %rbx, %rdi
movl 0x50(%rsp), %esi
movl $0xffe, %edx            # imm = 0xFFE
callq 0x137e4
movl 0x7c(%r13), %esi
movq %rbx, %rdi
pushq $0x1
popq %r14
movl %r14d, %edx
callq 0x118cb9
movq %rax, %rbx
movq %r13, %rdi
movl $0x81, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
movq %rax, %r9
pushq %r14
pushq $0x0
pushq $0x0
pushq 0x28(%rsp)
pushq $0x0
pushq 0x28(%rsp)
callq 0x119f0d
addq $0x30, %rsp
movq 0x2812b4(%rip), %rax    # 0x294fe0
movq (%rax), %r14
callq 0x1365ef
movsd %xmm0, (%rsp)
callq 0x1366b8
movaps %xmm0, %xmm1
movq 0x10(%rbx), %rcx
leaq 0x22632a(%rip), %rsi    # 0x23a076
movq %r14, %rdi
leaq 0x22634e(%rip), %rdx    # 0x23a0a4
movsd (%rsp), %xmm0
movb $0x2, %al
callq 0x22b0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: test_unitig_index(ha_ug_index*, ma_ug_t*)
void test_unitig_index(ha_ug_index* idx, ma_ug_t *ug)
{
    double index_time = yak_realtime();
    uint32_t i, j;
    ma_utg_t *u = NULL;
    hc_pt1_t *h = NULL;
    idx->ug = ug;
    for (i = 0; i < idx->ug->u.n; i++)
    {
        u = &(idx->ug->u.a[i]);
        if(u->m == 0) continue;
        test_hc_pt1(u->s, u->len, i, idx);
    }

    for (i = 0; i < idx->tot; i++)
    {
        h = &(idx->idx_buf[i]);
        for (j = 0; j < h->n; j++)
        {
            if(h->a[j] != (uint64_t)-1)
            {
                fprintf(stderr, "ERROR j\n");
            }
        }
        
    }

    fprintf(stderr, "[M::%s::%.3f] ==> Test has been passed\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1365ef
movsd %xmm0, (%rsp)
movq %r14, (%rbx)
movq (%r14), %rax
testq %rax, %rax
je 0x14d31
pushq $0x1
popq %rbp
xorl %edx, %edx
movq 0x10(%r14), %rcx
imulq $0x28, %rdx, %rsi
cmpl $0x0, 0xc(%rcx,%rsi)
je 0x14d28
addq %rsi, %rcx
movq 0x20(%rcx), %rdi
movl (%rcx), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rcx
callq 0x13a506
movq (%rbx), %r14
movq (%r14), %rax
movl %ebp, %edx
incl %ebp
cmpq %rdx, %rax
ja 0x14cfc
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x14da9
xorl %edx, %edx
pushq $0x8
popq %r15
pushq $0x1
popq %r12
xorl %ebp, %ebp
movq 0x78(%rbx), %r13
shlq $0x5, %rdx
movq 0x8(%r13,%rdx), %rcx
testq %rcx, %rcx
je 0x14d9f
addq %rdx, %r13
pushq $0x1
popq %r14
xorl %eax, %eax
movq 0x10(%r13), %rdx
cmpq $-0x1, (%rdx,%rax,8)
jne 0x14d79
movl %r14d, %eax
incl %r14d
cmpq %rax, %rcx
ja 0x14d61
jmp 0x14d9b
movq 0x280260(%rip), %rax    # 0x294fe0
movq (%rax), %rcx
leaq 0x226537(%rip), %rdi    # 0x23b2c1
movq %r15, %rsi
movq %r12, %rdx
callq 0x2410
movq 0x8(%r13), %rcx
jmp 0x14d6c
movq 0x58(%rbx), %rax
incl %ebp
movq %rbp, %rdx
cmpq %rbp, %rax
ja 0x14d46
movq 0x280230(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd (%rsp), %xmm0
leaq 0x226506(%rip), %rsi    # 0x23b2ca
leaq 0x226527(%rip), %rdx    # 0x23b2f2
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: dedup_hits(kvec_pe_hit*, unsigned long)
void dedup_hits(kvec_pe_hit* hits, uint64_t is_dup)
{
    double index_time = yak_realtime();
    uint64_t k, l, m = 0, cur;
    radix_sort_pe_hit_an1(hits->a.a, hits->a.a + hits->a.n);
    for (k = 1, l = 0; k <= hits->a.n; ++k) 
    {   
        if (k == hits->a.n || hits->a.a[k].s != hits->a.a[l].s) 
        {
            if (k - l > 1) radix_sort_pe_hit_an2(hits->a.a + l, hits->a.a + k);
            if(is_dup)
            {
                cur = (uint64_t)-1;
                while (l < k)
                {
                    if(hits->a.a[l].e != cur)
                    {
                        cur = hits->a.a[l].e;
                        hits->a.a[m++] = hits->a.a[l];
                    }
                    l++;
                }
            }
            l = k;
        }
    }
    if(is_dup) hits->a.n = m;
    fprintf(stderr, "[M::%s::%.3f] ==> Dedup\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1365ef
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x13702f
movq (%rbx), %rax
testq %rax, %rax
jne 0x15006
xorl %r15d, %r15d
jmp 0x150d7
pushq $0x1
popq %r12
xorl %r15d, %r15d
pushq $-0x1
popq %r13
xorl %ebp, %ebp
cmpq %rax, %r12
je 0x15038
movq 0x10(%rbx), %rax
movq %r12, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rcx
movq %rbp, %rdx
shlq $0x5, %rdx
cmpq (%rax,%rdx), %rcx
je 0x150c8
movq %r12, %rax
subq %rbp, %rax
cmpq $0x2, %rax
jb 0x15061
movq 0x10(%rbx), %rax
movq %rbp, %rdi
shlq $0x5, %rdi
addq %rax, %rdi
movq %r12, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
callq 0x13729f
testq %r14, %r14
setne %al
cmpq %rbp, %r12
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x150c5
movq %rbp, %rax
shlq $0x5, %rax
orq $0x8, %rax
movq %r13, %rcx
movq 0x10(%rbx), %rsi
movq (%rsi,%rax), %rdx
cmpq %rcx, %rdx
je 0x150b9
leaq (%rsi,%rax), %rcx
addq $-0x8, %rcx
leaq 0x1(%r15), %rdi
shlq $0x5, %r15
movupd (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rsi,%r15)
movupd %xmm0, (%rsi,%r15)
movq %rdi, %r15
movq %rdx, %rcx
incq %rbp
addq $0x20, %rax
cmpq %rbp, %r12
jne 0x15082
movq %r12, %rbp
incq %r12
movq (%rbx), %rax
cmpq %rax, %r12
jbe 0x15013
testq %r14, %r14
je 0x150df
movq %r15, (%rbx)
movq 0x27fefa(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd (%rsp), %xmm0
leaq 0x226395(%rip), %rsi    # 0x23b48f
leaq 0x2263a7(%rip), %rdx    # 0x23b4a8
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: sort_hits(kvec_pe_hit*)
void sort_hits(kvec_pe_hit* hits)
{
    double index_time = yak_realtime();
    uint64_t k, l;
    radix_sort_pe_hit_an1(hits->a.a, hits->a.a + hits->a.n);
    for (k = 1, l = 0; k <= hits->a.n; ++k) 
    {   
        if (k == hits->a.n || (hits->a.a[k].s<<1) != (hits->a.a[l].s<<1)) 
        {
            if (k - l > 1) radix_sort_pe_hit_an2(hits->a.a + l, hits->a.a + k);
            l = k;
        }
    }
    fprintf(stderr, "[M::%s::%.3f] ==> Sort\n", __func__, yak_realtime()-index_time);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x1365ef
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x13702f
movq (%rbx), %rax
testq %rax, %rax
je 0x151b1
pushq $0x1
popq %r14
pushq $0x20
popq %r15
xorl %edi, %edi
cmpq %rax, %r14
je 0x15175
movq 0x10(%rbx), %rcx
movq %rdi, %rdx
shlq $0x5, %rdx
movq (%rcx,%rdx), %rdx
xorq (%rcx,%r15), %rdx
shlq %rdx
testq %rdx, %rdx
je 0x1519f
movq %r14, %rdx
subq %rdi, %rdx
movq %r14, %rcx
cmpq $0x2, %rdx
jb 0x151a2
movq 0x10(%rbx), %rsi
shlq $0x5, %rdi
addq %rsi, %rdi
addq %r15, %rsi
callq 0x13729f
movq (%rbx), %rax
movq %r14, %rcx
jmp 0x151a2
movq %rdi, %rcx
incq %r14
addq $0x20, %r15
movq %rcx, %rdi
cmpq %rax, %r14
jbe 0x15155
movq 0x27fe28(%rip), %rax    # 0x294fe0
movq (%rax), %rbx
callq 0x1365ef
subsd 0x8(%rsp), %xmm0
leaq 0x2262e6(%rip), %rsi    # 0x23b4b3
leaq 0x2262f7(%rip), %rdx    # 0x23b4cb
movq %rbx, %rdi
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: write_hc_links(hc_links*, char const*)
void write_hc_links(hc_links* link, const char *fn)
{
    uint64_t k;
    char *buf = (char*)calloc(strlen(fn) + 25, 1);
	sprintf(buf, "%s.hic.link.bin", fn);
    FILE* fp = fopen(buf, "w");

    fwrite(&link->a.n, sizeof(link->a.n), 1, fp);
    for (k = 0; k < link->a.n; k++)
    {
        fwrite(&link->a.a[k].e.n, sizeof(link->a.a[k].e.n), 1, fp);
        fwrite(link->a.a[k].e.a, sizeof(hc_edge), link->a.a[k].e.n, fp);

        fwrite(&link->a.a[k].f.n, sizeof(link->a.a[k].f.n), 1, fp);
        fwrite(link->a.a[k].f.a, sizeof(hc_edge), link->a.a[k].f.n, fp);
    }
    
    fwrite(&link->enzymes.n, sizeof(link->enzymes.n), 1, fp);
    fwrite(link->enzymes.a, sizeof(uint64_t), link->enzymes.n, fp);
    
    fclose(fp);
    free(buf);
    fprintf(stderr, "[M::%s::] ==> Hi-C linkages have been written\n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
pushq $0x1
popq %r12
movq %r12, %rsi
callq 0x2120
movq %rax, %rbx
leaq 0x225cc8(%rip), %rsi    # 0x23b7a9
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0x232bed(%rip), %rsi    # 0x2486e2
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
pushq $0x8
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x2410
cmpq $0x0, (%r14)
je 0x15b93
xorl %ebx, %ebx
xorl %r12d, %r12d
pushq $0x8
popq %r13
pushq $0x1
popq %rbp
movq 0x10(%r14), %rdi
addq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x2410
movq 0x10(%r14), %rax
movq (%rax,%rbx), %rdx
movq 0x10(%rax,%rbx), %rdi
pushq $0x28
popq %rsi
movq %r15, %rcx
callq 0x2410
movq 0x10(%r14), %rax
leaq (%rax,%rbx), %rdi
addq $0x18, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x2410
movq 0x10(%r14), %rax
movq 0x18(%rax,%rbx), %rdx
movq 0x28(%rax,%rbx), %rdi
pushq $0x28
popq %rsi
movq %r15, %rcx
callq 0x2410
incq %r12
addq $0x30, %rbx
cmpq (%r14), %r12
jb 0x15b27
leaq 0x18(%r14), %rdi
pushq $0x8
popq %r12
pushq $0x1
popq %rdx
movq %r12, %rsi
movq %r15, %rcx
callq 0x2410
movq 0x18(%r14), %rdx
movq 0x28(%r14), %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x2410
movq %r15, %rdi
callq 0x2190
movq (%rsp), %rdi
callq 0x2220
movq 0x27f40c(%rip), %rax    # 0x294fe0
movq (%rax), %rdi
leaq 0x225bdb(%rip), %rsi    # 0x23b7b9
leaq 0x225c03(%rip), %rdx    # 0x23b7e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/hic.cpp
// Function: print_src_dest(unsigned long, min_cut_t*, char const*)
void print_src_dest(uint64_t src, min_cut_t* x, const char* command)
{
    uint64_t i;
    fprintf(stderr, "********************\n%s\n", command);
    if(src >= x->n)
    {
        for (i = 0; i < x->rGraph.a[src].n; i++)
        {
            if(x->rGraph.a[src].a[i].del) continue;
            fprintf(stderr, "utg%.6ul\n", x->rGraph.a[src].a[i].uID + 1);
        }
        
    }
    else
    {
        fprintf(stderr, "utg%.6lul\n", src+1);
    }
    fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!\n");
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27f3ce(%rip), %r15    # 0x294fe0
movq (%r15), %rdi
leaq 0x225e02(%rip), %rsi    # 0x23ba1e
xorl %eax, %eax
callq 0x22b0
cmpq %r14, 0x148(%rbx)
jbe 0x15c45
movq (%r15), %rdi
incq %r14
leaq 0x225dfe(%rip), %rsi    # 0x23ba37
movq %r14, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x15c54
movq 0x10(%rbx), %rax
imulq $0x18, %r14, %r12
cmpq $0x0, (%rax,%r12)
jne 0x15c77
movq (%r15), %rcx
leaq 0x225de4(%rip), %rdi    # 0x23ba42
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2410
pushq $0x18
popq %r13
leaq 0x225f48(%rip), %r14    # 0x23bbca
xorl %ebp, %ebp
movq 0x10(%rax,%r12), %rcx
cmpb $0x0, (%rcx,%r13)
jns 0x15c9f
incq %rbp
addq $0x28, %r13
cmpq (%rax,%r12), %rbp
jb 0x15c84
jmp 0x15c54
movq (%r15), %rdi
movl -0x10(%rcx,%r13), %edx
incl %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x22b0
movq 0x10(%rbx), %rax
jmp 0x15c90