LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: label_unitigs_sm(signed char*, mc_gg_status*, ma_ug_t*)
void label_unitigs_sm(int8_t *s, mc_gg_status *sa, ma_ug_t* ug)
{
    memset(R_INF.trio_flag, AMBIGU, R_INF.total_reads * sizeof(uint8_t));
    uint32_t i, k, flag = AMBIGU;
    ma_utg_t *u = NULL;

    for (i = 0; i < ug->g->n_seq; i++)
    {
        if(ug->g->seq[i].del) continue;
        flag = 0;
        if(s)
        {
            if(s[i] == 0) continue;
            flag = (s[i] > 0? FATHER:MOTHER);
        }

        if(sa)
        {
            if(sa[i].s != 1 && sa[i].s != 2) continue;
            flag = sa[i].s;
        }
        
        u = &ug->u.a[i];
        if(u->m == 0) continue;
        for (k = 0; k < u->n; k++)
        {
            R_INF.trio_flag[u->a[k]>>33] = flag;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x13e08e(%rip), %r12    # 0x254230
movq 0x28(%r12), %rdi
movq 0x50(%r12), %rdx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x20e0
movq 0x18(%rbx), %rax
movl 0x14(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpq %rcx, %r13
jae 0x116240
movq 0x20(%rax), %rax
cmpl $0x0, (%rax,%r13,8)
js 0x116238
testq %r15, %r15
je 0x1161e9
cmpb $0x0, (%r15,%r13)
je 0x116238
setle %al
movzbl %al, %eax
incl %eax
jmp 0x1161eb
xorl %eax, %eax
testq %r14, %r14
je 0x116203
movq %r13, %rax
shlq $0x5, %rax
movl (%r14,%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0x1, %ecx
ja 0x116238
movq 0x10(%rbx), %rcx
imulq $0x28, %r13, %rdx
cmpl $0x0, 0xc(%rcx,%rdx)
je 0x116238
addq %rdx, %rcx
xorl %edx, %edx
movl 0x10(%rcx), %esi
cmpq %rsi, %rdx
jae 0x116238
movq 0x28(%r12), %rsi
movq 0x18(%rcx), %rdi
movq (%rdi,%rdx,8), %rdi
shrq $0x21, %rdi
movb %al, (%rsi,%rdi)
incq %rdx
jmp 0x116217
incq %r13
jmp 0x1161b6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: print_debug_bubble_graph(bubble_type*, ma_ug_t*, char const*)
void print_debug_bubble_graph(bubble_type* bub, ma_ug_t* ug, const char *fn)
{
    char *buf = (char*)calloc(strlen(fn) + 25, 1);
    sprintf(buf, "%s.bub.gfa", fn);
    FILE* fp = fopen(buf, "w");

    print_bubble_utg(bub, ug, "btg", fp);

    fclose(fp);
    free(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x2120
movq %rax, %r12
leaq 0xd77e6(%rip), %rsi     # 0x1ee30c
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0xe3b67(%rip), %rsi     # 0x1fa6a1
movq %r12, %rdi
callq 0x2210
movq %rax, %r15
leaq 0xd77cb(%rip), %rdx     # 0x1ee317
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq 0x1166e0
movq %r15, %rdi
callq 0x2190
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: print_bubble_chain(bubble_type*)
void print_bubble_chain(bubble_type* bub)
{
    uint32_t m, i, k;
    uint32_t beg, sink, *a = NULL, n;
    uint64_t bid;
    ma_utg_t *u = NULL; 
    for (m = 0; m < bub->chain_weight.n; m++)
    {
        if(bub->chain_weight.a[m].del) continue;
        u = &(bub->b_ug->u.a[bub->chain_weight.a[m].id]);
        fprintf(stderr, "\nChain_id=%lu\n", bub->chain_weight.a[m].id);
        for (i = 0; i < u->n; i++)
        {
            bid = u->a[i]>>33;
            get_bubbles(bub, bid, &beg, &sink, &a, &n, NULL);
            fprintf(stderr, "btg%.6lu%c, beg-utg%.6ul, sink-utg%.6ul\n", 
                        bid, "fb"[bid<bub->f_bub?0:1], (beg>>1)+1, (sink>>1)+1);
            for (k = 0; k < n; k++)
            {
                if(k != 0 && (k%5)==0) fprintf(stderr, "\n");
                fprintf(stderr, "m-utg%.6ul\t", (a[k]>>1)+1);
            }
            fprintf(stderr, "\n");
            
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x20(%rsp), %rax
andq $0x0, (%rax)
movq %rdi, %r14
xorl %r13d, %r13d
movl %r13d, %r13d
cmpq %r13, 0xc8(%r14)
jbe 0x116ce9
movq 0xd8(%r14), %rax
movq %r13, %rcx
shlq $0x5, %rcx
cmpb $0x0, 0x18(%rax,%rcx)
je 0x116bbc
incl %r13d
jmp 0x116b92
addq %rcx, %rax
movq 0xc0(%r14), %rcx
movq 0x10(%rax), %rdx
imulq $0x28, %rdx, %r12
addq 0x10(%rcx), %r12
movq 0x13c407(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0xd7738(%rip), %rsi     # 0x1ee31b
xorl %eax, %eax
callq 0x22b0
xorl %ebx, %ebx
movl 0x10(%r12), %eax
cmpq %rax, %rbx
jae 0x116bb7
movq 0x18(%r12), %rax
movq (%rax,%rbx,8), %rbp
shrq $0x21, %rbp
andq $0x0, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x14(%rsp), %r9
callq 0xf6ab5
cmpq 0x80(%r14), %rbp
leaq 0xd6c8d(%rip), %rax     # 0x1ed8c2
sbbq $-0x1, %rax
movq 0x13c3a0(%rip), %rcx    # 0x252fe0
movq (%rcx), %rdi
movsbl (%rax), %ecx
movl 0x1c(%rsp), %r8d
shrl %r8d
incl %r8d
movl 0x18(%rsp), %r9d
shrl %r9d
incl %r9d
xorl %r15d, %r15d
leaq 0xd76c4(%rip), %rsi     # 0x1ee32a
movq %rbp, %rdx
xorl %eax, %eax
callq 0x22b0
xorl %ebp, %ebp
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
movl 0x14(%rsp), %ecx
cmpq %rcx, %rbp
jae 0x116ccf
testq %rbp, %rbp
je 0x116ca3
leal (%rax,%rax,4), %eax
addl %r15d, %eax
jne 0x116ca3
movq 0x13c348(%rip), %rax    # 0x252fe0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x2270
movq 0x13c336(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl (%rax,%rbp,4), %edx
shrl %edx
incl %edx
leaq 0xd7693(%rip), %rsi     # 0x1ee353
xorl %eax, %eax
callq 0x22b0
incq %rbp
decl %r15d
jmp 0x116c72
movq 0x13c30a(%rip), %rax    # 0x252fe0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x2270
incq %rbx
jmp 0x116bec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: reset_H_partition(H_partition*, unsigned int)
void reset_H_partition(H_partition* hap, uint32_t is_init)
{
    if(!is_init)
    {
        hap->n = 0;
        free(hap->lock);
        free(hap->hap);
        hap->m[0] = hap->m[1] = hap->m[2] = (uint32_t)-1;
        hap->label = hap->label_add = hap->label_shift = (uint32_t)-1;
        destory_G_partition(&(hap->g_p)); memset(&(hap->g_p), 0, sizeof(G_partition));
        destory_G_partition(&(hap->group_g_p)); memset(&(hap->group_g_p), 0, sizeof(G_partition));
        kv_destroy(hap->label_buffer); kv_init(hap->label_buffer);
        kv_destroy(hap->b.vis); kv_init(hap->b.vis); memset(&(hap->b), 0, sizeof(block_phase_type));
    }

    memset(hap, 0, sizeof(H_partition));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jne 0x11717b
andq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
callq 0x2220
leaq 0x38(%rbx), %rdi
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rbx)
orq $-0x1, 0x28(%rbx)
callq 0x10191d
pxor %xmm0, %xmm0
movdqu %xmm0, 0x48(%rbx)
movdqu %xmm0, 0x38(%rbx)
leaq 0x58(%rbx), %rdi
callq 0x10191d
pxor %xmm0, %xmm0
movdqu %xmm0, 0x68(%rbx)
movdqu %xmm0, 0x58(%rbx)
movq 0x88(%rbx), %rdi
callq 0x2220
pxor %xmm0, %xmm0
movdqu %xmm0, 0x78(%rbx)
andq $0x0, 0x88(%rbx)
movq 0xa0(%rbx), %rdi
callq 0x2220
movl $0xc8, %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: alignment_worker_pipeline(sldat_t*, enzyme const*, enzyme const*)
int alignment_worker_pipeline(sldat_t* sl, const enzyme *fn1, const enzyme *fn2)
{
    double index_time = yak_realtime();
    int i;
    for (i = 0; i < fn1->n && i < fn2->n; i++)
    {
        gzFile fp1, fp2;
        if ((fp1 = gzopen(fn1->a[i], "r")) == 0) return 0;
        if ((fp2 = gzopen(fn2->a[i], "r")) == 0) return 0;
        sl->ks1 = kseq_init(fp1);
        sl->ks2 = kseq_init(fp2);

        kt_pipeline(3, worker_pipeline, sl, 3);
        
        kseq_destroy(sl->ks1);
        kseq_destroy(sl->ks2);
        gzclose(fp1);
        gzclose(fp2);
    }
    fprintf(stderr, "[M::%s::%.3f] ==> Qualification\n", __func__, yak_realtime()-index_time);

    dedup_hits(&(sl->hits), 1);    
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, (%rsp)
xorl %r14d, %r14d
callq 0xefea7
movsd %xmm0, 0x8(%rsp)
leaq 0xda4ff(%rip), %rbx     # 0x1f16b7
movq %r15, 0x10(%rsp)
movslq 0x8(%r15), %rax
cmpq %rax, %r14
jge 0x11727b
movslq 0x8(%rbp), %rax
cmpq %rax, %r14
jge 0x11727b
movq 0x10(%r15), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0x22d0
xorl %r12d, %r12d
testq %rax, %rax
je 0x1172bc
movq %rax, %r13
movq %rbx, %rsi
movq %rbp, %r15
movq 0x10(%rbp), %rax
movq (%rax,%r14,8), %rdi
callq 0x22d0
testq %rax, %rax
je 0x1172bc
movq %rax, %rbp
movq %r13, %rdi
callq 0xf6315
movq (%rsp), %r12
movq %rax, 0x8(%r12)
movq %rbp, %rdi
callq 0xf6315
movq %rax, 0x10(%r12)
pushq $0x3
popq %rcx
movl %ecx, %edi
leaq 0x8f(%rip), %rsi        # 0x1172ce
movq %r12, %rdx
callq 0xc6979
movq 0x8(%r12), %rdi
callq 0xf654e
movq 0x10(%r12), %rdi
callq 0xf654e
movq %r13, %rdi
callq 0x2390
movq %rbp, %rdi
callq 0x2390
incq %r14
movq %r15, %rbp
movq 0x10(%rsp), %r15
jmp 0x1171bd
movq 0x13bd5e(%rip), %rax    # 0x252fe0
movq (%rax), %r14
callq 0xefea7
subsd 0x8(%rsp), %xmm0
leaq 0xd70c8(%rip), %rsi     # 0x1ee35f
leaq 0xd70e2(%rip), %rdx     # 0x1ee380
movq %r14, %rdi
movb $0x1, %al
callq 0x22b0
movq (%rsp), %rdi
addq $0x38, %rdi
pushq $0x1
popq %rsi
callq 0xf6869
pushq $0x1
popq %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: debug_gfa_space(ha_ug_index*, ma_ug_t*, trans_chain*, kv_u_trans_t*)
void debug_gfa_space(ha_ug_index* idx, ma_ug_t* ug, trans_chain* t_ch, kv_u_trans_t *ref)
{
    bubble_type bub; 
    memset(&bub, 0, sizeof(bubble_type));
    bub.round_id = 0; bub.n_round = 2;

    identify_bubbles(ug, &bub, t_ch->ir_het, ref);

    hc_links link;
    init_hc_links(&link, ug->g->n_seq, t_ch);

    measure_distance(idx, ug, NULL, &link, &bub, &(t_ch->k_trans));

    // uint32_t i, k;
    // for (i = 0; i < link.a.n; ++i) 
    // {
    //     for (k = 0; k < link.a.a[i].e.n; k++)
    //     {
    //         if(link.a.a[i].e.a[k].del || link.a.a[i].e.a[k].dis == (uint64_t)-1) continue;
    //         fprintf(stderr, "s-utg%.6dl\td-utg%.6dl\t%lu\n", 
    //             (int)(i+1), (int)(link.a.a[i].e.a[k].uID+1), 
    //             link.a.a[i].e.a[k].dis == (uint64_t)-1? (uint64_t)-1 : link.a.a[i].e.a[k].dis>>3);
    //     }
    // }



    destory_bubbles(&bub);
    destory_hc_links(&link);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
leaq 0x38(%rsp), %rbx
movl $0x110, %edx            # imm = 0x110
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20e0
movl $0x2, 0xc(%rbx)
movq 0x10(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0xf7387
movq 0x18(%r15), %rax
movl 0x14(%rax), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x83ca2
addq $0x138, %r14            # imm = 0x138
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xfdf3d
movq %rbx, %rdi
callq 0xf6a60
movq %r12, %rdi
callq 0x83da5
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: get_u_trans_spec_idx(kv_u_trans_t*, unsigned int, unsigned int, u_trans_t**, unsigned int*, unsigned int*)
uint32_t get_u_trans_spec_idx(kv_u_trans_t *ta, uint32_t qn, uint32_t tn, u_trans_t **r_a, uint32_t *occ, uint32_t *idx)
{
    if(r_a) (*r_a) = NULL; 
    if(occ) (*occ) = 0;
    if(idx) (*idx) = (uint32_t)-1;
    u_trans_t *a = NULL;
    uint32_t n, st, i;
    a = u_trans_a(*ta, qn);
    n = u_trans_n(*ta, qn);
    for (st = 0, i = 1; i <= n; ++i)
    {
        if (i == n || a[i].tn != a[st].tn)
        {
            if(a[st].tn == tn)
            {
                if(r_a) (*r_a) = a + st;
                if(occ) (*occ) = i - st;
                if(idx) (*idx) = st + ((*ta).idx.a[(qn)]>>32);
                return 1;
            }
            st = i;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rcx, %rcx
je 0x117676
andq $0x0, (%rcx)
testq %r8, %r8
je 0x11767f
andl $0x0, (%r8)
testq %r9, %r9
je 0x117688
orl $-0x1, (%r9)
movq 0x28(%rdi), %rax
movl %esi, %esi
movq (%rax,%rsi,8), %r14
movq %r14, %rax
shrq $0x20, %rax
imulq $0x30, %rax, %rbx
addq 0x10(%rdi), %rbx
movl $0x1, %r11d
xorl %eax, %eax
xorl %r10d, %r10d
cmpl %r14d, %r11d
ja 0x11771c
movl %r10d, %r15d
jne 0x1176c1
imulq $0x30, %r15, %r12
movl 0x14(%rbx,%r12), %ebp
jmp 0x1176dd
movl %r11d, %r12d
imulq $0x30, %r12, %r12
imulq $0x30, %r15, %r13
movl 0x14(%rbx,%r13), %ebp
cmpl %ebp, 0x14(%rbx,%r12)
jne 0x1176dd
movl %r10d, %r12d
jmp 0x1176e4
movl %r11d, %r12d
cmpl %edx, %ebp
je 0x1176ec
incl %r11d
movl %r12d, %r10d
jmp 0x1176ac
testq %rcx, %rcx
je 0x1176fb
imulq $0x30, %r15, %rax
addq %rax, %rbx
movq %rbx, (%rcx)
testq %r8, %r8
je 0x117706
subl %r10d, %r11d
movl %r11d, (%r8)
movl $0x1, %eax
testq %r9, %r9
je 0x11771c
movq 0x28(%rdi), %rcx
addl 0x4(%rcx,%rsi,8), %r10d
movl %r10d, (%r9)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: hic_sc_type(ha_ug_index*, kvec_pe_hit*, unsigned long)
int hic_sc_type(ha_ug_index* idx, kvec_pe_hit* hits, uint64_t k)
{
    uint32_t s_uid, s_beg, s_end, e_uid, e_beg, e_end, slen, elen, x = 0;

    interpr_hit(idx, hits->a.a[k].s, hits->a.a[k].len>>32, &s_uid, &s_beg, &s_end); 
    s_beg = (s_beg+s_end)>>1; slen = idx->ug->u.a[s_uid].len;
    if(s_beg >= (slen>>1)) x+=1;

    interpr_hit(idx, hits->a.a[k].e, (uint32_t)hits->a.a[k].len, &e_uid, &e_beg, &e_end); 
    e_beg = (e_beg+e_end)>>1; elen = idx->ug->u.a[e_uid].len;
    if(e_beg >= (elen>>1)) x+=2;
    return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %r12
shlq $0x5, %r15
movq (%r12,%r15), %rsi
movq 0x18(%r12,%r15), %rdx
movq %rdx, 0x8(%rsp)
shrq $0x20, %rdx
leaq 0x24(%rsp), %r14
leaq 0x20(%rsp), %r13
leaq 0x1c(%rsp), %rbp
movq %r14, %rcx
movq %r13, %r8
movq %rbp, %r9
callq 0x117804
movl (%rbp), %eax
addl (%r13), %eax
shrl %eax
movl %eax, (%r13)
movq (%rbx), %rcx
movq 0x10(%rcx), %rbp
movl (%r14), %ecx
imulq $0x28, %rcx, %rcx
movl (%rbp,%rcx), %ecx
shrl %ecx
movl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
andl %edx, %ecx
xorl %r14d, %r14d
cmpl %ecx, %eax
setae %r14b
movq 0x8(%r12,%r15), %rsi
leaq 0x18(%rsp), %r15
leaq 0x14(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x117804
movl (%r13), %ecx
addl (%r12), %ecx
shrl %ecx
movl (%r15), %eax
imulq $0x28, %rax, %rax
movl (%rbp,%rax), %edx
shrl %edx
movl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
andl %eax, %edx
leal 0x2(%r14), %eax
cmpl %edx, %ecx
cmovbl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: interpr_hit(ha_ug_index*, unsigned long, unsigned int, unsigned int*, unsigned int*, unsigned int*)
void interpr_hit(ha_ug_index* idx, uint64_t x, uint32_t rLen, uint32_t *uid, uint32_t *beg, uint32_t *end)
{
    if(uid) (*uid) = ((x<<1)>>(64 - idx->uID_bits)); 
    uint32_t rev = (x>>63);
    long long ref_p = x & idx->pos_mode;
    long long p_beg, p_end;

    if(rev)
    {
        p_end = ref_p;
        p_beg = p_end + 1 - rLen;
    }
    else
    {
        p_beg = ref_p; 
        p_end = p_beg + rLen - 1;
    }
    if(p_beg < 0) p_beg = 0;
    if(p_end < 0) p_end = 0;
    if(beg) (*beg) = p_beg; 
    if(end) (*end) = p_end + 1;
}

// Assembly:
testq %rcx, %rcx
je 0x11781b
movq %rcx, %rax
leaq (%rsi,%rsi), %r10
xorl %ecx, %ecx
subb 0x18(%rdi), %cl
shrq %cl, %r10
movl %r10d, (%rax)
movq 0x30(%rdi), %rcx
andq %rsi, %rcx
movl %edx, %edx
leaq -0x1(%rdx), %rax
xorl %edi, %edi
testq %rsi, %rsi
cmovsq %rdi, %rax
addq %rcx, %rax
testq %rax, %rax
cmovleq %rdi, %rax
testq %r8, %r8
je 0x11785b
negq %rdx
testq %rsi, %rsi
leaq 0x1(%rcx,%rdx), %rdx
cmovnsq %rcx, %rdx
xorl %ecx, %ecx
testq %rdx, %rdx
cmovgq %rdx, %rcx
movl %ecx, (%r8)
testq %r9, %r9
je 0x117865
incl %eax
movl %eax, (%r9)
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: merge_u_trans_list(u_trans_t*, unsigned int)
double merge_u_trans_list(u_trans_t* a, uint32_t a_n)
{
    radix_sort_u_trans_occ(a, a + a_n);
    uint32_t k, l, i;
    double weight, w = 0;
    for (k = 1, l = 0; k <= a_n; ++k) 
    {   
        if (k == a_n || a[k].occ != a[l].occ) 
        {
            for (i = l, weight = 0; i < k; i++)
            {
                weight += a[i].nw;
            }
            
            /*******************************for debug************************************/
            // w += (weight/(double)(a[l].occ));
            w += weight;
            /*******************************for debug************************************/
            l = k;
        }
    }
    return w;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
imulq $0x30, %r14, %rsi
addq %rdi, %rsi
callq 0xf0577
leaq 0x20(%rbx), %rax
xorpd %xmm0, %xmm0
xorl %esi, %esi
pushq $0x1
popq %rcx
cmpq %r14, %rcx
ja 0x118ce5
movl %esi, %edx
je 0x118cbd
imulq $0x30, %rcx, %rdi
movl 0x18(%rbx,%rdi), %edi
imulq $0x30, %rdx, %r8
cmpl 0x18(%rbx,%r8), %edi
je 0x118ce0
imulq $0x30, %rdx, %rsi
addq %rax, %rsi
xorpd %xmm1, %xmm1
cmpq %rcx, %rdx
jae 0x118cda
addsd (%rsi), %xmm1
incq %rdx
addq $0x30, %rsi
jmp 0x118cc8
addsd %xmm1, %xmm0
movl %ecx, %esi
incq %rcx
jmp 0x118ca1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: print_kv_weight(kv_u_trans_t*, signed char*)
void print_kv_weight(kv_u_trans_t *ta, int8_t *s)
{
    uint32_t i;
    // u_trans_t *e = NULL;
    fprintf(stderr, "\n[M::%s]\n", __func__);
    fprintf(stderr, "*********ta->n: %u\n", (uint32_t)ta->n);
    for (i = 0; i < ta->n; i++)
    {
        fprintf(stderr, "+s-utg%.6ul(s:%d)\td-utg%.6ul(s:%d)\tw-%f\n", 
                        ta->a[i].qn+1, s[ta->a[i].qn], ta->a[i].tn+1, s[ta->a[i].tn], ta->a[i].nw);
        /**
        get_u_trans_spec(ta, ta->a[i].tn, ta->a[i].qn, &e, NULL);
        if(e)
        {
            fprintf(stderr, "-d-utg%.6ul->s-utg%.6ul: %f\n", e->qn+1, e->tn+1, e->nw);
        }
        else
        {
            fprintf(stderr, "ERROR");
        }
        **/
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x139ff3(%rip), %r12    # 0x252fe0
movq (%r12), %rdi
leaq 0xd53c3(%rip), %rsi     # 0x1ee3bb
leaq 0xd53c6(%rip), %rdx     # 0x1ee3c5
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
movl (%r14), %edx
leaq 0xd53bf(%rip), %rsi     # 0x1ee3d5
xorl %eax, %eax
callq 0x22b0
leaq 0xd53c5(%rip), %r15     # 0x1ee3e9
movl %ebp, %r13d
cmpq %r13, (%r14)
jbe 0x119067
movq (%r12), %rdi
movq 0x10(%r14), %rax
imulq $0x30, %r13, %rsi
movl 0x8(%rax,%rsi), %ecx
movl 0x14(%rax,%rsi), %r9d
leal 0x1(%rcx), %edx
movsbl (%rbx,%rcx), %ecx
leal 0x1(%r9), %r8d
movsbl (%rbx,%r9), %r9d
movsd 0x20(%rax,%rsi), %xmm0
movq %r15, %rsi
movb $0x1, %al
callq 0x22b0
leal 0x1(%r13), %ebp
jmp 0x119024
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: print_debug_hc_links(ha_ug_index*, bubble_type*, hc_links*, kv_u_trans_t*, kvec_pe_hit*)
void print_debug_hc_links(ha_ug_index* idx, bubble_type* bub, hc_links* lk, kv_u_trans_t *ta, kvec_pe_hit* hits)
{
    uint64_t k, len = 0, occ = 0, shif = 64 - idx->uID_bits, beg, end;
    hc_edge *e = NULL;
    for (k = 0; k < hits->a.n; ++k) 
    {
        beg = ((hits->a.a[k].s<<1)>>shif);
        end = ((hits->a.a[k].e<<1)>>shif);
        if(beg == end) continue;
        if(IF_HOM(beg, *bub)) continue;
        if(IF_HOM(end, *bub)) continue;
        len += (hits->a.a[k].len>>32) + ((uint32_t)hits->a.a[k].len);
        occ++;
    }

    fprintf(stderr, "# total Hi-C aligned bases: %lu\n", len);
    fprintf(stderr, "# total Hi-C aligned pairs: %lu\n", occ);
    for (k = 0; k < ta->n; k++)
    {
        e = get_hc_edge(lk, ta->a[k].qn, ta->a[k].tn, 0);
        fprintf(stderr, "s-utg%.6ul\td-utg%.6ul\tD:%lu\tW:%f\n", 
        ta->a[k].qn+1, ta->a[k].tn+1, e->dis == (uint64_t)-1? (uint64_t)-1 : e->dis>>3, ta->a[k].nw);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
pushq $0x40
popq %rcx
subq 0x18(%rdi), %rcx
movq (%r8), %rax
xorl %edi, %edi
xorl %r15d, %r15d
xorl %edx, %edx
subq $0x1, %rax
jb 0x1190fa
movq 0x10(%r8), %r9
movq (%r9,%rdi), %r10
addq %r10, %r10
shrq %cl, %r10
movq 0x8(%r9,%rdi), %r11
addq %r11, %r11
shrq %cl, %r11
cmpq %r11, %r10
je 0x1190f4
movq (%rsi), %r12
movq 0x80(%rsi), %r14
movl (%r12,%r10,4), %r10d
incq %r14
cmpq %r10, %r14
jb 0x1190f4
movl (%r12,%r11,4), %r10d
cmpq %r10, %r14
jb 0x1190f4
movq 0x18(%r9,%rdi), %r9
movl %r9d, %r10d
shrq $0x20, %r9
addq %rdx, %r10
addq %r9, %r10
incq %r15
movq %r10, %rdx
addq $0x20, %rdi
jmp 0x119099
movq 0x139edf(%rip), %r12    # 0x252fe0
movq (%r12), %rdi
leaq 0xd5306(%rip), %rsi     # 0x1ee412
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x22b0
movq (%r12), %rdi
leaq 0xd5312(%rip), %rsi     # 0x1ee433
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
pushq $0x20
popq %r15
cmpq (%rbx), %r14
jae 0x119197
movq 0x10(%rbx), %rbp
movl -0x18(%rbp,%r15), %r12d
movl -0xc(%rbp,%r15), %r13d
movq (%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xfcabc
movq 0x139e86(%rip), %rcx    # 0x252fe0
movq (%rcx), %rdi
leal 0x1(%r12), %edx
leal 0x1(%r13), %ecx
movq 0x10(%rax), %rax
movq %rax, %r8
shrq $0x3, %r8
cmpq $-0x1, %rax
cmoveq %rax, %r8
movsd (%rbp,%r15), %xmm0
leaq 0xd52cd(%rip), %rsi     # 0x1ee454
movb $0x1, %al
callq 0x22b0
incq %r14
addq $0x30, %r15
jmp 0x11912f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: print_kv_u_trans(kv_u_trans_t*, hc_links*, signed char*)
void print_kv_u_trans(kv_u_trans_t *ta, hc_links* lk, int8_t *s)
{
    uint32_t i;
    u_trans_t *p = NULL;
    hc_edge *e = NULL;

    for (i = 0; i < ta->n; i++)
    {
        p = &(ta->a[i]);
        e = get_hc_edge(lk, p->qn, p->tn, 0);
        fprintf(stderr, "s-utg%.6ul\tS(%d)\td-utg%.6ul\tS(%d)\trev(%u)\td(%lld)\ttw(%f)\n", 
        p->qn+1, s[p->qn], p->tn+1, s[p->tn], p->rev, 
        (e == NULL || e->dis == (uint64_t)-1)? -1 : (long long)(e->dis>>3), p->nw);
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
movl %r12d, %r12d
cmpq %r12, (%r15)
jbe 0x1193e4
movq 0x10(%r15), %r14
imulq $0x30, %r12, %rbx
movl 0x8(%r14,%rbx), %ebp
movl 0x14(%r14,%rbx), %r13d
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xfcabc
pushq $-0x1
popq %r10
testq %rax, %rax
je 0x119393
movq 0x10(%rax), %rax
movq %rax, %r10
shrq $0x3, %r10
cmpq $-0x1, %rax
cmoveq %rax, %r10
leaq (%r14,%rbx), %rax
movq 0x139c42(%rip), %rcx    # 0x252fe0
movq (%rcx), %rdi
leal 0x1(%rbp), %edx
movq 0x10(%rsp), %rsi
movsbl (%rsi,%rbp), %ecx
leal 0x1(%r13), %r8d
movsbl (%rsi,%r13), %r9d
movl 0x28(%r14,%rbx), %r11d
shrl $0x6, %r11d
andl $0x1, %r11d
movsd 0x20(%rax), %xmm0
leaq 0xd50a7(%rip), %rsi     # 0x1ee476
movb $0x1, %al
pushq %r10
pushq %r11
callq 0x22b0
popq %rcx
popq %rdx
incl %r12d
jmp 0x119347
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: init_ps_t(unsigned long, unsigned long)
ps_t* init_ps_t(uint64_t seed, uint64_t n)
{
    ps_t *s = NULL; CALLOC(s, 1);
    s->xs = seed;
    CALLOC(s->s, n);
    s->n = n;
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %r12
movq %r14, 0x8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2120
movq %rax, (%r12)
movq %rbx, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: is_hom_map(unsigned long, unsigned int, mc_interval_t*, unsigned int*, ha_ug_index*)
uint32_t is_hom_map(uint64_t x, uint32_t len, mc_interval_t *p, uint32_t *p_idx, ha_ug_index* idx)
{
    mc_interval_t *a = NULL;
    uint32_t uid, qs, qe, as, ae, occ, k;
    uint64_t oLen;
    interpr_hit(idx, x, len, &uid, &qs, &qe);

    a = p + p_idx[uid]; 
    occ = p_idx[uid+1] - p_idx[uid];
    for (k = 0; k < occ; k++)
    {
        as = a[k].bS;
        ae = a[k].bE;
        oLen = ((MIN(qe, ae) >= MAX(qs, as))? MIN(qe, ae) - MAX(qs, as) + 1 : 0);
        if(oLen == 0) continue;
        if(oLen > len*0.2) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %r8, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x117804
movl (%r15), %eax
movl (%r14,%rax,4), %edi
incl %eax
movl (%r14,%rax,4), %eax
subl %edi, %eax
movl (%r13), %ecx
movl %ebp, %edx
cvtsi2sd %rdx, %xmm0
mulsd 0xca021(%rip), %xmm0    # 0x1e34d0
movl (%r12), %edx
imulq $0x18, %rax, %rsi
addq $0x18, %rsi
imulq $0x18, %rdi, %rax
leaq (%rax,%rbx), %rdi
addq $0x4, %rdi
xorl %eax, %eax
pushq $0x1
popq %r8
xorl %r11d, %r11d
leaq 0x18(%r11), %r9
cmpq %r9, %rsi
je 0x11950a
movl -0x4(%rdi,%r11), %ebx
movl (%rdi,%r11), %r10d
cmpl %r10d, %ecx
cmovbl %ecx, %r10d
cmpl %ebx, %edx
cmoval %edx, %ebx
movq %r9, %r11
subl %ebx, %r10d
jb 0x1194d0
incl %r10d
cvtsi2sd %r10, %xmm1
ucomisd %xmm0, %xmm1
movq %r9, %r11
jbe 0x1194d0
movl %r8d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: verbose_het_stat(bubble_type*)
void verbose_het_stat(bubble_type *bub)
{
    uint64_t i, hetBase = 0, homBase = 0;
    for (i = 0; i < bub->ug->g->n_seq; i++)
    {
        if(IF_HOM(i, *bub)) homBase += bub->ug->g->seq[i].len;
        else hetBase += bub->ug->g->seq[i].len;
    }

    fprintf(stderr, "[M::stat] # heterozygous bases: %lu; # homozygous bases: %lu\n", hetBase, homBase);
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %edx, %edx
xorl %ecx, %ecx
cmpq %r9, %rsi
je 0x11982f
movq (%rdi), %r10
movq 0x80(%rdi), %r11
movl (%r10,%r9,4), %r10d
incq %r11
movq 0x20(%rax), %rbx
movl (%rbx,%r9,8), %ebx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
cmpq %r10, %r11
movq %rbx, %r10
cmovbq %r8, %r10
cmovaeq %r8, %rbx
addq %r10, %rdx
addq %rbx, %rcx
incq %r9
jmp 0x1197f2
movq 0x1397aa(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0xd4c70(%rip), %rsi     # 0x1ee4b0
xorl %eax, %eax
popq %rbx
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: print_kv_u_trans_t(kv_u_trans_t*, ma_ug_t*)
void print_kv_u_trans_t(kv_u_trans_t *ta, ma_ug_t* ug)
{
    uint32_t i;
    u_trans_t *p = NULL;
    for (i = 0; i < ta->n; i++)
    {
        p = &(ta->a[i]);
        fprintf(stderr, "q-utg%.6ul\tql(%u)\tqs(%u)\tqe(%u)\tt-utg%.6ul\ttl(%u)\tts(%u)\tte(%u)\trev(%u)\tw(%f)\tf(%u)\n", 
        p->qn+1, ug->u.a[p->qn].len, p->qs, p->qe, p->tn+1, ug->u.a[p->tn].len, p->ts, p->te, p->rev, p->nw, p->f);
    }
    fprintf(stderr, "[M::%s::] \n", __func__);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %eax, %eax
movl %eax, %r13d
cmpq %r13, (%r14)
jbe 0x119fb5
movq 0x10(%r14), %rax
imulq $0x30, %r13, %rsi
movq 0x1390af(%rip), %rcx    # 0x252fe0
movq (%rcx), %rdi
movl 0x8(%rax,%rsi), %ecx
leal 0x1(%rcx), %edx
movq (%rsp), %r8
movq 0x10(%r8), %r11
imulq $0x28, %rcx, %rcx
movl (%r11,%rcx), %ecx
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
andl %ebx, %ecx
movl (%rax,%rsi), %r8d
movl 0x4(%rax,%rsi), %r9d
movl 0x14(%rax,%rsi), %r12d
leal 0x1(%r12), %r10d
imulq $0x28, %r12, %r12
movl (%r11,%r12), %r11d
andl %ebx, %r11d
movl 0xc(%rax,%rsi), %r12d
movl 0x10(%rax,%rsi), %r15d
movsd 0x20(%rax,%rsi), %xmm0
movzbl 0x28(%rax,%rsi), %ebp
movl %ebp, %ebx
shrl $0x6, %ebx
andl $0x1, %ebx
andl $0x3f, %ebp
leaq 0xd45b0(%rip), %rsi     # 0x1ee547
movb $0x1, %al
pushq %rbp
pushq %rbx
pushq %r15
pushq %r12
pushq %r11
pushq %r10
callq 0x22b0
addq $0x30, %rsp
leal 0x1(%r13), %eax
jmp 0x119f16
movq 0x139024(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0xd45d6(%rip), %rsi     # 0x1ee59c
leaq 0xd45db(%rip), %rdx     # 0x1ee5a8
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_O2/chhylp123[P]hifiasm/hic.cpp
// Function: write_ps_t(ps_t*, char const*)
void write_ps_t(ps_t *s, const char *fn)
{
    char *buf = (char*)calloc(strlen(fn) + 25, 1);
    sprintf(buf, "%s.hic.pst.bin", fn);
    FILE* fp = fopen(buf, "w");

    fwrite(&(s->xs), sizeof(s->xs), 1, fp);
    fwrite(&(s->n), sizeof(s->n), 1, fp);
    fwrite(s->s, sizeof(int8_t), s->n, fp);

    fclose(fp);
    free(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2090
leaq 0x19(%rax), %rdi
pushq $0x1
popq %r15
movq %r15, %rsi
callq 0x2120
movq %rax, %r14
leaq 0xd45a8(%rip), %rsi     # 0x1ee5bb
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0xe067a(%rip), %rsi     # 0x1fa6a1
movq %r14, %rdi
callq 0x2210
movq %rax, %r12
leaq 0x8(%rbx), %rdi
pushq $0x8
popq %r13
movq %r13, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x2410
leaq 0x10(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2410
movq (%rbx), %rdi
movq 0x10(%rbx), %rdx
movq %r15, %rsi
movq %r12, %rcx
callq 0x2410
movq %r12, %rdi
callq 0x2190
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: load_ps_t(ps_t**, char const*)
int load_ps_t(ps_t **s, const char *fn)
{
    uint64_t flag = 0;
    char *buf = (char*)calloc(strlen(fn) + 25, 1);
    sprintf(buf, "%s.hic.pst.bin", fn);
    FILE* fp = NULL; 
    fp = fopen(buf, "r"); 
    if(!fp) return 0;
    CALLOC(*s, 1);
    flag += fread(&((*s)->xs), sizeof((*s)->xs), 1, fp);
    flag += fread(&((*s)->n), sizeof((*s)->n), 1, fp);
    MALLOC((*s)->s, (*s)->n);
    flag += fread((*s)->s, sizeof(int8_t), (*s)->n, fp);

    fclose(fp);
    free(buf);
    return 1;
}

// 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 %rsi
callq 0x2120
movq %rax, %rbx
leaq 0xd4507(%rip), %rsi     # 0x1ee5bb
xorl %ebp, %ebp
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2050
leaq 0xd75ed(%rip), %rsi     # 0x1f16b7
movq %rbx, %rdi
callq 0x2210
testq %rax, %rax
je 0x11a14f
movq %rax, %r15
pushq $0x1
popq %r12
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, (%r14)
leaq 0x8(%rax), %rdi
pushq $0x8
popq %r13
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x22f0
movq (%r14), %rdi
addq $0x10, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x22f0
movq (%r14), %r13
movq 0x10(%r13), %rdi
callq 0x2280
movq %rax, (%r13)
movq (%r14), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rdx
movq %r12, %rsi
movq %r15, %rcx
callq 0x22f0
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2220
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: get_MAPQ(u_trans_t*, unsigned int, unsigned int, double)
uint32_t get_MAPQ(u_trans_t *a, uint32_t a_n, uint32_t idx, double secondRate)
{
    uint32_t i;
    u_trans_t *p = &(a[idx]);
    uint64_t ovlp = 0;
    double aw = 0;
    for (i = 0; i < a_n; i++)
    {
        if(i == idx) continue;
        ovlp = ((MIN(a[i].qe, p->qe) > MAX(a[i].qs, p->qs))?
                                        (MIN(a[i].qe, p->qe) - MAX(a[i].qs, p->qs)):0);
        // if(p->qn == 447 && p->tn == 5495)
        // {
        //     fprintf(stderr, "ovlp: %lu, secondRate: %f, len: %u\n", ovlp, secondRate, MIN(a[i].qe - a[i].qs, p->qe - p->qs));
        // }
        if(ovlp == 0) continue;
        if(ovlp <= (secondRate*MIN(a[i].qe - a[i].qs, p->qe - p->qs))) continue;
        
        aw += a[i].nw;
    }
    // if(p->qn == 447 && p->tn == 5495) fprintf(stderr, "aw: %f\n", aw);
    aw = aw/p->nw;
    // if(p->qn == 447 && p->tn == 5495) fprintf(stderr, "aw: %f\n", aw);
    if(aw >= 1) return 16;
    if(aw >= 0.75) return 8;
    if(aw >= 0.5) return 4;
    if(aw >= 0.25) return 2;
    return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
movl %edx, %eax
imulq $0x30, %rax, %rcx
leaq (%rdi,%rcx), %rax
movl %esi, %edx
imulq $0x30, %rdx, %rdx
xorpd %xmm1, %xmm1
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x11a4a8
cmpq %rsi, %rcx
je 0x11a4a2
movl (%rdi,%rsi), %r10d
movl 0x4(%rdi,%rsi), %r8d
movl (%rax), %r11d
movl 0x4(%rax), %r9d
cmpl %r9d, %r8d
movl %r9d, %ebx
cmovbl %r8d, %ebx
cmpl %r11d, %r10d
movl %r11d, %ebp
cmoval %r10d, %ebp
subl %ebp, %ebx
jbe 0x11a4a2
cvtsi2sd %rbx, %xmm2
subl %r10d, %r8d
subl %r11d, %r9d
cmpl %r9d, %r8d
cmovbl %r8d, %r9d
cvtsi2sd %r9, %xmm3
mulsd %xmm0, %xmm3
ucomisd %xmm2, %xmm3
jae 0x11a4a2
addsd 0x20(%rdi,%rsi), %xmm1
addq $0x30, %rsi
jmp 0x11a449
divsd 0x20(%rax), %xmm1
ucomisd 0xc8deb(%rip), %xmm1    # 0x1e32a0
jae 0x11a4dd
ucomisd 0xc90c9(%rip), %xmm1    # 0x1e3588
jae 0x11a4e4
ucomisd 0xc907f(%rip), %xmm1    # 0x1e3548
jae 0x11a4eb
ucomisd 0xc904d(%rip), %xmm1    # 0x1e3520
movl $0x2, %eax
sbbl $0x0, %eax
jmp 0x11a4f0
movl $0x10, %eax
jmp 0x11a4f0
movl $0x8, %eax
jmp 0x11a4f0
movl $0x4, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: check_ovlp(f_chain_t*, unsigned long, unsigned long, unsigned long)
uint64_t check_ovlp(f_chain_t *o, uint64_t on, uint64_t qs, uint64_t qe)
{
    uint64_t i, ovlp;
    for (i = 0; i < on; i++)
    {
        ovlp = ((MIN(o[i].e, qe) > MAX(o[i].s, qs))?
                                        (MIN(o[i].e, qe) - MAX(o[i].s, qs)):0);
        if(ovlp) return 1;
    }
    return 0;
}

// Assembly:
incq %rsi
addq $0x8, %rdi
pushq $0x1
popq %rax
decq %rsi
je 0x11a625
movq -0x8(%rdi), %r8
movq (%rdi), %r9
cmpq %rcx, %r9
cmovaeq %rcx, %r9
cmpq %rdx, %r8
cmovbeq %rdx, %r8
addq $0x10, %rdi
cmpq %r8, %r9
jbe 0x11a601
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: set_tag_pre_read(unsigned long*, unsigned long, unsigned long, unsigned long, ma_hit_t_alloc*)
void set_tag_pre_read(uint64_t *r_tag, uint64_t id, uint64_t off, uint64_t pos, ma_hit_t_alloc* sources)
{
    uint64_t i, tn;
    ma_hit_t *h = NULL;
    if(r_tag[id] == (uint64_t)-1) r_tag[id] = 0;
    r_tag[id] += off;
    // if(id == 2531247) fprintf(stderr, "***id: %lu, off: %lu, pos: %lu\n", id, off, pos);
    for (i = 0; i < (uint64_t)(sources[id].length); i++)
    {
        h = &(sources[id].buffer[i]);
        if(!h->el) continue;
        tn = Get_tn((*h));
        if(pos >= Get_qs((*h)) && pos < Get_qe((*h)))
        {
            // if(tn == 2531247) fprintf(stderr, "###id: %lu, off: %lu, tn: %lu, pos: %lu\n", id, off, tn, pos);
            if(r_tag[tn] == (uint64_t)-1) r_tag[tn] = 0;
            r_tag[tn] += off;
        }
        
    }
}

// Assembly:
movq (%rdi,%rsi,8), %r9
xorl %eax, %eax
cmpq $-0x1, %r9
cmoveq %rax, %r9
addq %rdx, %r9
movq %r9, (%rdi,%rsi,8)
imulq $0x18, %rsi, %r9
leaq (%r8,%r9), %rsi
movl 0xc(%r8,%r9), %r8d
xorl %r9d, %r9d
cmpq %r8, %r9
jae 0x11ab99
movq (%rsi), %r10
cmpb $0x0, 0x20(%r10,%rax)
je 0x11ab90
movl (%r10,%rax), %r11d
cmpq %rcx, %r11
ja 0x11ab90
movl 0x8(%r10,%rax), %r11d
cmpq %rcx, %r11
jbe 0x11ab90
movl 0xc(%r10,%rax), %r10d
movq (%rdi,%r10,8), %r11
cmpq $-0x1, %r11
jne 0x11ab89
xorl %r11d, %r11d
addq %rdx, %r11
movq %r11, (%rdi,%r10,8)
incq %r9
addq $0x28, %rax
jmp 0x11ab54
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: renew_idx_para(ha_ug_index*, ma_ug_t*)
void renew_idx_para(ha_ug_index* idx, ma_ug_t* ug)
{
    for (idx->uID_bits=1; (uint64_t)(1<<idx->uID_bits)<(uint64_t)ug->u.n; idx->uID_bits++);
    idx->pos_bits = 64 - idx->uID_bits - 1;
    idx->uID_mode = (((uint64_t)-1) << (64-idx->uID_bits))>>1;
    idx->pos_mode = ((uint64_t)-1) >> (64-idx->pos_bits);
    idx->rev_mode = ((uint64_t)1) << 63;
}

// Assembly:
movq (%rsi), %rsi
pushq $0x1
popq %rax
xorl %edx, %edx
pushq $0x1
popq %r8
movl %r8d, %r9d
movl %eax, %ecx
shll %cl, %r9d
movslq %r9d, %rcx
incq %rax
decq %rdx
cmpq %rcx, %rsi
ja 0x11af00
movq %rdx, %rcx
negq %rcx
movq %rcx, 0x18(%rdi)
leaq 0x3f(%rdx), %rcx
movq %rcx, 0x28(%rdi)
pushq $-0x1
popq %rsi
movq %rsi, %r8
movl %edx, %ecx
shlq %cl, %r8
shrq %r8
movl %eax, %ecx
shrq %cl, %rsi
movq %r8, 0x20(%rdi)
movq %rsi, 0x30(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x38(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: get_oe_occ(unsigned int, unsigned int, kvec_pe_hit*, ha_ug_index*)
uint32_t get_oe_occ(uint32_t qn, uint32_t tn, kvec_pe_hit* hits, ha_ug_index* idx)
{
    uint64_t shif = 64 - idx->uID_bits, occ = 0;
    pe_hit *h_a = hits->a.a + (hits->idx.a[qn]>>32);
    uint32_t h_occ = (uint32_t)(hits->idx.a[qn]), i;
    for (i = 0; i < h_occ; i++) {
        if(((h_a[i].s<<1)>>shif)==qn && ((h_a[i].e<<1)>>shif)==tn) occ++;
    }
    return occ;
}

// Assembly:
movq %rcx, %rax
pushq $0x40
popq %rcx
subq 0x18(%rax), %rcx
movq 0x10(%rdx), %rax
movq 0x28(%rdx), %r8
movl %edi, %edx
movq (%r8,%rdx,8), %r8
movl %esi, %esi
movl %r8d, %edi
shlq $0x5, %rdi
shrq $0x1b, %r8
andq $-0x20, %r8
addq %rax, %r8
addq $0x8, %r8
xorl %r9d, %r9d
xorl %eax, %eax
cmpq %r9, %rdi
je 0x11afb9
movq -0x8(%r8,%r9), %r10
addq %r10, %r10
shrq %cl, %r10
cmpq %rdx, %r10
jne 0x11afb3
movq (%r8,%r9), %r10
addq %r10, %r10
shrq %cl, %r10
xorl %r11d, %r11d
cmpq %rsi, %r10
sete %r11b
addl %r11d, %eax
addq $0x20, %r9
jmp 0x11af87
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: round_test(ps_t*, unsigned long, bubble_type*, kv_u_trans_t*, hc_links*, sldat_t*, ha_ug_index*, unsigned long, unsigned long)
void round_test(ps_t *s, uint64_t seed, bubble_type *bub, kv_u_trans_t *k_trans, hc_links *link, sldat_t *sl, 
ha_ug_index* idx, uint64_t test_block_flip, uint64_t n_perturb)
{
    s->xs = seed; memset(s->s, 0, s->n);
    bub->round_id = 0; asm_opt.n_perturb = n_perturb;

    fprintf(stderr, "[M::%s] ----> test_block_flip: %lu, n_perturb: %lu\n", 
    __func__, test_block_flip, n_perturb);
    renew_kv_u_trans(k_trans, link, &sl->hits, &(idx->t_ch->k_trans), idx, bub, s->s, NULL, 0);    
    mc_solve(NULL, NULL, k_trans, idx->ug, idx->read_g, 0.8, R_INF.trio_flag, 
        (bub->round_id == 0? 1 : 0), s->s, 1, NULL, test_block_flip?&(idx->t_ch->k_trans):0, 0, 0);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbp
movq %r8, 0x38(%rsp)
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %r12
movq 0x80(%rsp), %r14
movq 0x90(%rsp), %rbx
movq %rsi, 0x8(%rdi)
movq (%rdi), %rdi
movq 0x10(%r12), %rdx
xorl %esi, %esi
callq 0x20e0
andl $0x0, 0x8(%r15)
leaq 0x1382cd(%rip), %rax    # 0x253758
movl %ebx, 0x1d0(%rax)
movq 0x137b48(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0xd3263(%rip), %rsi     # 0x1ee705
leaq 0xd3290(%rip), %rdx     # 0x1ee739
movq 0x88(%rsp), %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x22b0
addq $0x38, %rbp
movl $0x138, %ebx            # imm = 0x138
movq 0x10(%r14), %rcx
addq %rbx, %rcx
movq (%r12), %rax
andl $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq %rax, (%rsp)
movq %r13, 0x40(%rsp)
movq %r13, %rdi
movq 0x38(%rsp), %rsi
movq %rbp, %rdx
movq %r14, %r8
movq %r15, %r9
callq 0x1191a6
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x138d29(%rip), %rax    # 0x254230
movq 0x28(%rax), %r9
movl 0x8(%r15), %edx
movq (%r12), %rax
cmpq $0x0, 0x88(%rsp)
je 0x11b524
addq 0x10(%r14), %rbx
jmp 0x11b526
xorl %ebx, %ebx
xorl %esi, %esi
testl %edx, %edx
sete %sil
movq %rbx, 0x20(%rsp)
movq %rax, 0x8(%rsp)
andl $0x0, 0x30(%rsp)
movl %esi, (%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x18(%rsp)
movl $0x1, 0x10(%rsp)
movsd 0xc7fa5(%rip), %xmm0    # 0x1e3500
xorl %edi, %edi
xorl %esi, %esi
movq 0x40(%rsp), %rdx
callq 0x12b808
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: debug_round_test(ps_t*, unsigned long, bubble_type*, kv_u_trans_t*, hc_links*, sldat_t*, ha_ug_index*, unsigned long, unsigned long)
void debug_round_test(ps_t *s, uint64_t seed, bubble_type *bub, kv_u_trans_t *k_trans, hc_links *link, sldat_t *sl, 
ha_ug_index* idx, uint64_t step, uint64_t total)
{
    uint64_t i;
    for (i = step; i <= total; i += step) {
        fprintf(stderr, "\n");
        round_test(s, seed, bub, k_trans, link, sl, idx, 0, i);
        round_test(s, seed, bub, k_trans, link, sl, idx, 1, i);
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r13
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r15
movq 0x30(%rsp), %r14
cmpq 0x80(%rsp), %rax
ja 0x11b64c
movq %rax, (%rsp)
movq 0x137a04(%rip), %rax    # 0x252fe0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x2270
subq $0x8, %rsp
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x8(%rsp)
pushq $0x0
movq 0x88(%rsp), %rax
pushq %rax
callq 0x11b43d
addq $0x18, %rsp
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
pushq 0x8(%rsp)
pushq $0x1
pushq 0x88(%rsp)
callq 0x11b43d
movq 0x20(%rsp), %rax
addq $0x20, %rsp
addq 0x78(%rsp), %rax
jmp 0x11b5c7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: prt_hits_noid(ha_ug_index*, ma_ug_t*, kvec_pe_hit*, _IO_FILE*)
void prt_hits_noid(ha_ug_index* idx, ma_ug_t* ug, kvec_pe_hit* hits, FILE *fn)
{
    uint64_t k, shif = 64 - idx->uID_bits;
    char dir[2] = {'+', '-'};
    for (k = 0; k < hits->a.n; ++k) { 
        fprintf(fn, "r-%lu-th\t%c\trs-utg%.6d%c\t%lu\t%c\tre-utg%.6d%c\t%lu\n", 
        hits->a.a[k].id,
        dir[hits->a.a[k].s>>63], (int)((hits->a.a[k].s<<1)>>shif)+1, 
        "lc"[ug->u.a[((hits->a.a[k].s<<1)>>shif)].circ], hits->a.a[k].s&idx->pos_mode,
        dir[hits->a.a[k].e>>63], (int)((hits->a.a[k].e<<1)>>shif)+1, 
        "lc"[ug->u.a[((hits->a.a[k].e<<1)>>shif)].circ], hits->a.a[k].e&idx->pos_mode);        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, 0x18(%rsp)
pushq $0x40
popq %rax
movq %rdi, 0x10(%rsp)
subq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
pushq $0x10
popq %rbp
xorl %ebx, %ebx
cmpq (%r13), %rbx
jae 0x11b758
movq 0x10(%r13), %rax
movq -0x10(%rax,%rbp), %r10
movq -0x8(%rax,%rbp), %r14
movq %r10, %rsi
leaq (%r10,%r10), %rdi
movq 0x8(%rsp), %r11
movl %r11d, %ecx
shrq %cl, %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rdx
imulq $0x28, %rdi, %rcx
movl (%rdx,%rcx), %r9d
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %r8
leaq (%r14,%r14), %r12
movl %r11d, %ecx
shrq %cl, %r12
andq %r8, %r10
imulq $0x28, %r12, %rcx
movl (%rdx,%rcx), %r15d
movq %r14, %r11
andq %r8, %r14
movq (%rax,%rbp), %rdx
shrq $0x3f, %rsi
leaq 0xd1a92(%rip), %rax     # 0x1ed18c
movsbl (%rsi,%rax), %ecx
leal 0x1(%rdi), %r8d
shrl $0x1f, %r9d
leaq 0xcaf7e(%rip), %rsi     # 0x1e668b
movsbl (%r9,%rsi), %r9d
shrq $0x3f, %r11
movsbl (%r11,%rax), %r11d
incl %r12d
shrl $0x1f, %r15d
movsbl (%r15,%rsi), %r15d
subq $0x8, %rsp
movq 0x28(%rsp), %rdi
leaq 0xd300d(%rip), %rsi     # 0x1ee744
xorl %eax, %eax
pushq %r14
pushq %r15
pushq %r12
pushq %r11
pushq %r10
callq 0x22b0
addq $0x30, %rsp
incq %rbx
addq $0x20, %rbp
jmp 0x11b68c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/hic.cpp
// Function: prt_utg_trans(kv_u_trans_t*, ma_ug_t*, _IO_FILE*)
void prt_utg_trans(kv_u_trans_t *ta, ma_ug_t* ug, FILE *fn)
{
    uint32_t i;
    u_trans_t *p = NULL;
    for (i = 0; i < ta->n; i++) {
        p = &(ta->a[i]);
        fprintf(fn, "utg%.6u%c\t%u\t%u\t%u\t%c\tutg%.6u%c\t%u\t%u\t%u\tw(%f)\tf(%u)\n", 
        p->qn+1, "lc"[ug->u.a[p->qn].circ], ug->u.a[p->qn].len, p->qs, p->qe, "+-"[p->rev],
        p->tn+1, "lc"[ug->u.a[p->tn].circ], ug->u.a[p->tn].len, p->ts, p->te, p->nw, p->f);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
movq %rdi, 0x8(%rsp)
movl %eax, %r12d
cmpq %r12, (%rdi)
jbe 0x11b862
movq 0x10(%rdi), %rax
imulq $0x30, %r12, %rsi
movl 0x8(%rax,%rsi), %ecx
leal 0x1(%rcx), %edx
movq 0x10(%rsp), %rdi
movq 0x10(%rdi), %rdi
imulq $0x28, %rcx, %rcx
movl (%rdi,%rcx), %r8d
movl %r8d, %ecx
shrl $0x1f, %ecx
leaq 0xcaecc(%rip), %r10     # 0x1e668b
movsbl (%rcx,%r10), %ecx
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
andl %r9d, %r8d
movl (%rax,%rsi), %r9d
movl 0x4(%rax,%rsi), %r11d
movq %r11, 0x20(%rsp)
movzbl 0x28(%rax,%rsi), %r13d
btl $0x6, %r13d
leaq 0xc8a36(%rip), %r11     # 0x1e4223
adcq $0x0, %r11
movsbl (%r11), %r11d
movl 0x14(%rax,%rsi), %r14d
leal 0x1(%r14), %ebx
imulq $0x28, %r14, %r14
movl (%rdi,%r14), %r14d
movl 0xc(%rax,%rsi), %ebp
movsd 0x20(%rax,%rsi), %xmm0
movl 0x10(%rax,%rsi), %r15d
movl %r14d, %eax
shrl $0x1f, %eax
movsbl (%rax,%r10), %r10d
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl %eax, %r14d
andl $0x3f, %r13d
movq 0x18(%rsp), %rdi
leaq 0xcd37f(%rip), %rsi     # 0x1e8bb7
movb $0x1, %al
pushq %r13
pushq %r15
pushq %rbp
pushq %r14
pushq %r10
pushq %rbx
pushq %r11
pushq 0x58(%rsp)
callq 0x22b0
movq 0x48(%rsp), %rdi
addq $0x40, %rsp
leal 0x1(%r12), %eax
jmp 0x11b786
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq