LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x28, %rax, %rdx
xorl %esi, %esi
xorl %ecx, %ecx
cmpq %rsi, %rdx
je 0x146552
movq (%r15), %rdi
cmpb $0x1, 0x20(%rdi,%rsi)
adcl $0x0, %ecx
addq $0x28, %rsi
jmp 0x14653c
addl 0xc(%r14), %ecx
cmpq %rcx, 0x8(%rbx)
jae 0x1465b1
decq %rcx
movq %rcx, %rax
shrq %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2370
movq %rax, 0x10(%rbx)
movl 0xc(%r15), %eax
andq $0x0, (%rbx)
imulq $0x28, %rax, %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x1465fc
movq (%r15), %rsi
cmpb $0x0, 0x20(%rsi,%rdx)
jne 0x1465f6
movl 0xc(%rsi,%rdx), %edi
movq 0x10(%rbx), %r8
movq %rdi, (%r8,%rax,8)
movq (%rbx), %rax
shlq (%r8,%rax,8)
movl 0x18(%rsi,%rdx), %eax
shrl $0x1f, %eax
movq (%rbx), %rsi
orq %rax, (%r8,%rsi,8)
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x28, %rdx
jmp 0x1465bd
movl 0xc(%r14), %ecx
imulq $0x28, %rcx, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x14663e
movq (%r14), %rsi
movl 0xc(%rsi,%rdx), %edi
movq 0x10(%rbx), %r8
movq %rdi, (%r8,%rax,8)
movq (%rbx), %rax
shlq (%r8,%rax,8)
movl 0x18(%rsi,%rdx), %eax
shrl $0x1f, %eax
movq (%rbx), %rsi
orq %rax, (%r8,%rsi,8)
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x28, %rdx
jmp 0x146606
movq 0x10(%rbx), %rdi
leaq (%rdi,%rax,8), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13d044
// File: /workspace/github_cpp_makefile_star2_O2/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 %r8, %rbx
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
xorl %eax, %eax
leaq 0x20(%rsp), %rbp
movq %rdi, 0x8(%rsp)
cmpq 0x10(%rsp), %rax
je 0x14676d
movq %rax, 0x18(%rsp)
imulq $0xa8, %rax, %r12
cmpl $0x0, 0x1c(%r14,%r12)
movl 0x10(%r14,%r12), %edx
movq %rbx, %rdi
je 0x1466b1
movq (%rsp), %rsi
callq 0x7215
jmp 0x1466ba
movq (%rsp), %rsi
callq 0x715e
addq %r14, %r12
pushq $0x1c
popq %r13
xorl %r14d, %r14d
cmpq 0x48(%r12), %r14
jae 0x14675b
movq 0x58(%r12), %rcx
movswl -0x8(%rcx,%r13), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x1466f6
movl (%rcx,%r13), %edx
testl %edx, %edx
jne 0x1466fa
xorl %edx, %edx
cmpw $0x0, -0xa(%rcx,%r13)
jns 0x1466fa
jmp 0x14674f
movl (%rcx,%r13), %edx
movl -0x4(%rcx,%r13), %esi
addq %rsi, %rsi
addq 0x70(%r12), %rsi
movq %rsi, 0xd8(%rsp)
movl %edx, %edx
movq %rdx, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq -0x1c(%rcx,%r13), %rdx
movq %rdx, 0x3c(%rsp)
movq -0x14(%rcx,%r13), %rcx
movq %rcx, 0x30(%rsp)
movl %eax, 0x4c(%rsp)
movl %eax, 0x48(%rsp)
movq (%rbx), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x626e8
testl %eax, %eax
je 0x14677f
incq %r14
addq $0x20, %r13
jmp 0x1466c4
movq 0x18(%rsp), %rax
incq %rax
movq 0x8(%rsp), %r14
jmp 0x14667f
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10c85a(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
movl 0x10(%r12), %r8d
movl (%r12), %ecx
movl 0x4(%r12), %r9d
movl 0x8(%r12), %r10d
incl %r10d
movl 0x14(%r12), %r11d
movl 0x18(%r12), %ebx
incl %ebx
subq $0x8, %rsp
leaq 0xaa056(%rip), %rsi     # 0x1f080c
leaq 0xaa089(%rip), %rdx     # 0x1f0846
xorl %eax, %eax
pushq %rbx
pushq %r11
pushq %r10
callq 0x22b0
addq $0x20, %rsp
pushq $0x1
popq %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x14(%rsp), %rbp
leaq 0x10(%rsp), %rbx
xorl %esi, %esi
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq (%r15), %rsi
jae 0x14ae9c
movq %r15, %rdi
leaq 0xe(%rsp), %rdx
leaq 0x16(%rsp), %rcx
movq %rbp, %r8
movq %rbx, %r9
callq 0xeeaa9
movl %eax, %esi
movzwl 0xe(%rsp), %eax
cmpw $0x2, %ax
movl 0x10(%rsp), %ecx
movq %rcx, %rdx
cmoveq %r14, %rdx
addq %rdx, %r12
cmpw $0x3, %ax
cmoveq %r14, %rcx
addq %rcx, %r13
jmp 0x14ae59
movq 0x18(%rsp), %rax
movq %r12, (%rax)
movq 0x20(%rsp), %rax
movq %r13, (%rax)
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/ecovlp.cpp
// Function: cal_ec_multiple(ec_ovec_buf_t*, unsigned long, unsigned long, unsigned long*)
uint64_t cal_ec_multiple(ec_ovec_buf_t *b, uint64_t n_thre, uint64_t n_a, uint64_t *r_base)
{
    double tt0 = yak_realtime_0();
    uint64_t k, num_base = 0, num_correct = 0; (*r_base) = 0;

    if(!(scc.a)) {
        scc.n = scc.m = n_a; CALLOC(scc.a, n_a); CALLOC(scc.f, n_a);
    }

    if(!(scb.a)) {
        scb.n = scb.m = n_a; CALLOC(scb.a, n_a);
    }

    for (k = 0; k < n_thre; ++k) b->a[k].cnt[0] = b->a[k].cnt[1] = 0;

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

    for (k = 0; k < n_thre; ++k) {
        num_base += b->a[k].cnt[0];
        num_correct += b->a[k].cnt[1];
    }

    // fprintf(stderr, "\n[M::%s] # reads->%lu\n", __func__, n_a);
    // fprintf(stderr, "[M::%s] # input bases->%lu\n", __func__, num_base);
    // fprintf(stderr, "[M::%s] # corrected bases->%lu\n", __func__, num_correct);
    // fprintf(stderr, "[M::%s::%.3f] running time\n", __func__, yak_realtime_0()-tt0);
    fprintf(stderr, "[M::pec::%.3f] # bases: %lu; # corrected bases: %lu\n", yak_realtime_0()-tt0, num_base, num_correct);

    (*r_base) = num_base;
    return num_correct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0xefeb7
andq $0x0, (%rbx)
movsd %xmm0, 0x8(%rsp)
cmpq $0x0, 0x1088b1(%rip)    # 0x254548
jne 0x14bccb
movq %r12, 0x1088a0(%rip)    # 0x254540
movq %r12, 0x108891(%rip)    # 0x254538
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x10888f(%rip)    # 0x254548
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x108885(%rip)    # 0x254550
cmpq $0x0, 0x108895(%rip)    # 0x254568
jne 0x14bcf5
movq %r12, 0x108884(%rip)    # 0x254560
movq %r12, 0x108875(%rip)    # 0x254558
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x2120
movq %rax, 0x108873(%rip)    # 0x254568
movl $0xc0, %eax
xorpd %xmm0, %xmm0
movq %r14, %rcx
subq $0x1, %rcx
jb 0x14bd17
movq (%r15), %rdx
movupd %xmm0, (%rdx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14bd01
leaq 0x73(%rip), %rsi        # 0x14bd91
movl %r14d, %edi
movq %r15, %rdx
movq %r12, %rcx
callq 0xc67c0
movl $0xc8, %eax
xorl %r12d, %r12d
xorl %r13d, %r13d
subq $0x1, %r14
jb 0x14bd51
movq (%r15), %rcx
addq -0x8(%rcx,%rax), %r12
addq (%rcx,%rax), %r13
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14bd37
movq 0x107288(%rip), %rax    # 0x252fe0
movq (%rax), %r14
callq 0xefeb7
subsd 0x8(%rsp), %xmm0
leaq 0xa56cb(%rip), %rsi     # 0x1f1438
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movb $0x1, %al
callq 0x22b0
movq %r12, (%rbx)
movq %r13, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_update_ec_multiple(ec_ovec_buf_t*, unsigned long, unsigned long)
void cal_update_ec_multiple(ec_ovec_buf_t *b, uint64_t n_thre, uint64_t n_a)
{
    double tt0 = yak_realtime_0();
    uint64_t k, num_ec_o = 0, num_nec_o = 0; 

    for (k = 0; k < n_thre; ++k) b->a[k].cnt[0] = b->a[k].cnt[1] = 0;

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

    for (k = 0; k < n_thre; ++k) {
        num_ec_o += b->a[k].cnt[0]; num_nec_o += b->a[k].cnt[1];
    }

    fprintf(stderr, "[M::pec::%.3f] # exact o: %lu; # non-exact o: %lu\n", yak_realtime_0()-tt0, num_ec_o, num_nec_o);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0xc0, %r12d
callq 0xefeb7
movsd %xmm0, (%rsp)
xorpd %xmm0, %xmm0
movq %rbx, %rax
subq $0x1, %rax
jb 0x14c295
movq (%r14), %rcx
movupd %xmm0, (%rcx,%r12)
addq $0x5c0, %r12            # imm = 0x5C0
jmp 0x14c27d
leaq 0x68(%rip), %rsi        # 0x14c304
movl %ebx, %edi
movq %r14, %rdx
movq %r15, %rcx
callq 0xc67c0
movl $0xc8, %eax
xorl %r15d, %r15d
xorl %r12d, %r12d
subq $0x1, %rbx
jb 0x14c2ce
movq (%r14), %rcx
addq -0x8(%rcx,%rax), %r15
addq (%rcx,%rax), %r12
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14c2b4
movq 0x106d0b(%rip), %rax    # 0x252fe0
movq (%rax), %rbx
callq 0xefeb7
subsd (%rsp), %xmm0
leaq 0xa5184(%rip), %rsi     # 0x1f146d
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x107f17(%rip), %rcx    # 0x254230
movq 0x78(%rcx), %rcx
imulq $0x18, %rsi, %r13
cmpl $0x0, 0xc(%rcx,%r13)
je 0x14c3f6
movq %rsi, %rax
movslq %edx, %rcx
imulq $0x5c0, %rcx, %r14      # imm = 0x5C0
addq (%rdi), %r14
movq %r14, %rdi
leaq 0x107ee9(%rip), %rsi    # 0x254230
movq %rax, %rdx
callq 0x715e
leaq 0x107eda(%rip), %rsi    # 0x254230
leaq 0x20(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0xc0(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0xc8(%r14), %rbp
movq 0x78(%rsi), %rcx
xorl %r12d, %r12d
xorl %ebx, %ebx
movl 0xc(%rcx,%r13), %eax
cmpq %rax, %rbx
jae 0x14c3db
leaq (%rcx,%r13), %rax
movq (%rax), %r15
cmpb $0x0, 0x20(%r15,%r12)
je 0x14c3c5
leaq (%r15,%r12), %rdi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
leaq 0x108191(%rip), %r8     # 0x254538
callq 0x14503a
movq %rbp, %rdx
testl %eax, %eax
je 0x14c3b8
movq 0x8(%rsp), %rdx
leaq 0x107e71(%rip), %rsi    # 0x254230
movq 0x78(%rsi), %rcx
jmp 0x14c3ca
xorl %eax, %eax
movq %rbp, %rdx
movb %al, 0x20(%r15,%r12)
incq (%rdx)
incq %rbx
addq $0x28, %r12
jmp 0x14c37b
movl $0x80, %esi
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14f9cd
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/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 (%rdi), %rbp
movq 0x107801(%rip), %rax    # 0x254550
movb $0x0, (%rax,%rsi)
leaq 0x1074d6(%rip), %r12    # 0x254230
movq 0x78(%r12), %rax
imulq $0x18, %rsi, %r13
cmpl $0x0, 0xc(%rax,%r13)
je 0x14ce30
movq %rsi, %rbx
movslq %edx, %rax
imulq $0x5c0, %rax, %r15      # imm = 0x5C0
leaq (%r15,%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x715e
leaq (%r15,%rbp), %rdi
addq $0x4d0, %rdi            # imm = 0x4D0
movq 0xa8(%rdi), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups 0x98(%rdi), %xmm0
movaps %xmm0, (%rcx)
movq %rcx, %rsi
addq 0x78(%r12), %r13
addq %r15, %rbp
addq $0x20, %rbp
subq $0x8, %rsp
leaq 0x10776d(%rip), %rax    # 0x254538
pushq $0x4
popq %r9
movsd 0x96719(%rip), %xmm0    # 0x1e34f0
movl $0x200, %r8d            # imm = 0x200
movq %rcx, %r15
movq %r13, %rdx
movq %r12, %rcx
pushq %rax
pushq %rbp
pushq %r14
callq 0x1452a1
addq $0x20, %rsp
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
movq 0x10774e(%rip), %rdx    # 0x254550
movb %al, (%rdx,%rbx)
incq 0xc0(%r14,%rcx,8)
movq 0x10(%r15), %rax
movq %rax, 0x558(%rbp)
movaps (%r15), %xmm0
movups %xmm0, 0x548(%rbp)
movl $0x80, %esi
movq %r14, %rdi
callq 0x14f9cd
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/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 $0x58, %rsp
movq %rdi, %r12
leaq 0x18(%rsp), %rdi
callq 0x6bd1
leaq 0x38(%rsp), %rdi
callq 0x6bd1
movq %r12, %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x10617f(%rip), %rax    # 0x253758
movq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x2090
leaq (%rbx,%rax), %rdi
addq $0x24, %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x9d916(%rip), %rsi     # 0x1eaf12
xorl %r14d, %r14d
movq %rax, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2050
leaq 0xad08b(%rip), %rsi     # 0x1fa6a1
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq %rbx, %rdi
callq 0x2220
leaq 0x106c00(%rip), %r12    # 0x254230
xorl %ebp, %ebp
pushq $0xa
popq %r13
cmpq 0x50(%r12), %rbp
jae 0x14d704
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x715e
movq 0x106f0d(%rip), %rcx    # 0x254568
testq %rcx, %rcx
je 0x14d67d
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq %r14, %rcx
leaq 0x38(%rsp), %rbx
movq %rbx, %rdx
movq %rbp, %r8
callq 0x14a720
movq (%rbx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
pushq $0x3e
popq %rdi
movq %r15, %rsi
callq 0x2270
movq 0x40(%r12), %rax
movq (%rax,%rbp,8), %rcx
movq 0x8(%rax,%rbp,8), %rdx
movq 0x8(%r12), %rdi
addq %rcx, %rdi
incq %rbp
subq %rcx, %rdx
movq %r14, %rbx
movq %r12, %r14
pushq $0x1
popq %r12
movq %r12, %rsi
movq %r15, %rcx
callq 0x2410
movl %r13d, %edi
movq %r15, %rsi
callq 0x2270
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %r12
movq %rbx, %r14
movq 0x10(%rsp), %rdx
movq %r15, %rcx
callq 0x2410
movl %r13d, %edi
movq %r15, %rsi
callq 0x2270
addq $0x18, %r14
jmp 0x14d636
movq %r15, %rdi
callq 0x2190
leaq 0x18(%rsp), %rdi
callq 0x6b07
leaq 0x38(%rsp), %rdi
callq 0x6b07
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_ec_r(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*)
void cal_ec_r(uint64_t n_thre, uint64_t round, uint64_t n_round, uint64_t n_a, uint64_t is_sv, uint64_t *tot_b, uint64_t *tot_e)
{
    // write_ec_reads("ec0.fa");

    // fprintf(stderr, "[M::%s]\tn_thre::%lu, round::%lu, n_round::%lu, n_a::%lu, is_sv::%lu\n", __func__, n_thre, round, n_round, n_a, is_sv);

    ec_ovec_buf_t *b = NULL; uint64_t k, is_cr = (round&1);
    (*tot_b) = (*tot_e) = 0;


    b = gen_ec_ovec_buf_t(n_thre);
    (*tot_e) += cal_ec_multiple(b, n_thre, n_a, tot_b); ///exit(1);
    sl_ec_r(n_thre, n_a);

    for (k = 0; k < n_round; k++) {
        (*tot_e) += cal_sec_ec_multiple(b, n_thre, n_a, k);
        sl_ec_r(n_thre, n_a);
    }

    cal_update_ec_multiple(b, n_thre, n_a);///update overlaps

    // if(is_sv) kt_for(n_thre, worker_hap_dc_ec, b, n_a);///update overlaps
    

    if((!is_sv) || (is_sv && is_cr)) {
        kt_for(n_thre, worker_hap_post_rev, b, n_a);
    }

    // cal_sec_ec_multiple(b, n_thre, n_a, -1);

    // gen_sec_ec_multiple(b, n_thre, n_a);

    destroy_ec_ovec_buf_t(b);

    // write_ec_reads("ec16.fa");

    // uint64_t z;
    // for (z = 0; z < scc.n; z++) {
    //     if(scc.f[z]) continue;
    //     fprintf(stderr, "[M::%s]\tid::%lu::%.*s\n", __func__, z, (int)Get_NAME_LENGTH(R_INF, z), Get_NAME((R_INF), z));
    // }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, 0x10(%rsp)
movq 0x50(%rsp), %r13
andq $0x0, (%r13)
movq %rdi, %r15
andq $0x0, (%r9)
callq 0x13d062
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x14bc67
addq %rax, (%r13)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14d7fb
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
cmpq %r12, %rbp
je 0x14d7b6
movq %r12, %rcx
callq 0x14cb91
addq %rax, (%r13)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14d7fb
incq %r12
jmp 0x14d78c
callq 0x14c255
cmpq $0x0, 0x8(%rsp)
setne %al
testb $0x1, 0x10(%rsp)
sete %cl
testb %al, %cl
jne 0x14d7e5
leaq 0xca(%rip), %rsi        # 0x14d8a1
movl %r15d, %edi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc67c0
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13d1f3
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
imulq $0x50, %rdi, %rdi
callq 0x2280
movq %rax, %r14
movq %rax, %r12
movq %rbx, %r13
subq $0x1, %r13
jb 0x14d84f
leaq 0x18(%r12), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
andq $0x0, 0x10(%r12)
callq 0x6bd1
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
andq $0x0, 0x48(%r12)
addq $0x50, %r12
jmp 0x14d81c
leaq 0x6bd(%rip), %rsi       # 0x14df13
movl %ebx, %edi
movq %r14, %rdx
movq %r15, %rcx
callq 0xc67c0
movq %r14, %r15
addq $0x48, %r15
subq $0x1, %rbx
jb 0x14d890
movq -0x38(%r15), %rdi
callq 0x2220
leaq -0x30(%r15), %rdi
callq 0x6b07
movq (%r15), %rdi
callq 0x2220
addq $0x50, %r15
jmp 0x14d86a
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/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 $0x18, %rsp
movq %r9, %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x60(%rsp), %r15
movq 0x88(%rsp), %r12
movl 0x50(%rsp), %edx
movq 0x80(%rsp), %r8
movq 0x70(%rsp), %r9
movq 0x78(%rsp), %rcx
movq %rcx, (%rsp)
leaq 0xa3bd2(%rip), %r13     # 0x1f165e
movq %r13, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x22b0
leaq 0x96783(%rip), %rax     # 0x1e4223
movsbl (%r12,%rax), %edx
leaq 0xac2fd(%rip), %rsi     # 0x1f9da9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movq %r15, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq 0x68(%rsp), %r8
movq 0x58(%rsp), %r9
xorl %eax, %eax
callq 0x22b0
leaq 0xa3b93(%rip), %rdi     # 0x1f1670
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2410
movl $0xa8, %r14d
addq 0x90(%rsp), %r14
leaq 0x12(%rsp), %r15
leaq 0x14(%rsp), %r12
leaq 0x967b4(%rip), %r13     # 0x1e42be
xorl %ebp, %ebp
cmpq (%r14), %rbp
jae 0x14db47
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x53a7d
movl %eax, %ebp
movl 0x14(%rsp), %edx
movzwl 0x12(%rsp), %eax
movq 0x98(%rsp), %rcx
movsbl (%rcx,%rax), %ecx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x22b0
jmp 0x14db0c
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2270
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/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 0x105bdf(%rip), %rax    # 0x253758
movq 0x10(%rax), %r12
movq %r12, %rdi
callq 0x2090
leaq 0x40(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x952db(%rip), %rsi     # 0x1e2e73
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
movq %rsp, %r12
movl %r15d, (%r12)
movl %r14d, 0x4(%r12)
movq $0x7d0, 0x8(%r12)       # imm = 0x7D0
leaq 0xacae0(%rip), %rsi     # 0x1fa6a1
movq %rbx, %rdi
callq 0x2210
movq %rax, 0x10(%r12)
leaq 0x2b(%rip), %rsi        # 0x14dc00
pushq $0x3
popq %rcx
movl %ecx, %edi
movq %r12, %rdx
callq 0xc6979
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_O2/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 0x13d062
movq %rax, %rbx
testq %r12, %r12
je 0x14dece
leaq 0x106697(%rip), %rdi    # 0x254538
callq 0x14de2f
leaq 0x1066ab(%rip), %rdi    # 0x254558
callq 0x14de2f
leaq 0x1066bf(%rip), %rdi    # 0x254578
callq 0x14de2f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14c79a
jmp 0x14df00
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14c405
leaq 0x106655(%rip), %rdi    # 0x254538
callq 0x14de2f
leaq 0x106669(%rip), %rdi    # 0x254558
callq 0x14de2f
leaq 0x10667d(%rip), %rdi    # 0x254578
callq 0x14de2f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13d1f3
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/ecovlp.cpp
// Function: handle_chemical_r(unsigned long, unsigned long)
void handle_chemical_r(uint64_t n_thre, uint64_t n_a)
{
    ec_ovec_buf_t *b = NULL; uint64_t k, chem_n = 0, dedup = 0;
    b = gen_ec_ovec_buf_t(n_thre);
    for (k = 0; k < n_thre; ++k) {
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 0;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_r, b, n_a);

    for (k = 0; k < n_thre; ++k) {
        chem_n += b->a[k].cnt[0]; 
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 1;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_r, b, n_a);
    
    for (k = 0; k < n_thre; ++k) {
        dedup += b->a[k].cnt[0]; 
        b->a[k].cnt[1] = 2;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_r, b, n_a);

    fprintf(stderr, "[M::%s] # chimeric reads: %lu, # arcs:: %lu\n", __func__, chem_n, dedup);

    destroy_ec_ovec_buf_t(b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl %r15d, %ebp
callq 0x13d062
movq %rax, %rbx
movl $0xc0, %eax
xorps %xmm0, %xmm0
movq %r15, %rcx
subq $0x1, %rcx
jb 0x14e3a0
movq (%rbx), %rdx
movups %xmm0, (%rdx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14e38b
leaq 0xc4(%rip), %rsi        # 0x14e46b
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xc67c0
movl $0xc0, %eax
xorl %r12d, %r12d
movq %r15, %rcx
subq $0x1, %rcx
jb 0x14e3e2
movq (%rbx), %rdx
addq (%rdx,%rax), %r12
andq $0x0, (%rdx,%rax)
movq $0x1, 0x8(%rdx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14e3bf
leaq 0x82(%rip), %rsi        # 0x14e46b
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xc67c0
movl $0xc8, %eax
xorl %r13d, %r13d
subq $0x1, %r15
jb 0x14e41c
movq (%rbx), %rcx
addq -0x8(%rcx,%rax), %r13
movq $0x2, (%rcx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14e3fe
leaq 0x48(%rip), %rsi        # 0x14e46b
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xc67c0
movq 0x104ba9(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0xa3239(%rip), %rsi     # 0x1f167a
leaq 0xa325f(%rip), %rdx     # 0x1f16a7
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13d1f3
// File: /workspace/github_cpp_makefile_star2_O2/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 0x105da8(%rip), %r14    # 0x254230
movq 0x78(%r14), %rax
imulq $0x18, %rsi, %r15
leaq (%rax,%r15), %rdi
movq 0xc8(%rcx,%rdx), %rcx
testq %rcx, %rcx
je 0x14e4e3
cmpq $0x1, %rcx
jne 0x14e531
movl 0xc(%rdi), %ecx
imulq $0x28, %rcx, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x14e57d
movq (%rdi), %rsi
movl 0xc(%rsi,%rdx), %r8d
imulq $0x18, %r8, %r8
cmpl $0x0, 0xc(%rax,%r8)
jne 0x14e4dd
orl $-0x1, 0xc(%rsi,%rdx)
incq 0xc0(%rbx)
addq $0x28, %rdx
jmp 0x14e4b4
leaq 0x4d0(%rbx), %rax
movq 0x18(%r14), %rcx
movq (%rcx,%rsi,8), %rdx
leaq 0x10525f(%rip), %rsi    # 0x253758
movq 0x2b8(%rsi), %rcx
movq 0x2c0(%rsi), %r8
movsd 0x91b09(%rip), %xmm0    # 0x1e0018
movq %rax, %rsi
xorl %r9d, %r9d
callq 0x145c24
testl %eax, %eax
je 0x14e57d
movq 0x78(%r14), %rax
andl $0x0, 0xc(%rax,%r15)
incq 0xc0(%rbx)
jmp 0x14e57d
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
movl 0xc(%rdi), %esi
cmpq %rsi, %rdx
jae 0x14e57a
movq (%rdi), %rsi
cmpl $-0x1, 0xc(%rsi,%rax)
je 0x14e571
leaq (%rsi,%rax), %r8
imulq $0x28, %rcx, %r9
incq %rcx
movq 0x20(%r8), %r10
movq %r10, 0x20(%rsi,%r9)
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movups %xmm1, 0x10(%rsi,%r9)
movups %xmm0, (%rsi,%r9)
incq %rdx
addq $0x28, %rax
jmp 0x14e537
movl %ecx, 0xc(%rdi)
movl $0x80, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x14f9cd
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/ecovlp.cpp
// Function: handle_chemical_arc(unsigned long, unsigned long)
void handle_chemical_arc(uint64_t n_thre, uint64_t n_a)
{
    ec_ovec_buf_t *b = NULL; uint64_t k, chem_n = 0;
    b = gen_ec_ovec_buf_t(n_thre);
    for (k = 0; k < n_thre; ++k) {
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 0;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc, b, n_a);

    for (k = 0; k < n_thre; ++k) {
        chem_n += b->a[k].cnt[0]; 
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 1;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc, b, n_a);

    fprintf(stderr, "[M::%s] # chimeric reads: %lu\n", __func__, chem_n);

    destroy_ec_ovec_buf_t(b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %r15d, %ebp
callq 0x13d062
movq %rax, %rbx
movl $0xc0, %eax
xorps %xmm0, %xmm0
movq %r15, %rcx
subq $0x1, %rcx
jb 0x14e5c8
movq (%rbx), %rdx
movups %xmm0, (%rdx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14e5b3
leaq 0x7e(%rip), %rsi        # 0x14e64d
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xc67c0
movl $0xc0, %eax
xorl %r12d, %r12d
subq $0x1, %r15
jb 0x14e607
movq (%rbx), %rcx
addq (%rcx,%rax), %r12
andq $0x0, (%rcx,%rax)
movq $0x1, 0x8(%rcx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14e5e4
leaq 0x3f(%rip), %rsi        # 0x14e64d
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xc67c0
movq 0x1049be(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0xa308d(%rip), %rsi     # 0x1f16b9
leaq 0xa30a5(%rip), %rdx     # 0x1f16d8
movq %r12, %rcx
xorl %eax, %eax
callq 0x22b0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13d1f3
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq (%rdi), %rax
movslq %edx, %rcx
imulq $0x5c0, %rcx, %rdx      # imm = 0x5C0
leaq (%rax,%rdx), %rbx
leaq 0x105bc3(%rip), %rcx    # 0x254230
imulq $0x18, %rsi, %r14
addq 0x78(%rcx), %r14
movq 0xc8(%rax,%rdx), %rax
testq %rax, %rax
je 0x14e716
cmpq $0x1, %rax
jne 0x14e784
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorl %edx, %edx
pushq $0x18
popq %rsi
movl 0xc(%r14), %edi
cmpq %rdi, %rdx
jae 0x14e784
movq (%r14), %r9
imulq $0x28, %rdx, %rdi
movl 0xc(%r9,%rdi), %r8d
cmpl 0x4(%r9,%rdi), %r8d
jae 0x14e6c4
incq %rdx
jmp 0x14e69f
imulq $0x18, %r8, %r8
addq 0x78(%rcx), %r8
movq %rsi, %r9
xorl %r10d, %r10d
movl 0xc(%r8), %r11d
cmpq %r11, %r10
jae 0x14e6bf
movq (%r8), %r11
movl -0xc(%r11,%r9), %ebp
movq (%r14), %r12
cmpl 0x4(%r12,%rdi), %ebp
jne 0x14e70d
addq %rdi, %r12
movq (%r11,%r9), %r15
movq 0x18(%r12), %r12
xorq %r15, %r12
jns 0x14e70d
orq %rax, %r15
movq %r15, (%r11,%r9)
movq (%r14), %r11
orq %rax, 0x18(%r11,%rdi)
incq %r10
addq $0x28, %r9
jmp 0x14e6d2
leaq 0x4d0(%rbx), %rax
movq 0x18(%rcx), %rcx
movq (%rcx,%rsi,8), %rdx
leaq 0x10502c(%rip), %rsi    # 0x253758
movq 0x2b8(%rsi), %rcx
movq 0x2c0(%rsi), %r8
movsd 0x918d6(%rip), %xmm0    # 0x1e0018
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rax, %rsi
callq 0x145c24
testl %eax, %eax
je 0x14e784
pushq $0x18
popq %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorl %edx, %edx
movl 0xc(%r14), %esi
cmpq %rsi, %rdx
jae 0x14e77d
movq (%r14), %rsi
orq %rcx, (%rsi,%rax)
incq %rdx
addq $0x28, %rax
jmp 0x14e764
incq 0xc0(%rbx)
movl $0x80, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14f9cd
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/ecovlp.cpp
// Function: gen_chemical_arc_rf(unsigned long, unsigned long)
uint8_t* gen_chemical_arc_rf(uint64_t n_thre, uint64_t n_a)
{
    ec_ovec_buf_t *b = NULL; uint64_t k, chem_n = 0; uint8_t *ra = NULL;
    b = gen_ec_ovec_buf_t(n_thre);
    for (k = 0; k < n_thre; ++k) {
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 0;
    }
    MALLOC(ra, n_a); ///memset(ra, -1, sizeof((*ra))*n_a); 
    b->cr = ra;

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc_mark, b, n_a);

    for (k = 0; k < n_thre; ++k) {
        chem_n += b->a[k].cnt[0]; 
        b->a[k].cnt[0] = 0; b->a[k].cnt[1] = 1;
    }

    kt_for(n_thre, worker_hap_dc_ec_chemical_arc_mark, b, n_a);

    fprintf(stderr, "[M::%s] # chimeric reads: %lu\n", __func__, chem_n);

    b->cr = NULL; destroy_ec_ovec_buf_t(b);
    return ra;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl %r15d, %ebp
callq 0x13d062
movq %rax, %rbx
movl $0xc0, %eax
xorps %xmm0, %xmm0
movq %r15, %rcx
subq $0x1, %rcx
jb 0x14e7d5
movq (%rbx), %rdx
movups %xmm0, (%rdx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14e7c0
movq %r14, %rdi
callq 0x2280
movq %rax, %r12
movq %rax, 0x10(%rbx)
leaq 0x8d(%rip), %rsi        # 0x14e878
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xc67c0
movl $0xc0, %eax
xorl %r13d, %r13d
subq $0x1, %r15
jb 0x14e823
movq (%rbx), %rcx
addq (%rcx,%rax), %r13
andq $0x0, (%rcx,%rax)
movq $0x1, 0x8(%rcx,%rax)
addq $0x5c0, %rax            # imm = 0x5C0
jmp 0x14e800
leaq 0x4e(%rip), %rsi        # 0x14e878
movl %ebp, %edi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xc67c0
movq 0x1047a2(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0xa2e71(%rip), %rsi     # 0x1f16b9
leaq 0xa2e9d(%rip), %rdx     # 0x1f16ec
movq %r13, %rcx
xorl %eax, %eax
callq 0x22b0
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x13d1f3
movq %r12, %rax
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/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq (%rsi), %r12
pushq $0x10
popq %rax
xorl %r14d, %r14d
movq %r12, %rcx
subq $0x1, %rcx
jb 0x14ea42
movq 0x10(%r15), %rdx
movl (%rdx,%rax), %edx
addq %rdx, %r14
addq $0x28, %rax
jmp 0x14ea2c
movq %r14, 0x8(%rsp)
leaq (,%r14,8), %rdi
callq 0x2280
movq %rax, 0x18(%rsp)
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %r12, %rcx
je 0x14ea97
movq 0x10(%r15), %rsi
imulq $0x28, %rcx, %rdi
movl 0x10(%rsi,%rdi), %esi
movq %rcx, %r8
shlq $0x20, %r8
leaq (%rax,%rdx,8), %r9
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x14ea8f
movq %rdi, %r10
orq %r8, %r10
movq %r10, (%r9,%rdi,8)
incq %rdi
jmp 0x14ea7b
incq %rcx
addq %rdi, %rdx
jmp 0x14ea5d
movl %ebx, %edi
callq 0x13d062
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x2a(%rip), %rsi        # 0x14ead5
movl %ebx, %edi
movq %r15, %rdx
movq %r14, %rcx
callq 0xc67c0
movq (%r15), %rdi
callq 0x13d1f3
movq 0x18(%r15), %rdi
callq 0x2220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %edx
movq (%rdi), %rax
cmpq %rdx, %rax
jbe 0x14f05f
movl %r8d, %r15d
movl %ecx, %ebp
movq %rdi, %r14
movq 0x10(%rdi), %rcx
imulq $0x28, %rdx, %r12
movq 0x8(%rcx,%r12), %rax
cmpq 0x10(%rcx,%r12), %rax
jne 0x14effe
leaq (%rax,%rax), %rdx
testq %rax, %rax
pushq $0x2
popq %rsi
cmovneq %rdx, %rsi
leaq (%rcx,%r12), %rax
addq $0x8, %rax
movq %rsi, 0x8(%rax)
movq 0x18(%rax), %rdi
shlq $0x3, %rsi
callq 0x2370
movq 0x10(%r14), %rcx
movq %rax, 0x20(%rcx,%r12)
movq 0x8(%rcx,%r12), %rax
movq 0x20(%rcx,%r12), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x8(%rcx,%r12)
movl %r15d, 0x4(%rdx,%rax,8)
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movl %ebx, (%rdx,%rax,8)
testl %ebp, %ebp
je 0x14f052
movq 0x10(%r14), %rsi
movq 0x18(%rsi,%r12), %rcx
leaq 0x1(%rcx), %rdi
movq %rdi, 0x18(%rsi,%r12)
cmpq 0x8(%rsi,%r12), %rdi
jae 0x14f052
addq %r12, %rsi
addq $0x8, %rsi
movq 0x18(%rsi), %rsi
movq (%rsi,%rcx,8), %rdi
movq (%rdx,%rax,8), %r8
movq %r8, (%rsi,%rcx,8)
movq %rdi, (%rdx,%rax,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r8d
movq 0x103f77(%rip), %rcx    # 0x252fe0
movq (%rcx), %rdi
movl %eax, (%rsp)
leaq 0xa268a(%rip), %rsi     # 0x1f1700
leaq 0xa26b4(%rip), %rdx     # 0x1f1731
movl %r9d, %ecx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x22b0
pushq $0x1
popq %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/ecovlp.cpp
// Function: add_cns_arc(cns_gfa*, unsigned int, unsigned int, unsigned int, unsigned int)
inline uint32_t add_cns_arc(cns_gfa *cns, uint32_t src, uint32_t des, uint32_t is_ou, uint32_t plus)
{
    uint32_t k, s, e;
    if(is_ou) {
        s = 0; e = (*cns).a[src].arc.nou;
    } else {
        s = (*cns).a[src].arc.nou; e = (*cns).a[src].arc.n;
    }

    for (k = s; k < e; k++) {
        if((*cns).a[src].arc.a[k].v == des) {
            (*cns).a[src].arc.a[k].sc += plus;
            break;
        }
    }
    
    return ((k < e)?(1):(0));
}

// Assembly:
movq 0x10(%rdi), %rax
movl %esi, %esi
testl %ecx, %ecx
je 0x14f0ab
imulq $0x28, %rsi, %rcx
addq %rax, %rcx
addq $0x18, %rcx
xorl %edi, %edi
jmp 0x14f0b9
imulq $0x28, %rsi, %rcx
addq %rax, %rcx
addq $0x8, %rcx
movl 0x10(%rcx), %edi
movl (%rcx), %ecx
imulq $0x28, %rsi, %rsi
addq %rsi, %rax
addq $0x20, %rax
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
movq %rdi, %rsi
cmpq %rcx, %rdi
jae 0x14f0ec
movq (%rax), %r10
movl (%r10,%rsi,8), %r11d
andl %r9d, %r11d
leaq 0x1(%rsi), %rdi
cmpl %edx, %r11d
jne 0x14f0cc
addl %r8d, -0x4(%r10,%rdi,8)
xorl %eax, %eax
cmpq %rcx, %rsi
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/ecovlp.cpp
// Function: add_cns_arc_bp(cns_gfa*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
inline uint32_t add_cns_arc_bp(cns_gfa *cns, uint32_t src, uint32_t bp, uint32_t plus0, uint32_t rid, uint32_t av_bp)
{
    uint32_t rr, des;
    rr = get_cns_arc_bp(cns, src, bp, 1, av_bp);
    if(rr != ((uint32_t)-1)) {///find an existing node
        des = (*cns).a[src].arc.a[rr].v;
        (*cns).a[des].sc++;
        (*cns).a[src].arc.a[rr].sc += plus0;

        rr = add_cns_arc(cns, des, src, 0, plus0); 
        // if(rr == 0) {
        //     fprintf(stderr, "[M::%s] src::%u -> des::%u\n", __func__, src, des);
        //     prt_cns_arc(cns, src);
        //     prt_cns_arc(cns, des);
        // }
        assert(rr);

        return des;
    } else {///create a new node
        des = insert_cns_node(cns);
        (*cns).a[des].sc++; (*cns).a[des].c = bp;
        insert_cns_arc(cns, src, des, 1, plus0, rid); 
        insert_cns_arc(cns, des, src, 0, plus0, rid);
    }

    return des;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebx
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rcx
movl %r9d, %r8d
callq 0x14f8c9
cmpl $-0x1, %eax
je 0x14f183
movq 0x10(%r14), %rcx
movl %ebp, %edx
imulq $0x28, %rdx, %rdx
movq 0x20(%rcx,%rdx), %rsi
movl %eax, %eax
movl (%rsi,%rax,8), %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
imulq $0x28, %r15, %rsi
addl $0x8, (%rcx,%rsi)
movq 0x10(%r14), %rcx
movq 0x20(%rcx,%rdx), %rcx
addl %ebx, 0x4(%rcx,%rax,8)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
movl %ebx, %r8d
callq 0x14f092
testl %eax, %eax
jne 0x14f1dc
leaq 0x96d03(%rip), %rdi     # 0x1e5e6e
leaq 0xa0d89(%rip), %rsi     # 0x1efefb
leaq 0xa25c7(%rip), %rcx     # 0x1f1740
movl $0x269, %edx            # imm = 0x269
callq 0x2110
movq %r14, %rdi
callq 0x14f946
movl %eax, %r15d
movq 0x10(%r14), %rax
movl %r15d, %ecx
imulq $0x28, %rcx, %rcx
addl $0x8, (%rax,%rcx)
movq 0x10(%r14), %rax
movl (%rax,%rcx), %edx
andl $0x3, %r13d
andl $-0x4, %edx
orl %r13d, %edx
movl %edx, (%rax,%rcx)
pushq $0x1
popq %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %ebx, %r8d
movl %r12d, %r9d
callq 0x14ef91
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
movl %ebx, %r8d
movl %r12d, %r9d
callq 0x14ef91
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq