LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: gen_ovlst_paf(ma_hit_t_alloc*, ma_hit_t_alloc*, asg64_v*)
void gen_ovlst_paf(ma_hit_t_alloc *in_e, ma_hit_t_alloc *in_r, asg64_v *ou)
{
    uint32_t n = 0, k; 

    for (k = 0; k < in_e->length; k++) {
        if(!(in_e->buffer[k].el)) n++;
    }
    n += in_r->length;

    kv_resize(uint64_t, *ou, n); ou->n = 0;

    for (k = 0; k < in_e->length; k++) {
        if(!(in_e->buffer[k].el)) {
            ou->a[ou->n] = in_e->buffer[k].tn;
            ou->a[ou->n] <<= 1; ou->a[ou->n] |= in_e->buffer[k].rev;
            ou->n++;
        }
    }

    for (k = 0; k < in_r->length; k++) {
        ou->a[ou->n] = in_r->buffer[k].tn;
        ou->a[ou->n] <<= 1; ou->a[ou->n] |= in_r->buffer[k].rev;
        ou->n++;
    }

    radix_sort_ec64(ou->a, ou->a+ou->n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0xc(%rdi), %eax
testq %rax, %rax
je 0x183c1f
movq (%r15), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpb $0x1, 0x20(%rcx,%rsi)
adcl $0x0, %eax
addq $0x28, %rsi
cmpq %rsi, %rdx
jne 0x183c0c
jmp 0x183c21
xorl %eax, %eax
addl 0xc(%r14), %eax
cmpq %rax, 0x8(%rbx)
jae 0x183c7c
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq 0x8(,%rcx,8), %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movq $0x0, (%rbx)
movl 0xc(%r15), %ecx
testq %rcx, %rcx
je 0x183cd0
movq (%r15), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
xorl %edx, %edx
cmpb $0x0, 0x20(%rax,%rdx)
jne 0x183cc7
movl 0xc(%rax,%rdx), %esi
movq (%rbx), %rdi
movq 0x10(%rbx), %r8
movq %rsi, (%r8,%rdi,8)
movq (%rbx), %rsi
shlq (%r8,%rsi,8)
movl 0x18(%rax,%rdx), %esi
shrl $0x1f, %esi
movq (%rbx), %rdi
orq %rsi, (%r8,%rdi,8)
incq (%rbx)
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x183c99
movl 0xc(%r14), %edx
testq %rdx, %rdx
je 0x183d16
movq (%r14), %rax
movq 0x10(%rbx), %rcx
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
xorl %esi, %esi
movl 0xc(%rax,%rsi), %edi
movq (%rbx), %r8
movq %rdi, (%rcx,%r8,8)
movq (%rbx), %rdi
shlq (%rcx,%rdi,8)
movl 0x18(%rax,%rsi), %edi
shrl $0x1f, %edi
movq (%rbx), %r8
orq %rdi, (%rcx,%r8,8)
incq (%rbx)
addq $0x28, %rsi
cmpq %rsi, %rdx
jne 0x183cea
movq (%rbx), %rax
movq 0x10(%rbx), %rdi
leaq (%rdi,%rax,8), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x178fc2
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: dbg_overlap_region_cigar(overlap_region*, unsigned long, char*, All_reads*, UC_Read*)
void dbg_overlap_region_cigar(overlap_region *a, uint64_t a_n, char *qstr, All_reads *rref, UC_Read *tu)
{
    bit_extz_t ez; uint64_t i, k;
    for (i = 0; i < a_n; i++) {
        if(a[i].y_pos_strand) {
            recover_UC_Read_RC(tu, rref, a[i].y_id);
        } else {
            recover_UC_Read(tu, rref, a[i].y_id);
        }
        for (k = 0; k < a[i].w_list.n; k++) {
            if(is_ualn_win((a[i].w_list.a[k]))) continue;
            set_bit_extz_t(ez, a[i], k);
            if(!cigar_check(tu->seq, qstr, &ez)) {
                fprintf(stderr, "\n-0-[M::%s] x_id::%u, y_id::%u, x::[%u, %u), y::[%u, %u)\n", __func__, a[i].x_id, a[i].y_id, a[i].x_pos_s, a[i].x_pos_e + 1, a[i].y_pos_s, a[i].y_pos_e + 1);
                exit(1);
            } else {
                // fprintf(stderr, "\n-1-[M::%s] x_id::%u, y_id::%u, x::[%u, %u), y::[%u, %u)\n", __func__, a[i].x_id, a[i].y_id, a[i].x_pos_s, a[i].x_pos_e + 1, a[i].y_pos_s, a[i].y_pos_e + 1);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, (%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0x183e5d
movq %r8, %rbx
movq %rdx, %r15
movq %rdi, %r12
xorl %eax, %eax
leaq 0x20(%rsp), %rbp
movq %rdi, 0x8(%rsp)
movq %rax, 0x18(%rsp)
imulq $0xa8, %rax, %r14
cmpl $0x0, 0x1c(%r12,%r14)
movl 0x10(%r12,%r14), %edx
movq %rbx, %rdi
je 0x183d8a
movq (%rsp), %rsi
callq 0x33dc3
jmp 0x183d93
movq (%rsp), %rsi
callq 0x33cf8
addq %r12, %r14
cmpq $0x0, 0x48(%r14)
je 0x183e45
movl $0x1c, %r13d
xorl %r12d, %r12d
movq 0x58(%r14), %rax
cmpw $0x7fff, -0x8(%rax,%r13) # imm = 0x7FFF
jne 0x183dc8
cmpl $0x0, (%rax,%r13)
jne 0x183dc8
cmpw $0x0, -0xa(%rax,%r13)
js 0x183e34
movl -0x4(%rax,%r13), %ecx
addq %rcx, %rcx
addq 0x70(%r14), %rcx
movq %rcx, 0xd8(%rsp)
movl (%rax,%r13), %ecx
movq %rcx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movl -0x1c(%rax,%r13), %ecx
movl %ecx, 0x3c(%rsp)
movl -0x18(%rax,%r13), %ecx
movl %ecx, 0x40(%rsp)
movl -0x14(%rax,%r13), %ecx
movl %ecx, 0x30(%rsp)
movl -0x10(%rax,%r13), %ecx
movl %ecx, 0x34(%rsp)
movswl -0x8(%rax,%r13), %eax
movl %eax, 0x4c(%rsp)
movl %eax, 0x48(%rsp)
movq (%rbx), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x97ed2
testl %eax, %eax
je 0x183e6f
incq %r12
addq $0x20, %r13
cmpq 0x48(%r14), %r12
jb 0x183daa
movq 0x18(%rsp), %rax
incq %rax
cmpq 0x10(%rsp), %rax
movq 0x8(%rsp), %r12
jne 0x183d63
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x23804
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_updated_trace_len(asg16_v*, unsigned long*, unsigned long*)
void cal_updated_trace_len(asg16_v *sc, uint64_t *ql, uint64_t *tl)
{
    uint64_t ck = 0, qk = 0, tk = 0; uint32_t len; uint16_t c, bq, bt;
    while (ck < sc->n) {
        ck = pop_trace_bp_f(sc, ck, &c, &bq, &bt, &len);
        if(c != 2) qk += len;
        if(c != 3) tk += len;
    }
    *ql = qk; *tl = tk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x188b11
movq 0x10(%rdi), %r8
xorl %eax, %eax
xorl %esi, %esi
xorl %edi, %edi
xorl %r10d, %r10d
movzwl (%r8,%r10,2), %r14d
movl %r14d, %r11d
shrl $0xe, %r11d
leal -0x2(%r11), %edx
cmpl $0x2, %edx
jae 0x188a2f
movl %r14d, %ebx
shrl $0xc, %ebx
andl $0x3, %ebx
andl $0xfff, %r14d           # imm = 0xFFF
jmp 0x188a3f
testl %r11d, %r11d
jne 0x188a46
andl $0x3fff, %r14d          # imm = 0x3FFF
movw $0xffff, %bx            # imm = 0xFFFF
movl $0xffff, %ebp           # imm = 0xFFFF
jmp 0x188a5f
movl %r14d, %ebx
shrl $0xc, %ebx
andl $0x3, %ebx
movl %r14d, %ebp
shrl $0xa, %ebp
andl $0x3, %ebp
andl $0x3ff, %r14d           # imm = 0x3FF
movzwl %r14w, %r14d
incl %r10d
cmpq %r10, %rcx
jbe 0x188ae5
movzwl %r11w, %r15d
leal -0x2(%r15), %r12d
movzwl (%r8,%r10,2), %r13d
movl %r13d, %edx
shrl $0xe, %edx
cmpl %r11d, %edx
jne 0x188ae5
cmpl $0x2, %r12d
jae 0x188a9d
movl %r13d, %r9d
shrl $0xc, %r9d
andl $0x3, %r9d
andl $0xfff, %r13d           # imm = 0xFFF
jmp 0x188aae
testl %r15d, %r15d
jne 0x188ab5
andl $0x3fff, %r13d          # imm = 0x3FFF
movw $0xffff, %r9w           # imm = 0xFFFF
movl $0xffff, %edx           # imm = 0xFFFF
jmp 0x188ad0
movl %r13d, %r9d
shrl $0xc, %r9d
andl $0x3, %r9d
movl %r13d, %edx
shrl $0xa, %edx
andl $0x3, %edx
andl $0x3ff, %r13d           # imm = 0x3FF
cmpl %ebp, %edx
jne 0x188ae5
cmpw %r9w, %bx
jne 0x188ae5
addl %r13d, %r14d
incl %r10d
cmpq %r10, %rcx
ja 0x188a73
cmpw $0x2, %r11w
movl %r14d, %edx
movq %rdx, %r9
cmoveq %rsi, %r9
addq %r9, %rdi
cmpw $0x3, %r11w
movl %r10d, %r10d
cmoveq %rsi, %rdx
addq %rdx, %rax
cmpq %r10, %rcx
ja 0x188a08
jmp 0x188b15
xorl %edi, %edi
xorl %eax, %eax
movq -0x10(%rsp), %rcx
movq %rdi, (%rcx)
movq -0x8(%rsp), %rcx
movq %rax, (%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: worker_update_dc_ec(void*, long, int)
static void worker_update_dc_ec(void *data, long i, int tid)
{
    ec_ovec_buf_t0 *b = &(((ec_ovec_buf_t*)data)->a[tid]);
    uint64_t k; ma_hit_t *z;
    // fprintf(stderr, "-0-[M::%s-beg] rid->%ld\n", __func__, i);
    // if (memcmp("m64012_190921_234837/139067658/ccs", Get_NAME((R_INF), i), Get_NAME_LENGTH((R_INF),i)) == 0) {
    //     fprintf(stderr, "-0-[M::%s-beg] rid->%ld\n", __func__, i);
    // } else if (memcmp("m64012_190921_234837/28968323/ccs", Get_NAME((R_INF), i), Get_NAME_LENGTH((R_INF),i)) == 0) {
    //     fprintf(stderr, "-1-[M::%s-beg] rid->%ld\n", __func__, i);
    // } else {
    //     return;
    // }
    // if(i != 2851) return;

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


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

    refresh_ec_ovec_buf_t0(b, REFRESH_N);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x100ca2(%rip), %rbx    # 0x28b230
movq 0x78(%rbx), %rcx
leaq (%rsi,%rsi,2), %r13
cmpl $0x0, 0xc(%rcx,%r13,8)
je 0x18a66b
movq %rsi, %rax
movslq %edx, %rcx
imulq $0x5c0, %rcx, %r14      # imm = 0x5C0
addq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x33cf8
movq 0x78(%rbx), %rax
cmpl $0x0, 0xc(%rax,%r13,8)
je 0x18a650
leaq (%rax,%r13,8), %rax
leaq 0x20(%r14), %rcx
movq %rcx, 0x10(%rsp)
leaq 0xc0(%r14), %rcx
movq %rcx, 0x8(%rsp)
leaq 0xc8(%r14), %rcx
movq %rcx, (%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rax), %rbp
cmpb $0x0, 0x20(%rbp,%r15)
je 0x18a62b
leaq (%r15,%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
leaq 0x100f1d(%rip), %r8     # 0x28b538
callq 0x182573
movb $0x1, %cl
movq 0x8(%rsp), %rdx
testl %eax, %eax
jne 0x18a631
xorl %ecx, %ecx
movq (%rsp), %rdx
movb %cl, 0x20(%rbp,%r15)
incq (%rdx)
incq %r12
movq 0x78(%rbx), %rax
leaq (%rax,%r13,8), %rax
movl 0xc(%rax), %ecx
addq $0x28, %r15
cmpq %rcx, %r12
jb 0x18a5fa
movl $0x80, %esi
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18db6a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: worker_hap_dc_ec(void*, long, int)
static void worker_hap_dc_ec(void *data, long i, int tid)
{
    ec_ovec_buf_t0 *b = &(((ec_ovec_buf_t*)data)->a[tid]);
    // fprintf(stderr, "-0-[M::%s-beg] rid->%ld\n", __func__, i);
    // if (memcmp("m64012_190921_234837/139067658/ccs", Get_NAME((R_INF), i), Get_NAME_LENGTH((R_INF),i)) == 0) {
    //     fprintf(stderr, "-0-[M::%s-beg] rid->%ld\n", __func__, i);
    // } else if (memcmp("m64012_190921_234837/28968323/ccs", Get_NAME((R_INF), i), Get_NAME_LENGTH((R_INF),i)) == 0) {
    //     fprintf(stderr, "-1-[M::%s-beg] rid->%ld\n", __func__, i);
    // } else {
    //     return;
    // }
    // if(i != 2851) return;

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

    scc.f[i] = 0;

    if(!(R_INF.paf[i].length)) return;
    // if(scc.f[i]) return;
    asg64_v buf0;

    recover_UC_Read(&b->self_read, &R_INF, i);

    copy_asg_arr(buf0, b->sp);
    if(gen_hap_dc_cov(&(b->v64), &buf0, &(R_INF.paf[i]), &R_INF, WINDOW_HC_FAST, 4, 0.7, &b->self_read, &b->ovlp_read, &scc, i)) {
        scc.f[i] = 1; b->cnt[0]++;
        // fprintf(stderr, "-mm-[M::%s]\tqn::%u::%.*s\n", __func__, (uint32_t)(i), (int)Get_NAME_LENGTH(R_INF, i), Get_NAME((R_INF), i));
    } else {
        scc.f[i] = 0; b->cnt[1]++;
        // fprintf(stderr, "-um-[M::%s]\tqn::%u::%.*s\n", __func__, (uint32_t)(i), (int)Get_NAME_LENGTH(R_INF, i), Get_NAME((R_INF), i));
    }
    copy_asg_arr(b->sp, buf0);

    refresh_ec_ovec_buf_t0(b, REFRESH_N);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdi), %rbp
movq 0x1008aa(%rip), %rax    # 0x28b550
movb $0x0, (%rax,%rsi)
leaq 0x10057f(%rip), %rsi    # 0x28b230
movq 0x78(%rsi), %rax
leaq (%rbx,%rbx,2), %r13
cmpl $0x0, 0xc(%rax,%r13,8)
je 0x18ad9b
movslq %edx, %rax
imulq $0x5c0, %rax, %r12      # imm = 0x5C0
leaq (%r12,%rbp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x33cf8
leaq (%r12,%rbp), %rdi
addq $0x4d0, %rdi            # imm = 0x4D0
movq 0xa8(%rdi), %rax
movq %rsp, %r15
movq %rax, 0x10(%r15)
movq 0x98(%rdi), %rax
movq %rax, (%r15)
movq 0xa0(%rdi), %rax
movq %rax, 0x8(%r15)
shlq $0x3, %r13
leaq 0x100519(%rip), %rcx    # 0x28b230
addq 0x78(%rcx), %r13
addq %r12, %rbp
addq $0x20, %rbp
subq $0x8, %rsp
leaq 0x10080b(%rip), %rax    # 0x28b538
movsd 0x9a76b(%rip), %xmm0    # 0x2254a0
movl $0x200, %r8d            # imm = 0x200
movl $0x4, %r9d
movq %r15, %rsi
movq %r13, %rdx
pushq %rax
pushq %rbp
pushq %r14
callq 0x1827ff
addq $0x20, %rsp
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
movq 0x1007ed(%rip), %rdx    # 0x28b550
movb %al, (%rdx,%rbx)
incq 0xc0(%r14,%rcx,8)
movq 0x10(%r15), %rax
movq %rax, 0x558(%rbp)
movq (%r15), %rax
movq %rax, 0x548(%rbp)
movq 0x8(%r15), %rax
movq %rax, 0x550(%rbp)
movl $0x80, %esi
movq %r14, %rdi
callq 0x18db6a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: write_ec_reads(char const*)
void write_ec_reads(const char *suffix_ou)
{
    uint64_t k, strl; UC_Read qstr, tstr; char *nn = NULL, *str = NULL;
    init_UC_Read(&qstr); init_UC_Read(&tstr);
    MALLOC(nn, strlen(suffix_ou) + strlen(asm_opt.output_file_name) + 36);
    sprintf(nn, "%s.%s", asm_opt.output_file_name, suffix_ou);
    FILE *ou = fopen(nn, "w");
    free(nn);

    for (k = 0; k < R_INF.total_reads; k++) {
        recover_UC_Read(&qstr, &R_INF, k);
        if(scb.a) {
            gen_ori_seq0(qstr.seq, qstr.length, &tstr, &(scb.a[k]), k); str = tstr.seq; strl = tstr.length;
        } else {
            str = qstr.seq; strl = qstr.length;
        }

        fwrite(">", 1, 1, ou);
        fwrite(Get_NAME(R_INF, k), 1, Get_NAME_LENGTH(R_INF, k), ou);
        fwrite("\n", 1, 1, ou);
        fwrite(str, 1, strl, ou);
        fwrite("\n", 1, 1, ou);
    }

    fclose(ou); destory_UC_Read(&qstr); destory_UC_Read(&tstr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x3372c
leaq 0x28(%rsp), %rdi
callq 0x3372c
movq %r15, %rdi
callq 0x2090
movq %rax, %r14
leaq 0xff001(%rip), %rax     # 0x28a758
movq 0x10(%rax), %r12
movq %r12, %rdi
callq 0x2090
leaq (%r14,%rax), %rdi
addq $0x24, %rdi
callq 0x2280
movq %rax, %r14
leaq 0xa16a8(%rip), %rsi     # 0x22ce22
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2050
leaq 0xb0c6d(%rip), %rsi     # 0x23c3fe
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
movq %r14, %rdi
callq 0x2220
leaq 0xffa85(%rip), %r12     # 0x28b230
cmpq $0x0, 0x50(%r12)
je 0x18b871
xorl %ebx, %ebx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x33cf8
movq 0xffd92(%rip), %rcx     # 0x28b568
testq %rcx, %rcx
je 0x18b7f8
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq %rbx, %rcx
leaq 0x28(%rsp), %r14
movq %r14, %rdx
movq %r13, %r8
callq 0x18810d
movq (%r14), %rbp
movq 0x8(%r14), %r14
movl $0x3e, %edi
movq %r15, %rsi
callq 0x2270
movq 0x40(%r12), %rax
movq (%rax,%r13,8), %rcx
movq 0x8(%rax,%r13,8), %rdx
movq 0x8(%r12), %rdi
addq %rcx, %rdi
incq %r13
subq %rcx, %rdx
movl $0x1, %esi
movq %r15, %rcx
callq 0x2410
movl $0xa, %edi
movq %r15, %rsi
callq 0x2270
movl $0x1, %esi
movq %rbp, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2410
movl $0xa, %edi
movq %r15, %rsi
callq 0x2270
addq $0x18, %rbx
cmpq 0x50(%r12), %r13
jb 0x18b7bc
movq %r15, %rdi
callq 0x2190
leaq 0x8(%rsp), %rdi
callq 0x33667
leaq 0x28(%rsp), %rdi
callq 0x33667
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: sl_ec_r(unsigned long, unsigned long)
void sl_ec_r(uint64_t n_thre, uint64_t n_a)
{
    sl_v *b = NULL; uint64_t k; MALLOC(b, n_thre);
    for (k = 0; k < n_thre; k++) {
        b[k].a = NULL; b[k].n = b[k].m = 0;
        init_UC_Read(&b[k].z); kv_init(b[k].q);
    }

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rdi, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rdi
callq 0x2280
movq %rax, %r14
testq %rbx, %rbx
je 0x18b8f8
xorl %r12d, %r12d
movq %r14, %r13
movq %rbx, %rbp
leaq 0x18(%r13), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq %r12, 0x10(%r13)
callq 0x3372c
movq %r12, 0x48(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r13)
addq $0x50, %r13
decq %rbp
jne 0x18b8ce
leaq 0x73b(%rip), %rsi       # 0x18c03a
movl %ebx, %edi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1047b4
testq %rbx, %rbx
je 0x18b93b
movq %r14, %r15
addq $0x48, %r15
movq -0x38(%r15), %rdi
callq 0x2220
leaq -0x30(%r15), %rdi
callq 0x33667
movq (%r15), %rdi
callq 0x2220
addq $0x50, %r15
decq %rbx
jne 0x18b918
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: print_ov_dbg_paf(_IO_FILE*, char*, char*, int, char*, char*, int, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, bit_extz_t*, char*)
void print_ov_dbg_paf(FILE *fp, char *ref_str, char *ref_id, int32_t ref_id_n, char *qry_str, char *qry_id, int32_t qry_id_n, uint64_t rs, uint64_t re, uint64_t rl, uint64_t qs, uint64_t qe, uint64_t ql, uint64_t rev, bit_extz_t *ez, char *ezh)
{
    uint64_t ci = 0; uint16_t c; uint32_t cl;
    fprintf(fp, "%.*s\t%lu\t%lu\t%lu\t", qry_id_n, qry_id, ql, qs, qe);
    fprintf(fp, "%c\t", "+-"[rev]);
    fprintf(fp, "%.*s\t%lu\t%lu\t%lu\t", ref_id_n, ref_id, rl, rs, re);
    fprintf(fp, "255\tcg:Z:");
    while (ci < ez->cigar.n) {
        ci = pop_trace(&(ez->cigar), ci, &c, &cl);
        fprintf(fp, "%u%c", cl, ezh[c]);
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rax
movl %ecx, 0x14(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, %rbx
movq 0xa8(%rsp), %r13
movq 0xa0(%rsp), %rbp
movq 0x78(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x68(%rsp), %r12
movq 0x70(%rsp), %r14
movq 0x98(%rsp), %r15
movl 0x60(%rsp), %edx
movq 0x90(%rsp), %r8
movq 0x80(%rsp), %r9
movq 0x88(%rsp), %rcx
movq %rcx, (%rsp)
leaq 0xa79b2(%rip), %rsi     # 0x23354e
movq %rax, %rcx
xorl %eax, %eax
callq 0x22b0
leaq 0x9a616(%rip), %rax     # 0x2261c3
movsbl (%r15,%rax), %edx
leaq 0xaff4d(%rip), %rsi     # 0x23bb06
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movq %r14, (%rsp)
movq %rbx, %rdi
leaq 0xa797d(%rip), %rsi     # 0x23354e
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq %r12, %r9
xorl %eax, %eax
callq 0x22b0
leaq 0xa7970(%rip), %rdi     # 0x233560
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
movq 0xa8(%rbp), %rax
testq %rax, %rax
je 0x18bc79
leaq 0x9a649(%rip), %r14     # 0x22625e
xorl %r15d, %r15d
movq 0xb8(%rbp), %rdi
movzwl (%rdi,%r15,2), %edx
movl %edx, %ecx
shrl $0xe, %ecx
andl $0x3fff, %edx           # imm = 0x3FFF
leal 0x1(%r15), %esi
cmpq %rsi, %rax
jbe 0x18bc57
movzwl (%rdi,%rsi,2), %r8d
movl %r8d, %r9d
shrl $0xe, %r9d
cmpl %ecx, %r9d
jne 0x18bc57
andl $0x3fff, %r8d           # imm = 0x3FFF
addl %r8d, %edx
incl %esi
jmp 0x18bc33
movl %esi, %r15d
movsbl (%r13,%rcx), %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x22b0
movq 0xa8(%rbp), %rax
cmpq %r15, %rax
ja 0x18bc18
movl $0xa, %edi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_ec_r_dbg(unsigned long, unsigned long)
void cal_ec_r_dbg(uint64_t n_thre, uint64_t n_a)
{
    char *paf = NULL; MALLOC(paf, (strlen(asm_opt.output_file_name)+64));
    sprintf(paf, "%s.ovlp.paf", asm_opt.output_file_name); 

    cal_ec_r_dbg_t sl; memset(&sl, 0, sizeof(sl));
    sl.n_thread = n_thre; sl.n_a = n_a; sl.chunk_size = 2000; sl.cn = 0; sl.fp = fopen(paf, "w");

    kt_pipeline(3, worker_ov_dbg_pipeline, &sl, 3);

    fclose(sl.fp); free(paf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xfeaac(%rip), %rax     # 0x28a758
movq 0x10(%rax), %r12
movq %r12, %rdi
callq 0x2090
leaq 0x40(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x99178(%rip), %rsi     # 0x224e43
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movl %r15d, (%r12)
movl %r14d, 0x4(%r12)
movq $0x7d0, 0x8(%r12)       # imm = 0x7D0
leaq 0xb06f9(%rip), %rsi     # 0x23c3fe
movq %rbx, %rdi
callq 0x2210
movq %rax, 0x10(%r12)
leaq 0x30(%rip), %rsi        # 0x18bd49
movl $0x3, %edi
movq %r12, %rdx
movl $0x3, %ecx
callq 0x104984
movq 0x10(%r12), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2220
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: destroy_cc_v(cc_v*)
void destroy_cc_v(cc_v *z)
{
    uint64_t k;
    for (k = 0; k < z->m; k++) free(z->a[k].a);
    free(z->f); free(z->a);
    z->n = z->m = 0; z->f = NULL; z->a = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x18bfd2
movl $0x10, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2220
incq %r15
addq $0x18, %r14
cmpq 0x8(%rbx), %r15
jb 0x18bfb8
movq 0x18(%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
callq 0x2220
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_ov_r(unsigned long, unsigned long, unsigned long)
void cal_ov_r(uint64_t n_thre, uint64_t n_a, uint64_t new_idx)
{
    ec_ovec_buf_t *b = NULL;
    b = gen_ec_ovec_buf_t(n_thre);
    if(new_idx) {
        // kt_for(n_thre, worker_hap_dc_ec, b, n_a);///update overlaps
        destroy_cc_v(&scc); destroy_cc_v(&scb); destroy_cc_v(&sca);
        
        ha_print_ovlp_stat_0(b, n_thre, n_a);
    } else {
        ha_print_ovlp_stat_1(b, n_thre, n_a);
        destroy_cc_v(&scc); destroy_cc_v(&scb); destroy_cc_v(&sca);
    }

    destroy_ec_ovec_buf_t(b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x179027
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
testq %r12, %r12
jne 0x18c022
callq 0x238ff
jmp 0x18c027
callq 0x238ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1793c1
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: worker_hap_dc_ec_chemical_r(void*, long, int)
static void worker_hap_dc_ec_chemical_r(void *data, long i, int tid)
{
    ec_ovec_buf_t0 *b = &(((ec_ovec_buf_t*)data)->a[tid]);
    ma_hit_t_alloc *paf = &(R_INF.paf[i]); uint64_t k, m;

    // if (memcmp("3ed80bc4-1169-4948-a9ff-9c2463b7f7a2", Get_NAME((R_INF), i), Get_NAME_LENGTH((R_INF),i)) == 0) {
    //     fprintf(stderr, "-a-[M::%s-beg] rid->%ld, b->rr->%lu\n", __func__, i, b->rr);
    // } 
    if(b->cnt[1] == 0) {
        // if(i == 6204620) prt_dbg_rid_paf(&(R_INF.paf[i]), &(b->self_read), &(b->v8q));
        // if(is_chemical_r(&(R_INF.paf[i]), &b->v64, Get_READ_LENGTH((R_INF), i), 3, 16)) {
        if(is_chemical_r_adv(&(R_INF.paf[i]), &b->v64, Get_READ_LENGTH((R_INF), i), asm_opt.chemical_cov, asm_opt.chemical_flank, 0.02, 0)) {
            // fprintf(stderr, "-um-[M::%s]\tqn::%u::%.*s\n\n", __func__, (uint32_t)(i), (int)Get_NAME_LENGTH(R_INF, i), Get_NAME((R_INF), i));
            R_INF.paf[i].length = 0; b->cnt[0]++;
        } 
    } else if(b->cnt[1] == 1) {
        for (k = 0; k < paf->length; k++) {
            if(R_INF.paf[paf->buffer[k].tn].length == 0) {
                paf->buffer[k].tn = (uint32_t)-1; b->cnt[0]++;
            }
        }
    } else {
        for (k = m = 0; k < paf->length; k++) {
            if(paf->buffer[k].tn == ((uint32_t)-1)) continue;
            paf->buffer[m++] = paf->buffer[k];
        }
        paf->length = m;
    }

   refresh_ec_ovec_buf_t0(b, REFRESH_N);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rcx
movslq %edx, %rax
imulq $0x5c0, %rax, %rdx      # imm = 0x5C0
leaq (%rcx,%rdx), %rbx
leaq 0xfeaa3(%rip), %r14     # 0x28b230
movq 0x78(%r14), %rax
leaq (%rsi,%rsi,2), %r15
leaq (%rax,%r15,8), %rdi
movq 0xc8(%rcx,%rdx), %rcx
testq %rcx, %rcx
je 0x18c7f5
cmpq $0x1, %rcx
jne 0x18c846
movl 0xc(%rdi), %edx
testq %rdx, %rdx
je 0x18c89a
movq (%rdi), %rcx
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
xorl %esi, %esi
movl 0xc(%rcx,%rsi), %edi
leaq (%rdi,%rdi,2), %rdi
cmpl $0x0, 0xc(%rax,%rdi,8)
jne 0x18c7e7
movl $0xffffffff, 0xc(%rcx,%rsi) # imm = 0xFFFFFFFF
incq 0xc0(%rbx)
addq $0x28, %rsi
cmpq %rsi, %rdx
jne 0x18c7c9
jmp 0x18c89a
leaq 0x4d0(%rbx), %rax
movq 0x18(%r14), %rcx
movq (%rcx,%rsi,8), %rdx
leaq 0xfdf4d(%rip), %rsi     # 0x28a758
movq 0x2b8(%rsi), %rcx
movq 0x2c0(%rsi), %r8
movsd 0x957f7(%rip), %xmm0    # 0x222018
movq %rax, %rsi
xorl %r9d, %r9d
callq 0x18323e
testl %eax, %eax
je 0x18c89a
movq 0x78(%r14), %rax
movl $0x0, 0xc(%rax,%r15,8)
incq 0xc0(%rbx)
jmp 0x18c89a
cmpl $0x0, 0xc(%rdi)
je 0x18c895
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
movq (%rdi), %rsi
cmpl $-0x1, 0xc(%rsi,%rcx)
je 0x18c884
leaq (%rsi,%rcx), %r8
leaq (%rax,%rax,4), %r9
incq %rax
movq 0x20(%r8), %r10
movq %r10, 0x20(%rsi,%r9,8)
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movups %xmm1, 0x10(%rsi,%r9,8)
movups %xmm0, (%rsi,%r9,8)
incq %rdx
movl 0xc(%rdi), %esi
addq $0x28, %rcx
cmpq %rsi, %rdx
jb 0x18c852
jmp 0x18c897
xorl %eax, %eax
movl %eax, 0xc(%rdi)
movl $0x80, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x18db6a
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: worker_hap_dc_ec_chemical_arc(void*, long, int)
static void worker_hap_dc_ec_chemical_arc(void *data, long i, int tid)
{
    ec_ovec_buf_t0 *b = &(((ec_ovec_buf_t*)data)->a[tid]);
    ma_hit_t_alloc *paf = &(R_INF.paf[i]), *rev; uint64_t k, z;

    if(b->cnt[1] == 0) {
        if(is_chemical_r_adv(&(R_INF.paf[i]), &b->v64, Get_READ_LENGTH((R_INF), i), asm_opt.chemical_cov, asm_opt.chemical_flank, 0.02, 1)) {
            // fprintf(stderr, "-um-[M::%s]\tqn::%u::%.*s\n\n", __func__, (uint32_t)(i), (int)Get_NAME_LENGTH(R_INF, i), Get_NAME((R_INF), i));   
            for (k = 0; k < paf->length; k++) paf->buffer[k].del = 1; b->cnt[0]++;
        }
    } else if(b->cnt[1] == 1) {
        for (k = 0; k < paf->length; k++) {
            if((Get_qn(paf->buffer[k])) > (Get_tn(paf->buffer[k]))) continue;
            rev = &(R_INF.paf[paf->buffer[k].tn]);
            for (z = 0; z < rev->length; z++) {
                if((rev->buffer[z].tn == (Get_qn(paf->buffer[k])))) {
                    if(paf->buffer[k].del != rev->buffer[z].del) {
                        paf->buffer[k].del = rev->buffer[z].del = 1;
                    }
                }
            }
        }
    }

   refresh_ec_ovec_buf_t0(b, REFRESH_N);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movslq %edx, %rcx
imulq $0x5c0, %rcx, %rdx      # imm = 0x5C0
leaq (%rax,%rdx), %rbx
leaq 0xfe965(%rip), %rcx     # 0x28b230
leaq (%rsi,%rsi,2), %r14
shlq $0x3, %r14
addq 0x78(%rcx), %r14
movq 0xc8(%rax,%rdx), %rax
testq %rax, %rax
je 0x18c989
cmpq $0x1, %rax
jne 0x18ca00
cmpl $0x0, 0xc(%r14)
je 0x18ca00
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorl %edx, %edx
movq (%r14), %r8
leaq (%rdx,%rdx,4), %rsi
movl 0xc(%r8,%rsi,8), %edi
cmpl 0x4(%r8,%rsi,8), %edi
jb 0x18c97b
movq 0x78(%rcx), %r8
leaq (%rdi,%rdi,2), %rdi
cmpl $0x0, 0xc(%r8,%rdi,8)
je 0x18c97b
leaq (%r8,%rdi,8), %rdi
movl $0x18, %r8d
xorl %r9d, %r9d
movq (%rdi), %r10
movl -0xc(%r10,%r8), %ebp
movq (%r14), %r11
cmpl 0x4(%r11,%rsi,8), %ebp
jne 0x18c96b
leaq (%r11,%rsi,8), %r15
movq (%r10,%r8), %r11
movq 0x18(%r15), %r15
xorq %r11, %r15
jns 0x18c96b
orq %rax, %r11
movq %r11, (%r10,%r8)
movq (%r14), %r10
orq %rax, 0x18(%r10,%rsi,8)
incq %r9
movl 0xc(%rdi), %r10d
addq $0x28, %r8
cmpq %r10, %r9
jb 0x18c939
incq %rdx
movl 0xc(%r14), %esi
cmpq %rsi, %rdx
jb 0x18c909
jmp 0x18ca00
leaq 0x4d0(%rbx), %rax
movq 0x18(%rcx), %rcx
movq (%rcx,%rsi,8), %rdx
leaq 0xfddb9(%rip), %rsi     # 0x28a758
movq 0x2b8(%rsi), %rcx
movq 0x2c0(%rsi), %r8
movsd 0x95663(%rip), %xmm0    # 0x222018
movl $0x1, %r9d
movq %r14, %rdi
movq %rax, %rsi
callq 0x18323e
testl %eax, %eax
je 0x18ca00
cmpl $0x0, 0xc(%r14)
je 0x18c9f9
movl $0x18, %eax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorl %edx, %edx
movq (%r14), %rsi
orq %rcx, (%rsi,%rax)
incq %rdx
movl 0xc(%r14), %esi
addq $0x28, %rax
cmpq %rsi, %rdx
jb 0x18c9e2
incq 0xc0(%rbx)
movl $0x80, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18db6a
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: gen_hc_polish(unsigned long, ma_ug_t*)
void gen_hc_polish(uint64_t n_thre, ma_ug_t *ug)
{
    ec_polish_buf_t b; memset(&b, 0, sizeof(b)); b.ug = ug;
    uint64_t k, z, zn;
    for (k = b.idx.n = 0; k < ug->u.n; k++) {
        b.idx.n += ug->u.a[k].n;
    }
    MALLOC(b.idx.a, b.idx.n);
    for (k = zn = 0; k < ug->u.n; k++) {
        for (z = 0; z < ug->u.a[k].n; z++, zn++) {
            b.idx.a[zn] = (k<<32)|z;
        }
    }
    b.p = gen_ec_ovec_buf_t(n_thre);

    kt_for(n_thre, worker_ec_polish, &b, b.idx.n);

    destroy_ec_ovec_buf_t(b.p); free(b.idx.a);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsi), %rax
testq %rax, %rax
je 0x18cbfe
movq 0x10(%r14), %rcx
addq $0x10, %rcx
xorl %edi, %edi
movl (%rcx), %edx
addq %rdx, %rdi
addq $0x28, %rcx
decq %rax
jne 0x18cbee
jmp 0x18cc00
xorl %edi, %edi
movq %rdi, 0x8(%rsp)
shlq $0x3, %rdi
callq 0x2280
movq %rax, 0x18(%rsp)
movq (%r14), %rcx
testq %rcx, %rcx
je 0x18cc5c
movq 0x10(%r14), %rdx
xorl %esi, %esi
xorl %edi, %edi
leaq (%rdi,%rdi,4), %r8
movl 0x10(%rdx,%r8,8), %r8d
testq %r8, %r8
je 0x18cc54
movq %rdi, %r9
shlq $0x20, %r9
leaq (%rax,%rsi,8), %r11
xorl %r10d, %r10d
movq %r10, %r14
orq %r9, %r14
movq %r14, (%r11,%r10,8)
incq %r10
cmpq %r10, %r8
jne 0x18cc3f
addq %r10, %rsi
incq %rdi
cmpq %rcx, %rdi
jne 0x18cc23
movl %ebx, %edi
callq 0x179027
movq %rsp, %r14
movq %rax, (%r14)
movq 0x8(%r14), %rcx
leaq 0x23(%rip), %rsi        # 0x18cc97
movl %ebx, %edi
movq %r14, %rdx
callq 0x1047b4
movq (%r14), %rdi
callq 0x1793c1
movq 0x18(%r14), %rdi
callq 0x2220
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/ecovlp.cpp
// Function: insert_cns_arc(cns_gfa*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
inline void insert_cns_arc(cns_gfa *cns, uint32_t src, uint32_t des, uint32_t is_ou, uint32_t plus0, uint32_t rid)
{
    if(src >= cns->n) {
        fprintf(stderr, "[M::%s] rid::%u, src::%u, des::%u, (*cns).n::%u\n", __func__, rid, src, des, (uint32_t)(*cns).n);
        exit(1);
    }
    cns_arc *p, t; kv_pushp(cns_arc, (*cns).a[src].arc, &p);
    p->f = 0; p->sc = plus0; p->v = des;
    if(is_ou) {
        (*cns).a[src].arc.nou++;
        if((*cns).a[src].arc.nou < (*cns).a[src].arc.n) {
            t = (*cns).a[src].arc.a[(*cns).a[src].arc.nou-1]; 
            (*cns).a[src].arc.a[(*cns).a[src].arc.nou-1] = *p;
            *p = t;
        }
    } 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %eax
movq (%rdi), %rcx
cmpq %rax, %rcx
jbe 0x18d230
movl %r8d, %r15d
movq %rdi, %r14
movq 0x10(%rdi), %rcx
leaq (%rax,%rax,4), %r12
movq 0x10(%rcx,%r12,8), %rdx
cmpq %rdx, 0x8(%rcx,%r12,8)
jne 0x18d1c2
leaq (%rcx,%r12,8), %rdi
addq $0x8, %rdi
leaq (%rdx,%rdx), %rsi
testq %rdx, %rdx
movl $0x2, %edx
cmovneq %rsi, %rdx
shlq $0x3, %rax
leaq (%rax,%rax,4), %r13
movq %rdx, 0x10(%rcx,%r13)
movq 0x8(%rdi), %rsi
movq 0x18(%rdi), %rdi
shlq $0x3, %rsi
callq 0x2370
movq 0x10(%r14), %rcx
movq %rax, 0x20(%rcx,%r13)
movq 0x10(%r14), %rdx
movq 0x8(%rdx,%r12,8), %rax
movq 0x20(%rdx,%r12,8), %rcx
leaq 0x1(%rax), %rsi
movq %rsi, 0x8(%rdx,%r12,8)
movl %r15d, 0x4(%rcx,%rax,8)
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movl %ebx, (%rcx,%rax,8)
testl %ebp, %ebp
je 0x18d221
movq 0x10(%r14), %rsi
movq 0x18(%rsi,%r12,8), %rdx
incq %rdx
movq %rdx, 0x18(%rsi,%r12,8)
cmpq 0x8(%rsi,%r12,8), %rdx
jae 0x18d221
leaq (%rsi,%r12,8), %rsi
addq $0x8, %rsi
movq 0x18(%rsi), %rsi
movq -0x8(%rsi,%rdx,8), %rdi
movq (%rcx,%rax,8), %r8
movq %r8, -0x8(%rsi,%rdx,8)
movq %rdi, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r8d
movq 0xfcda6(%rip), %rax     # 0x289fe0
movq (%rax), %rdi
movl %ecx, (%rsp)
leaq 0xa63a9(%rip), %rsi     # 0x2335f0
leaq 0xa63d3(%rip), %rdx     # 0x233621
movl %r9d, %ecx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x22b0
movl $0x1, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/./Levenshtein_distance.h
// Function: push_trace_bp(asg16_v*, unsigned short, unsigned short, unsigned int, unsigned int)
inline void push_trace_bp(asg16_v *res, uint16_t c, uint16_t b, uint32_t len, uint32_t is_append)
{
    uint16_t p, c0, b0, len0, mm; 
	if((is_append) && (res->n)) {
		b0 = b;
		pop_trac_bpc(res->a[res->n-1], c0, b0, len0);
		if((c == c0) && (b == b0)) {
			res->n--; len += len0;
		}
	}
	
	mm = (0x3fff); c0 = c; c <<= 14;
	if(c0 == 1 || c0 == 2) {
		mm = (0xfff); c += ((b&3) << 12);
	}

	
	while (len >= mm) {
		p = (c + mm); kv_push(uint16_t, *res, p); len -= mm;
	}
	// fprintf(stderr, "[M::%s] c::%u, len::%u\n", __func__, c, len);
	if(len) {
		p = (c + len); kv_push(uint16_t, *res, p);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
testl %r8d, %r8d
je 0x18d8f8
movq (%rbx), %rax
testq %rax, %rax
je 0x18d8f8
movq 0x10(%rbx), %rcx
movzwl -0x2(%rcx,%rax,2), %ecx
movl %ecx, %r10d
shrl $0xe, %r10d
movl %r10d, %edi
addl $-0x3, %edi
cmpw $-0x2, %di
setb %r8b
movl %ecx, %r9d
shrl $0xc, %r9d
andl $0x3, %r9d
cmpw %dx, %r9w
sete %r9b
cmpw %si, %r10w
jne 0x18d8f8
orb %r9b, %r8b
je 0x18d8f8
cmpw $-0x2, %di
movl $0x3fff, %edi           # imm = 0x3FFF
movl $0xfff, %r8d            # imm = 0xFFF
cmovbl %edi, %r8d
andl %r8d, %ecx
decq %rax
movq %rax, (%rbx)
addl %ecx, %ebp
movl %esi, %eax
shll $0xe, %eax
decl %esi
andl $0x3, %edx
shll $0xc, %edx
xorl %r14d, %r14d
cmpw $0x2, %si
cmovbl %edx, %r14d
movl $0xfff, %ecx            # imm = 0xFFF
movl $0x3fff, %r15d          # imm = 0x3FFF
cmovbl %ecx, %r15d
orl %eax, %r14d
cmpl %r15d, %ebp
jb 0x18d974
leal (%r14,%r15), %r12d
movl $0x2, %r13d
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jne 0x18d959
leaq (%rax,%rax), %rsi
testq %rax, %rax
cmoveq %r13, %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq %rsi, %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movw %r12w, (%rcx,%rax,2)
subl %r15d, %ebp
cmpl %r15d, %ebp
jae 0x18d931
testl %ebp, %ebp
je 0x18d9bb
addl %ebp, %r14d
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
jne 0x18d9a8
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x2, %esi
cmovneq %rcx, %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
addq %rsi, %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movw %r14w, (%rcx,%rax,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/tovlp.cpp
// Function: init_clean_mul_t(asg_t*, ma_ug_t*, unsigned long, unsigned char, unsigned char)
clean_mul_t *init_clean_mul_t(asg_t *g, ma_ug_t *ug, uint64_t n_threads, uint8_t fp, uint8_t fa)
{
    uint32_t i;
    clean_t *kt = NULL;
    clean_mul_t *p = NULL; CALLOC(p, 1);
    p->g = g; p->ug = ug;
    CALLOC(p->bs_flag, p->g->n_seq<<1);
    p->n = p->m = n_threads;
    CALLOC(p->a, p->n);
    for (i = 0, kt = NULL; i < p->n; i++)
    {
        kt = &(p->a[i]);
        kv_init(kt->tt.a); kv_init(kt->stack.a);
        CALLOC(kt->vis, p->g->n_seq<<1);
        init_pdq(&kt->pq_p, p->g->n_seq<<1);
        init_pdq(&kt->pq_a, p->g->n_seq<<1);
        memset(&kt->b, 0, sizeof(kt->b));
        kt->b.a = (binfo_t*)calloc(p->g->n_seq<<1, sizeof(binfo_t));
    }
    p->max_dist = get_bub_pop_max_dist_advance(g, &kt->b);
    p->fp = fp; p->fa = fa;
    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, (%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movl $0x1, %edi
movl $0x40, %esi
callq 0x2120
movq %rax, %rbx
movq %r14, 0x30(%rax)
movq %r13, 0x38(%rax)
movl 0x14(%r14), %eax
addl %eax, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2120
movq %rax, 0x20(%rbx)
movq %r15, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movl $0x1a0, %esi            # imm = 0x1A0
movq %r15, 0x10(%rsp)
movq %r15, %rdi
callq 0x2120
movq %rax, %r13
movq %rbx, 0x8(%rsp)
movq %rax, (%rbx)
movl $0x1, %ebp
xorl %r15d, %r15d
xorl %eax, %eax
imulq $0x1a0, %rax, %r12      # imm = 0x1A0
movq %r15, 0x10(%r13,%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r13,%r12)
movups %xmm0, 0x20(%r13,%r12)
movq %r15, 0x30(%r13,%r12)
movl 0x14(%r14), %eax
addl %eax, %eax
movslq %eax, %rbx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2120
movq %rax, 0x40(%r13,%r12)
leaq (%r12,%r13), %rdi
addq $0x48, %rdi
movq %rbx, %rsi
callq 0x13bb82
leaq (%r12,%r13), %rdi
addq $0xb0, %rdi
movl 0x14(%r14), %eax
addl %eax, %eax
movslq %eax, %rsi
callq 0x13bb82
movq %r15, 0x178(%r13,%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x168(%r13,%r12)
movups %xmm0, 0x158(%r13,%r12)
movups %xmm0, 0x148(%r13,%r12)
movups %xmm0, 0x138(%r13,%r12)
movups %xmm0, 0x128(%r13,%r12)
movups %xmm0, 0x118(%r13,%r12)
movl 0x14(%r14), %eax
addl %eax, %eax
movslq %eax, %rdi
movl $0x1c, %esi
callq 0x2120
movq %rax, 0x118(%r13,%r12)
movl %ebp, %eax
incl %ebp
cmpq 0x10(%rsp), %rax
jb 0x18e02f
addq %r12, %r13
addq $0x118, %r13            # imm = 0x118
movq %r14, %rdi
movq %r13, %rsi
callq 0xbf22d
movq 0x8(%rsp), %rcx
movq %rax, 0x18(%rcx)
movl (%rsp), %eax
movb %al, 0x28(%rcx)
movl 0x4(%rsp), %eax
movb %al, 0x29(%rcx)
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/tovlp.cpp
// Function: destroy_clean_mul_t(clean_mul_t**)
void destroy_clean_mul_t(clean_mul_t **p)
{
    uint32_t i;
    clean_t *kt = NULL;
    free((*p)->bs_flag);
    for (i = 0; i < (*p)->n; i++)
    {
        kt = &((*p)->a[i]);
        kv_destroy(kt->tt.a);
        kv_destroy(kt->stack.a);
        free(kt->vis);
        destory_pdq(&kt->pq_p);
        destory_pdq(&kt->pq_a);
        free(kt->b.a); free(kt->b.S.a); free(kt->b.T.a); free(kt->b.b.a); free(kt->b.e.a);
    }
    free((*p)->a);
    free((*p));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rdi
callq 0x2220
movq (%rbx), %rax
cmpq $0x0, 0x8(%rax)
je 0x18e1f9
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax), %r15
imulq $0x1a0, %rcx, %r12      # imm = 0x1A0
leaq (%r15,%r12), %r14
addq $0x48, %r14
movq -0x38(%r14), %rdi
callq 0x2220
movq -0x18(%r14), %rdi
callq 0x2220
movq -0x8(%r14), %rdi
callq 0x2220
movq %r14, %rdi
callq 0x13bc20
leaq (%r15,%r12), %r14
addq $0xb0, %r14
movq %r14, %rdi
callq 0x13bc20
movq 0x68(%r14), %rdi
callq 0x2220
movq 0x80(%r14), %rdi
callq 0x2220
movq 0x98(%r14), %rdi
callq 0x2220
movq 0xb0(%r14), %rdi
callq 0x2220
movq 0xc8(%r14), %rdi
callq 0x2220
movl %ebp, %ecx
movq (%rbx), %rax
incl %ebp
cmpq %rcx, 0x8(%rax)
ja 0x18e167
movq (%rax), %rdi
callq 0x2220
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/tovlp.cpp
// Function: init_utg_trans_t(ma_ug_t*, ma_hit_t_alloc*, ma_sub_t*, R_to_U*, asg_t*, int, int)
utg_trans_t *init_utg_trans_t(ma_ug_t *ug, ma_hit_t_alloc* reverse_sources, ma_sub_t *coverage_cut, R_to_U* ruIndex, asg_t *read_g, int max_hang, int min_ovlp)
{
    utg_trans_t *o = NULL; 
    CALLOC(o, 1);
    o->reverse_sources = reverse_sources;
    o->coverage_cut = coverage_cut;
    o->ruIndex = ruIndex;
    o->read_g = read_g;
    o->rn = read_g->n_seq;
    memset(&(o->b0), 0, sizeof(o->b0));
    memset(&(o->b1), 0, sizeof(o->b1));
    MALLOC(o->pos_idx, o->rn); memset(o->pos_idx, -1, o->rn*sizeof(uint64_t));
    o->cug = copy_untig_graph(ug);
    o->max_hang = max_hang;
    o->min_ovlp = min_ovlp;
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x230, %esi            # imm = 0x230
callq 0x2120
movq %rax, %r15
movq %rbx, (%rax)
movq %rbp, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r12, 0x18(%rax)
movl 0x14(%r12), %ebx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %rbx, 0xe8(%rax)
leaq 0x160(%rax), %r12
shlq $0x3, %rbx
movq %rbx, %rdi
callq 0x2280
movq %rax, %r13
movl $0xd0, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x20e0
movq %r13, 0xe0(%r15)
movq %r13, %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x20e0
movq %r14, %rdi
callq 0xc815c
movq %rax, 0x108(%r15)
movl 0x4(%rsp), %eax
movl %eax, 0x110(%r15)
movl 0x40(%rsp), %eax
movl %eax, 0x114(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/tovlp.cpp
// Function: get_utg_chain_length(ma_ug_t*, unsigned int*, unsigned int)
uint64_t get_utg_chain_length(ma_ug_t *ug, uint32_t *a, uint32_t a_n)
{
    uint64_t i, k, l, qn, v, w, nv, offset;
    asg_arc_t *av  = NULL;
    for (i = 0, offset = 0; i < a_n; i++)
    {
        qn = a[i]>>1;
        l = ug->g->seq[qn].len;
        if(i + 1 < a_n)
        {
            v = a[i]; w = a[i+1];
            av = asg_arc_a(ug->g, v);
            nv = asg_arc_n(ug->g, v);
            for (k = 0; k < nv; k++)
            {
                if(av[k].del) continue;
                if(av[k].v == w) 
                {
                    l = asg_arc_len(av[k]);
                    break;
                }
            }
            if(k >= nv) fprintf(stderr, "ERROR-mc\n");
        }
        offset += l;
    }
    return offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
je 0x18e39f
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
xorl %r15d, %r15d
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movl (%rbx,%rbp,4), %eax
movl %eax, %ecx
shrl %ecx
movq 0x18(%r14), %rsi
movq 0x20(%rsi), %rdx
movl (%rdx,%rcx,8), %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
incq %rbp
cmpq %r12, %rbp
jae 0x18e384
movq 0x28(%rsi), %rcx
movq (%rcx,%rax,8), %rdi
movq %rdi, %rcx
andq %r10, %rcx
setne %al
je 0x18e380
movl (%rbx,%rbp,4), %edx
movq 0x8(%rsi), %r8
shrq $0x20, %rdi
movq %rcx, %rsi
negq %rsi
leaq (%rdi,%rdi,2), %rdi
leaq (%r8,%rdi,8), %rdi
addq $0xc, %rdi
movl $0x1, %r8d
cmpl $0x0, (%rdi)
js 0x18e360
cmpl %edx, -0x4(%rdi)
je 0x18e37c
cmpq %rcx, %r8
setb %al
leaq (%rsi,%r8), %r9
incq %r9
incq %r8
addq $0x18, %rdi
cmpq $0x1, %r9
jne 0x18e356
jmp 0x18e380
movl -0xc(%rdi), %r13d
testb $0x1, %al
je 0x18e392
addq %r13, %r15
cmpq %r12, %rbp
jne 0x18e2fe
jmp 0x18e3a2
callq 0x244d3
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
jmp 0x18e384
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/tovlp.cpp
// Function: collect_trans_ovlp(char const*, buf_t*, unsigned long, buf_t*, unsigned long, ma_ug_t*, utg_trans_t*)
void collect_trans_ovlp(const char* cmd, buf_t* pri, uint64_t pri_offset, buf_t* aux, uint64_t aux_offset,
ma_ug_t *ug, utg_trans_t *o)
{
    uint32_t thre_pri;
    uint64_t len_aux;
    if(pri->b.n == 0 || aux->b.n == 0) return;

    len_aux = set_utg_offset(aux->b.a, aux->b.n, ug, o->read_g, o->pos_idx, 0, 0);
    chain_trans_ovlp(NULL, o, ug, o->read_g, pri, len_aux, &thre_pri);

    
    if(thre_pri > 0)
    {
        chain_trans_d(o, pri->b.a, pri->b.n, pri_offset, NULL, aux->b.a, aux->b.n, aux_offset, &len_aux, 
        ug, RC_1, -1024, __func__);
        // fprintf(stderr, "\n%s, thre_pri: %u, len_aux: %lu\n", cmd, thre_pri, len_aux);
        // print_buf_t(ug, pri, "pri");
        // print_buf_t(ug, aux, "aux");
    }
    set_utg_offset(aux->b.a, aux->b.n, ug, o->read_g, o->pos_idx, 1, 0);
}

// Assembly:
cmpq $0x0, 0x38(%rsi)
je 0x1903fc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %rbp
movq 0x38(%rcx), %rsi
testq %rsi, %rsi
je 0x1903ee
movq %r9, %rbx
movq %rdx, %r13
movq %r8, (%rsp)
movq 0x50(%rsp), %r12
movq 0x48(%r14), %rdi
movq 0x18(%r12), %rcx
movq 0xe0(%r12), %r8
subq $0x8, %rsp
movq %r9, %rdx
xorl %r9d, %r9d
pushq $0x0
callq 0xbb724
addq $0x10, %rsp
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
movq 0x18(%r12), %rcx
subq $0x8, %rsp
leaq 0x1c(%rsp), %r15
xorl %edi, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %rbp, %r8
movl %eax, %r9d
pushq %r15
callq 0x108416
addq $0x10, %rsp
cmpl $0x0, (%r15)
je 0x1903c1
movq 0x48(%rbp), %rsi
movl 0x38(%rbp), %edx
movq 0x48(%r14), %r9
movl 0x38(%r14), %eax
subq $0x8, %rsp
leaq 0x10(%rsp), %r10
movsd 0x997bb(%rip), %xmm0    # 0x229b60
movq %r12, %rdi
movl %r13d, %ecx
xorl %r8d, %r8d
pushq $0x1
pushq %rbx
pushq %r10
pushq 0x20(%rsp)
pushq %rax
callq 0x18ea75
addq $0x30, %rsp
movq 0x48(%r14), %rdi
movl 0x38(%r14), %esi
movq 0x18(%r12), %rcx
movq 0xe0(%r12), %r8
subq $0x8, %rsp
movq %rbx, %rdx
movl $0x1, %r9d
pushq $0x0
callq 0xbb724
addq $0x10, %rsp
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq