LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: append_cns_g(cns_gfa*, char*, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, asg32_v*, unsigned long, unsigned int, long)
uint64_t append_cns_g(cns_gfa *cns, char *tstr, uint64_t tl, uint64_t qs, uint64_t qe, uint64_t cp, uint64_t cl, uint64_t pe, asg32_v* b32, uint64_t max_trace, uint32_t rid, int64_t insert_pos)
{
    // fprintf(stderr, ">q::[%lu, %lu)\n", qs, qe);
    uint64_t s0 = pe, plus0 = 1, ns = qs + cns->off, ne = qe + cns->off;
    if(pe == ((uint64_t)-1)) {
        if(qs > 0) {
            s0 = qs - 1 + cns->off;///just before node in backbone
        } else {
            s0 = 0;//beg
        }
        // plus0 = 0;
    }

    // fprintf(stderr, "+n_nodes::%u, tl::%lu, qs::%lu, qe::%lu\n", (uint32_t)cns->n, tl, qs, qe);

    if(cp == 0) {
        if((cl == 0) && (cp == 0) && (qs == qe) && (((int64_t)qe) == insert_pos)) {
            s0 = 0;//beg
            ns = ne = 1;//end
            plus0 = 1;
        }
        // if(cp == 0) {
        //     fprintf(stderr, "cp::%lu, cl::%lu, qs::%lu, qe::%lu, s0::%lu, ns::%lu, ne::%lu, plus0::%lu\n", cp, cl, qs, qe, s0, ns, ne, plus0);
        // }
        return push_cns_c0(cns, s0, ns, ne, plus0, rid);
    } else if(cp == 1 || cp == 2) { ///cp == 2: more y -> insertion
        return push_cns_c1(cns, s0, tstr, tl, plus0, b32, max_trace, rid);
    } else { ///more x -> do nothing
        return s0;
    }
}

// Assembly:
pushq %rbx
movq %rcx, %r11
movq %rdx, %r10
movq %rsi, %rdx
movl 0x30(%rsp), %eax
movq 0x18(%rsp), %rbx
movl 0x20(%rdi), %ecx
testq %r11, %r11
leaq -0x1(%rcx,%r11), %rsi
cmoveq %r11, %rsi
cmpq $-0x1, %rbx
cmovneq %rbx, %rsi
testq %r9, %r9
je 0x181b17
cmpq $0x2, %r9
ja 0x181b53
movq 0x20(%rsp), %r9
movq %r10, %rcx
movl $0x1, %r8d
pushq %rax
pushq 0x30(%rsp)
callq 0x181a12
addq $0x10, %rsp
jmp 0x181b51
leaq (%rcx,%r11), %rdx
xorq %r8, %r11
orq 0x10(%rsp), %r11
addq %r8, %rcx
xorq 0x38(%rsp), %r8
xorl %r9d, %r9d
orq %r11, %r8
cmoveq %r9, %rsi
movl $0x1, %r8d
cmoveq %r8, %rdx
cmoveq %r8, %rcx
movl $0x1, %r8d
movl %eax, %r9d
callq 0x1811c7
movl %eax, %esi
movq %rsi, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: get_sub_seq(rr_seq_t*, unsigned long, unsigned long)
char *get_sub_seq(rr_seq_t *ssq, uint64_t s, uint64_t e)
{
    if(s >= e) return NULL;

    if(s >= ssq->s && e <= ssq->e) {
        return ssq->tu->seq + s - ssq->s;
    }

    uint64_t l = e - s;
    if(ssq->s >= ssq->e) {
        if(l < ssq->n0) l = ssq->n0;
    } else {
        if(l < ssq->n1) l = ssq->n1;
    }

    ssq->s = s; ssq->e = s + l;
    if(ssq->e > Get_READ_LENGTH((*(ssq->rref)), ssq->id)) {
        ssq->e = Get_READ_LENGTH((*(ssq->rref)), ssq->id);
        l = ssq->e - ssq->s;
    }
    UC_Read_resize((*(ssq->tu)), ((int64_t)l)); 
    recover_UC_Read_sub_region(ssq->tu->seq, ssq->s, l, ssq->rev, ssq->rref, ssq->id);
    return ssq->tu->seq;
}

// Assembly:
movq %rdx, %rax
subq %rsi, %rax
jbe 0x181c0a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
cmpq %rsi, %rcx
seta %r8b
movq 0x18(%rdi), %rdi
cmpq %rdx, %rdi
setb %dl
orb %r8b, %dl
je 0x181c0e
xorl %edx, %edx
cmpq %rdi, %rcx
setb %dl
movq 0x20(%rbx,%rdx,8), %r14
cmpq %r14, %rax
cmovaq %rax, %r14
movq %rsi, 0x10(%rbx)
leaq (%r14,%rsi), %rcx
movq %rcx, 0x18(%rbx)
movq (%rbx), %r8
movq 0x30(%rbx), %r9
movq 0x18(%r8), %rax
movq (%rax,%r9,8), %rax
cmpq %rax, %rcx
jbe 0x181bc7
movq %rax, 0x18(%rbx)
subq %rsi, %rax
movq %rax, %r14
movq 0x8(%rbx), %rax
movq (%rax), %rdi
cmpq %r14, 0x10(%rax)
jge 0x181bf5
movq %r14, %rsi
callq 0x2370
movq %rax, %rdi
movq 0x8(%rbx), %rax
movq %rdi, (%rax)
movq %r14, 0x10(%rax)
movq (%rbx), %r8
movq 0x10(%rbx), %rsi
movq 0x30(%rbx), %r9
movzbl 0x38(%rbx), %ecx
movq %r14, %rdx
callq 0x32ef8
movq 0x8(%rbx), %rax
movq (%rax), %rsi
jmp 0x181c18
xorl %esi, %esi
jmp 0x181c1f
movq 0x8(%rbx), %rax
addq (%rax), %rsi
subq %rcx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: prt_cigar0(unsigned long, long)
void prt_cigar0(uint64_t in, int64_t len)
{
    int64_t k; uint64_t mp;
    char cm[4]; cm[0] = 'M'; cm[1] = 'S'; cm[2] = 'I'; cm[3] = 'D';  
    for (k = 0; k < len; k++) {
        mp = len - 1 - k; mp <<= 1;
        fprintf(stderr, "%c", cm[(in >> mp)&3]);
    }
    fprintf(stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x4449534d, 0x4(%rsp)  # imm = 0x4449534D
testq %rsi, %rsi
jle 0x1826d5
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x2(,%rsi,2), %r15
movq 0x11292e(%rip), %r12    # 0x294fe0
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
movq (%r12), %rsi
andl $0x3, %eax
movsbl 0x4(%rsp,%rax), %edi
callq 0x2270
addq $-0x2, %r15
decq %rbx
jne 0x1826b2
movq 0x112904(%rip), %rax    # 0x294fe0
movq (%rax), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: prt_bp0(unsigned long, long)
void prt_bp0(uint64_t in, int64_t len)
{
    int64_t k; uint64_t mp;
    char cm[4]; cm[0] = 'A'; cm[1] = 'C'; cm[2] = 'G'; cm[3] = 'T';  
    for (k = 0; k < len; k++) {
        mp = len - 1 - k; mp <<= 1;
        fprintf(stderr, "%c", cm[(in >> mp)&3]);
    }
    fprintf(stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x54474341, 0x4(%rsp)  # imm = 0x54474341
testq %rsi, %rsi
jle 0x182741
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x2(,%rsi,2), %r15
movq 0x1128c2(%rip), %r12    # 0x294fe0
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
movq (%r12), %rsi
andl $0x3, %eax
movsbl 0x4(%rsp,%rax), %edi
callq 0x2270
addq $-0x2, %r15
decq %rbx
jne 0x18271e
movq 0x112898(%rip), %rax    # 0x294fe0
movq (%rax), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: push_correct0(window_list*, window_list_alloc*, unsigned int, unsigned int)
uint64_t push_correct0(window_list *idx, window_list_alloc *res, uint32_t len0, uint32_t rc)
{
    uint64_t nec = 0;
    // fprintf(stderr, "[M::%s] NULL(idx)::%u\n", __func__, idx?0:1);
    if(len0 != ((uint32_t)-1)) {
        push_trace_bp(((asg16_v *)(&(res->c))), 0, (uint16_t)-1, len0, ((idx->clen>0)?1:0)); 
        idx->clen = res->c.n - idx->cidx;
    } else if(rc != ((uint32_t)-1)) {
        // fprintf(stderr, "[M::%s]\t", __func__);
        uint32_t cc = (rc<<4)>>20, cn = rc>>28, ck = 0, cs, cp;
        uint32_t bc = (rc<<20)>>20, bn = (rc<<16)>>28, bk = 0, bs, bp;
        ///debug
        // prt_cigar0(cc, cn);
        // prt_bp0(bc, bn);

        for (ck = 0; ck < cn; ck++) {
            cs = (cn-1-ck)<<1; cp = (cc>>cs)&3;

            bp = (uint32_t)-1;
            if(cp != 3) {///bp == 3: more x
                bs = (bn-1-bk)<<1; bp = (bc>>bs)&3; 
                bk++;
            }
            // fprintf(stderr, "[M::%s] cp::%u, bp::%u\n", __func__, cp, bp);

            push_trace_bp(((asg16_v *)(&(res->c))), cp, bp, 1, ((idx->clen>0)?1:0)); 
            idx->clen = res->c.n - idx->cidx;
            // fprintf(stderr, "%c", cm[(in >> mp)&3]);

            // fprintf(stderr, "%c", "MSID"[cp]);
            if(cp != 0) nec++;
        }

        // fprintf(stderr, "\n");
    }

    return nec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x1857ea
movl %edx, %eax
leaq 0x18(%r14), %rdi
xorl %r8d, %r8d
cmpl $0x0, 0x1c(%rbx)
setne %r8b
xorl %r15d, %r15d
xorl %esi, %esi
movl $0xffff, %edx           # imm = 0xFFFF
movl %eax, %ecx
callq 0x196694
movl 0x18(%r14), %eax
subl 0x18(%rbx), %eax
movl %eax, 0x1c(%rbx)
jmp 0x18589c
cmpl $-0x1, %ecx
je 0x1857f9
xorl %ebp, %ebp
cmpl $0x10000000, %ecx       # imm = 0x10000000
jae 0x185801
xorl %r15d, %r15d
jmp 0x18589c
movl %ecx, %eax
shrl $0x10, %eax
movl $0xfff, %edx            # imm = 0xFFF
andl %edx, %eax
movl %eax, 0x14(%rsp)
movl %ecx, %eax
shrl $0x1c, %eax
andl %ecx, %edx
movl %edx, 0xc(%rsp)
shrl $0xc, %ecx
andl $0xf, %ecx
movl %ecx, 0x10(%rsp)
addq $0x18, %r14
leal -0x2(,%rax,2), %r12d
xorl %r15d, %r15d
movl 0x14(%rsp), %r13d
movl %r12d, %ecx
shrl %cl, %r13d
andl $0x3, %r13d
movw $0xffff, %ax            # imm = 0xFFFF
cmpl $0x3, %r13d
je 0x185863
movl %ebp, %ecx
notl %ecx
addl 0x10(%rsp), %ecx
addl %ecx, %ecx
movl 0xc(%rsp), %eax
shrl %cl, %eax
incl %ebp
andl $0x3, %eax
xorl %r8d, %r8d
cmpl $0x0, 0x1c(%rbx)
setne %r8b
movzwl %ax, %edx
movq %r14, %rdi
movl %r13d, %esi
movl $0x1, %ecx
callq 0x196694
movl (%r14), %eax
subl 0x18(%rbx), %eax
movl %eax, 0x1c(%rbx)
cmpl $0x1, %r13d
sbbq $-0x1, %r15
addl $-0x2, %r12d
cmpl $-0x2, %r12d
jne 0x185835
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_cigar_xlen(overlap_region*)
uint32_t cal_cigar_xlen(overlap_region *in)
{
    assert(in->w_list.n == 1);
    uint32_t cn = in->w_list.a[0].clen; uint16_t *a = in->w_list.c.a + in->w_list.a[0].cidx;
    uint32_t ci, len, xk, yk; uint16_t c, b; asg16_v scc; scc.n = scc.m = cn; scc.a = a;

    ci = 0; xk = yk = 0;
    while (ci < cn) {
        ci = pop_trace_bp(&scc, ci, &c, &b, &len);
        if(c != 2) xk += len;
        if(c != 3) yk += len;
    }

    return xk;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpq $0x1, 0x48(%rdi)
jne 0x185dc4
movq 0x58(%rdi), %rax
movl 0x1c(%rax), %ecx
testl %ecx, %ecx
je 0x185dbd
movq 0x70(%rdi), %rdx
movl 0x18(%rax), %eax
leaq (%rdx,%rax,2), %rdx
xorl %esi, %esi
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %r8d
movzwl (%rdx,%r8,2), %r10d
movl %r10d, %r8d
shrl $0xe, %r8d
leal -0x1(%r8), %r9d
cmpw $0x1, %r9w
ja 0x185d31
movl %r10d, %r11d
shrl $0xc, %r11d
andl $0x3, %r11d
andl $0xfff, %r10d           # imm = 0xFFF
jmp 0x185d3e
andl $0x3fff, %r10d          # imm = 0x3FFF
movl $0xffff, %r11d          # imm = 0xFFFF
movzwl %r10w, %r10d
incl %edi
cmpl %edi, %ecx
jbe 0x185d97
movl %edi, %ebx
leaq (%rdx,%rbx,2), %rbx
movzwl (%rbx), %ebp
movl %ebp, %r14d
shrl $0xe, %r14d
cmpl %r8d, %r14d
jne 0x185d97
cmpw $0x1, %r9w
ja 0x185d77
movl %ebp, %r14d
shrl $0xc, %r14d
andl $0x3, %r14d
andl $0xfff, %ebp            # imm = 0xFFF
jmp 0x185d83
andl $0x3fff, %ebp           # imm = 0x3FFF
movl $0xffff, %r14d          # imm = 0xFFFF
cmpl %r11d, %r14d
jne 0x185d97
addl %ebp, %r10d
incl %edi
addq $0x2, %rbx
cmpl %edi, %ecx
jne 0x185d4e
jmp 0x185dad
cmpw $0x2, %r8w
cmovel %esi, %r10d
addl %r10d, %eax
cmpl %ecx, %edi
jb 0x185d03
jmp 0x185dbf
xorl %ecx, %ecx
cmpw $0x2, %r8w
cmovel %ecx, %r10d
addl %r10d, %eax
jmp 0x185dbf
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb8685(%rip), %rdi     # 0x23e450
leaq 0xb8269(%rip), %rsi     # 0x23e03b
leaq 0xb8689(%rip), %rcx     # 0x23e462
movl $0x81f, %edx            # imm = 0x81F
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_cigar_xlen_fhc(overlap_region*)
uint32_t cal_cigar_xlen_fhc(overlap_region *in)
{
    assert(in->w_list.n == 1);
    uint32_t cn = in->w_list.a[0].clen; uint16_t *a = in->w_list.c.a + in->w_list.a[0].cidx;
    uint32_t ci, len, xk, yk; uint16_t c, bq, bt; asg16_v scc; scc.n = scc.m = cn; scc.a = a;

    ci = 0; xk = yk = 0;
    while (ci < cn) {
        ci = pop_trace_bp_f(&scc, ci, &c, &bq, &bt, &len);
        if(c != 2) xk += len;
        if(c != 3) yk += len;
    }

    return xk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x1, 0x48(%rdi)
jne 0x185f70
movq 0x58(%rdi), %rax
movl 0x1c(%rax), %edx
testl %edx, %edx
je 0x185f5f
movq 0x70(%rdi), %rcx
movl 0x18(%rax), %eax
leaq (%rcx,%rax,2), %rsi
xorl %edi, %edi
movw $0xffff, %r8w           # imm = 0xFFFF
leaq 0x4(%rsp), %r9
xorl %eax, %eax
xorl %r11d, %r11d
movl %r11d, %ecx
movzwl (%rsi,%rcx,2), %ebp
movl %ebp, %ebx
shrl $0xe, %ebx
movw %r8w, 0x4(%rsp)
movw %r8w, 0x6(%rsp)
leal -0x2(%rbx), %ecx
cmpl $0x2, %ecx
jae 0x185e52
movw $0xfff, %r14w           # imm = 0xFFF
movw $0xc, %cx
movq %r9, %r10
jmp 0x185e76
movw $0x3fff, %r14w          # imm = 0x3FFF
testl %ebx, %ebx
je 0x185e85
movl %ebp, %ecx
shrl $0xc, %ecx
andl $0x3, %ecx
movw %cx, 0x4(%rsp)
movw $0x3ff, %r14w           # imm = 0x3FF
movw $0xa, %cx
leaq 0x6(%rsp), %r10
movzwl %bp, %r15d
shrl %cl, %r15d
andl $0x3, %r15d
movw %r15w, (%r10)
movzwl %r14w, %ecx
andl %ebp, %ecx
incl %r11d
cmpl %r11d, %edx
jbe 0x185f32
movzwl 0x6(%rsp), %ebp
movzwl 0x4(%rsp), %r14d
movl %r11d, %r10d
leaq (%rsi,%r10,2), %r15
movzwl (%r15), %r12d
movl %r12d, %r10d
shrl $0xe, %r10d
cmpl %ebx, %r10d
jne 0x185f32
movzwl %bx, %r10d
leal -0x2(%r10), %r13d
cmpl $0x2, %r13d
jae 0x185edb
movl %r12d, %r13d
shrl $0xc, %r13d
andl $0x3, %r13d
andl $0xfff, %r12d           # imm = 0xFFF
jmp 0x185eec
testl %r10d, %r10d
jne 0x185ef4
andl $0x3fff, %r12d          # imm = 0x3FFF
movw $0xffff, %r13w          # imm = 0xFFFF
movl $0xffff, %r10d          # imm = 0xFFFF
jmp 0x185f11
movl %r12d, %r13d
shrl $0xc, %r13d
andl $0x3, %r13d
movl %r12d, %r10d
shrl $0xa, %r10d
andl $0x3, %r10d
andl $0x3ff, %r12d           # imm = 0x3FF
cmpl %ebp, %r10d
jne 0x185f32
cmpw %r13w, %r14w
jne 0x185f32
addl %r12d, %ecx
incl %r11d
addq $0x2, %r15
cmpl %r11d, %edx
jne 0x185ea9
movl %edx, %r11d
cmpw $0x3, %bx
jne 0x185f4b
movzwl 0x4(%rsp), %r10d
movw %r10w, 0x6(%rsp)
movw $0xffff, 0x4(%rsp)      # imm = 0xFFFF
cmpw $0x2, %bx
cmovel %edi, %ecx
addl %ecx, %eax
cmpl %edx, %r11d
jb 0x185e24
jmp 0x185f61
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb84d9(%rip), %rdi     # 0x23e450
leaq 0xb80bd(%rip), %rsi     # 0x23e03b
leaq 0xb8507(%rip), %rcx     # 0x23e48c
movl $0x82f, %edx            # imm = 0x82F
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: push_nec_re(overlap_region*, asg16_v*)
void push_nec_re(overlap_region *in, asg16_v *ou)
{
    assert(in->w_list.n == 1);
    uint32_t n1 = in->w_list.a[0].clen;
    if(n1 > ou->m) {
        REALLOC(ou->a, n1); ou->m = n1;
    }
    ou->n = n1;
    memcpy(ou->a, in->w_list.c.a + in->w_list.a[0].cidx, n1*sizeof((*(in->w_list.c.a))));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x1, 0x48(%rdi)
jne 0x187027
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movl 0x1c(%rax), %r12d
movq 0x10(%rsi), %rdi
leaq (%r12,%r12), %r15
cmpq %r12, 0x8(%rsi)
jae 0x187007
movq %r15, %rsi
callq 0x2370
movq %rax, %rdi
movq %rax, 0x10(%r14)
movq %r12, 0x8(%r14)
movq 0x58(%rbx), %rax
movq %r12, (%r14)
movl 0x18(%rax), %esi
addq %rsi, %rsi
addq 0x70(%rbx), %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2160
leaq 0xb7422(%rip), %rdi     # 0x23e450
leaq 0xb7006(%rip), %rsi     # 0x23e03b
leaq 0xb75fe(%rip), %rcx     # 0x23e63a
movl $0x97c, %edx            # imm = 0x97C
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: stderr_phase_ovlp(overlap_region_alloc*)
void stderr_phase_ovlp(overlap_region_alloc* ol)
{
    int64_t on = ol->length, k; overlap_region *z;
    if(!on) return;
    uint64_t qry_n = 0, rid, ref_n, qid;
    rid = ol->list[0].x_id; ref_n = Get_NAME_LENGTH(R_INF, rid);
    
    for (k = 0; k < on; k++) {
        z = &(ol->list[k]); qid = ol->list[k].y_id; 
        qry_n = Get_NAME_LENGTH(R_INF, qid); 

        fprintf(stderr, "%.*s(qid::%lu)\tql::%lu\tq::[%u,\t%u)\t%c\t%.*s(tid::%lu)\ttl::%lu\tt::[%u,\t%u)\ttrans::%u\n", 
        (int32_t)Get_NAME_LENGTH(R_INF, rid), Get_NAME(R_INF, rid), rid, ref_n, z->x_pos_s, z->x_pos_e + 1, "+-"[z->y_pos_strand], 
        (int32_t)Get_NAME_LENGTH(R_INF, qid), Get_NAME(R_INF, qid), qid, qry_n, z->y_pos_s, z->y_pos_e + 1, ((z->is_match==1)?(0):(1)));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x10(%rdi), %r13
testq %r13, %r13
je 0x188c75
jle 0x188c75
movq (%rdi), %rax
movl (%rax), %ecx
leaq 0x10d6a8(%rip), %rax    # 0x296230
movq 0x40(%rax), %rax
movq 0x8(%rax,%rcx,8), %rdx
movq %rcx, 0x10(%rsp)
subq (%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rsp)
movl $0x4, %r12d
movq %rdi, 0x18(%rsp)
movq (%rdi), %rax
movl 0xc(%rax,%r12), %r10d
leaq 0x10d677(%rip), %rcx    # 0x296230
movq 0x8(%rcx), %r11
movq 0x40(%rcx), %rcx
movq (%rcx,%r10,8), %rsi
movq 0x8(%rcx,%r10,8), %rbp
subq %rsi, %rbp
movq 0x10c40c(%rip), %rdx    # 0x294fe0
movq (%rdx), %rdi
movq 0x10(%rsp), %r8
movl 0x8(%rcx,%r8,8), %edx
movq (%rcx,%r8,8), %rcx
subl %ecx, %edx
addq %r11, %rcx
movl (%rax,%r12), %r9d
movq %r9, 0x30(%rsp)
movl 0x4(%rax,%r12), %ebx
incl %ebx
movl 0x18(%rax,%r12), %r9d
leaq 0xa96cd(%rip), %r14     # 0x2322d3
movsbl (%r9,%r14), %r9d
movq %r9, 0x28(%rsp)
addq %rsi, %r11
movl 0x14(%rax,%r12), %r15d
incl %r15d
xorl %r14d, %r14d
cmpb $0x1, 0x28(%rax,%r12)
movl 0x10(%rax,%r12), %eax
movq %rax, 0x20(%rsp)
setne %r14b
leaq 0xb5ba7(%rip), %rsi     # 0x23e7e0
movq 0x8(%rsp), %r9
xorl %eax, %eax
pushq %r14
pushq %r15
pushq 0x30(%rsp)
pushq %rbp
pushq %r10
pushq %r11
pushq %rbp
pushq 0x60(%rsp)
pushq %rbx
pushq 0x78(%rsp)
callq 0x22b0
movq 0x68(%rsp), %rdi
addq $0x50, %rsp
addq $0xa8, %r12
decq %r13
jne 0x188baa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: is_uncorrected_read(overlap_region_alloc*, asg64_v*, long, long)
uint32_t is_uncorrected_read(overlap_region_alloc* ov, asg64_v *idx, int64_t len, int64_t min_len)
{
    uint64_t k, s, e; int64_t dp, old_dp, st = 0, ed;
    for (k = idx->n = 0; k < ov->length; k++) {
        s = ov->list[k].x_pos_s; e = ov->list[k].x_pos_e + 1;
        kv_push(uint64_t, (*idx), (s<<1));
        kv_push(uint64_t, (*idx), (e<<1)|1);
    }

    radix_sort_ec64(idx->a, idx->a + idx->n);
    for (k = 0, dp = 0, st = ed = 0; k < idx->n; ++k) {
        old_dp = dp;
        ///if a[j] is qe
        if (idx->a[k]&1) --dp;
        else ++dp;

        ed = idx->a[k]>>1;
        if(ed > st) {
            if(old_dp == 0) {
                if((ed - st) >= min_len) return 1;
            }
        }
        st = ed;
    }


    ed = len; old_dp = dp;
    if(ed > st) {
        if(old_dp == 0) {
            if((ed - st) >= min_len) return 1;
            if((ed - st) >= len) return 1;
        }
    }
    
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq $0x0, (%rsi)
cmpq $0x0, 0x10(%rdi)
je 0x189217
movq %rdi, %r12
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq 0x10(%r15), %rdi
movl $0x8, %r13d
xorl %ebp, %ebp
movq (%r12), %rax
movl -0x4(%rax,%r13), %r14d
movl (%rax,%r13), %ebx
movq (%r15), %rax
cmpq 0x8(%r15), %rax
jne 0x1891a0
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rsi
movq %rsi, 0x8(%r15)
shlq $0x3, %rsi
callq 0x2370
movq %rax, %rdi
movq %rax, 0x10(%r15)
movq (%r15), %rax
addq %r14, %r14
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
movq %r14, (%rdi,%rax,8)
movq (%r15), %rax
cmpq 0x8(%r15), %rax
jne 0x1891de
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rsi
movq %rsi, 0x8(%r15)
shlq $0x3, %rsi
callq 0x2370
movq %rax, %rdi
movq %rax, 0x10(%r15)
movq (%r15), %rax
incl %ebx
leaq 0x1(,%rbx,2), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%r15)
movq %rcx, (%rdi,%rax,8)
incq %rbp
addq $0xa8, %r13
cmpq 0x10(%r12), %rbp
jb 0x189163
movq (%r15), %rax
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r14
jmp 0x18921d
movq 0x10(%r15), %rdi
xorl %eax, %eax
leaq (%rdi,%rax,8), %rsi
callq 0x17fc92
movq (%r15), %rcx
testq %rcx, %rcx
je 0x189287
movq 0x10(%r15), %rdx
xorl %eax, %eax
xorl %esi, %esi
xorl %edi, %edi
movq %rax, %r9
movq (%rdx,%rdi,8), %r8
movq %r8, %rax
shrq %rax
movq %rax, %r10
subq %r9, %r10
setbe %r9b
testq %rsi, %rsi
setne %r11b
orb %r9b, %r11b
cmpq %rbx, %r10
setl %r9b
orb %r11b, %r9b
cmpb $0x1, %r9b
jne 0x1892ad
andl $0x1, %r8d
negq %r8
orq $0x1, %r8
addq %r8, %rsi
incq %rdi
cmpq %rdi, %rcx
jne 0x189238
testq %rsi, %rsi
sete %cl
jmp 0x18928b
movb $0x1, %cl
xorl %eax, %eax
subq %rax, %r14
jle 0x1892a9
testb %cl, %cl
je 0x1892a9
cmpq %rbx, %r14
setge %cl
testq %rax, %rax
sete %al
orb %cl, %al
movl $0x1, %eax
jne 0x1892b2
xorl %eax, %eax
jmp 0x1892b2
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: cal_cov_re(asg64_v*, long*, unsigned long, unsigned long)
uint64_t cal_cov_re(asg64_v *idx, int64_t *k, uint64_t s, uint64_t e)
{
    uint64_t *a = idx->a, ws, we, cn, os, oe, ovlp, tot = 0; int64_t n = idx->n;
    if(n <= 0) return 0;
    if((*k) >= n) (*k) = 0;
    while (((*k) > 0) && (((uint32_t)a[*k]) > s)) (*k) -= 2;
    if((*k) < 0) (*k) = 0;

    while (((*k) < n) && ((a[*k]>>32) < e)) {
        ws = (a[*k]>>32); we = ((uint32_t)a[*k]); cn = a[(*k) + 1];
        os = MAX(s, ws); oe = MIN(e, we);
        ovlp = ((oe>os)? (oe-os):0);
        tot += (ovlp*cn);
        (*k) += 2;
    }

    return tot;
}

// Assembly:
movq (%rdi), %r8
testq %r8, %r8
jle 0x189d9f
movq 0x10(%rdi), %rdi
movq (%rsi), %r9
cmpq %r8, %r9
jge 0x189daa
testq %r9, %r9
jle 0x189da2
movl (%rdi,%r9,8), %eax
cmpq %rdx, %rax
jbe 0x189db4
leaq -0x2(%r9), %rax
movq %rax, (%rsi)
cmpq $0x2, %r9
movq %rax, %r9
jg 0x189d84
jmp 0x189da5
xorl %eax, %eax
retq
movq %r9, %rax
testq %rax, %rax
jns 0x189db1
movq $0x0, (%rsi)
xorl %r9d, %r9d
xorl %eax, %eax
cmpq %r8, %r9
jge 0x189da1
movq (%rdi,%r9,8), %r11
movq %r11, %r10
shrq $0x20, %r10
cmpq %rcx, %r10
jae 0x189da1
movl %r11d, %r11d
cmpq %rdx, %r10
cmovbeq %rdx, %r10
cmpq %rcx, %r11
cmovaeq %rcx, %r11
subq %r10, %r11
movl $0x0, %r10d
cmovaeq %r11, %r10
imulq 0x8(%rdi,%r9,8), %r10
addq %r10, %rax
addq $0x2, %r9
movq %r9, (%rsi)
jmp 0x189db6
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/ecovlp.cpp
// Function: flip_paf_rc(unsigned long, ma_hit_t_alloc*, All_reads*)
void flip_paf_rc(uint64_t rid, ma_hit_t_alloc *paf, All_reads *rref)
{
    ma_hit_t *z; uint64_t k, m; int64_t ql = Get_READ_LENGTH((*rref), rid), tl, qs, qe, ts, te;
    for (k = m = 0; k < paf->length; k++) {
        z = &(paf->buffer[k]); tl = Get_READ_LENGTH((*rref), z->tn);
        qs = (uint32_t)z->qns; if(qs < 0) qs = 0; if(qs > ql) qs = ql;
        qe = z->qe; if(qe < 0) qe = 0; if(qe > ql) qe = ql;
        ts = z->ts; if(ts < 0) ts = 0; if(ts > tl) ts = tl;
        te = z->te; if(te < 0) te = 0; if(te > tl) te = tl;
        if(qe > qs && te > ts) {
            z->qns >>= 32; z->qns <<= 32;  
            z->qns |= ((uint64_t)(ql - qe));
            z->qe = ql - qs;
            z->ts = tl - te;
            z->te = tl - ts;
            paf->buffer[m++] = *z;
        }
    }
    paf->length = m;
}

// Assembly:
movl 0xc(%rsi), %r10d
testl %r10d, %r10d
je 0x18a590
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rdx), %rax
movq (%rax,%rdi,8), %r9
movl $0x14, %edi
xorl %r8d, %r8d
xorl %ecx, %ecx
movq (%rsi), %r11
movq 0x18(%rdx), %rbx
movl -0x8(%r11,%rdi), %r14d
movq (%rbx,%r14,8), %rbx
movq -0x14(%r11,%rdi), %r14
movl %r14d, %r12d
movl -0xc(%r11,%rdi), %r13d
cmpq %r13, %r9
cmovlq %r9, %r13
movl (%r11,%rdi), %r15d
cmpq %r15, %rbx
cmovlq %rbx, %r15
cmpq %r13, %r12
jge 0x18a571
movl -0x4(%r11,%rdi), %r12d
cmpq %r12, %r15
jle 0x18a571
cmpq %r12, %rbx
cmovlq %rbx, %r12
leaq (%r11,%rdi), %r10
addq $-0x14, %r10
movq %r14, %rbp
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %rbp
movq %r9, %rax
subq %r13, %rax
orq %rbp, %rax
movq %rax, (%r10)
movl %r9d, %eax
subl %r14d, %eax
movl %eax, 0x8(%r10)
movl %ebx, %eax
subl %r15d, %eax
movl %eax, 0x10(%r10)
subl %r12d, %ebx
movl %ebx, 0x14(%r10)
leaq (%rcx,%rcx,4), %rax
incq %rcx
movq 0x20(%r10), %rbx
movq %rbx, 0x20(%r11,%rax,8)
movups (%r10), %xmm0
movups 0x10(%r10), %xmm1
movups %xmm1, 0x10(%r11,%rax,8)
movups %xmm0, (%r11,%rax,8)
movl 0xc(%rsi), %r10d
incq %r8
movl %r10d, %eax
addq $0x28, %rdi
cmpq %rax, %r8
jb 0x18a4c6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a592
xorl %ecx, %ecx
movl %ecx, 0xc(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18b23a
movq (%r15), %rdx
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,4), %rsi
xorl %edi, %edi
xorl %ecx, %ecx
cmpb $0x1, 0x20(%rdx,%rdi)
adcl $0x0, %ecx
addq $0x28, %rdi
cmpq %rdi, %rsi
jne 0x18b227
jmp 0x18b23c
xorl %ecx, %ecx
addl 0xc(%r14), %ecx
cmpq %rcx, 0x8(%rbx)
jae 0x18b29b
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
movq $0x0, (%rbx)
testl %eax, %eax
je 0x18b2f3
movq (%r15), %rcx
movl %eax, %eax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpb $0x0, 0x20(%rcx,%rsi)
jne 0x18b2e8
movl 0xc(%rcx,%rsi), %edi
movq 0x10(%rbx), %r8
movq %rdi, (%r8,%rax,8)
movq (%rbx), %rax
shlq (%r8,%rax,8)
movl 0x18(%rcx,%rsi), %eax
shrl $0x1f, %eax
movq (%rbx), %rdi
orq %rax, (%r8,%rdi,8)
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x28, %rsi
cmpq %rsi, %rdx
jne 0x18b2b7
jmp 0x18b2f5
xorl %eax, %eax
movl 0xc(%r14), %edx
testq %rdx, %rdx
je 0x18b341
movq (%r14), %rcx
movq 0x10(%rbx), %rdi
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
xorl %esi, %esi
movl 0xc(%rcx,%rsi), %r8d
movq %r8, (%rdi,%rax,8)
movq (%rbx), %rax
shlq (%rdi,%rax,8)
movl 0x18(%rcx,%rsi), %eax
shrl $0x1f, %eax
movq (%rbx), %r8
orq %rax, (%rdi,%r8,8)
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x28, %rsi
cmpq %rsi, %rdx
jne 0x18b30f
jmp 0x18b345
movq 0x10(%rbx), %rdi
leaq (%rdi,%rax,8), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17fc92
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18b47f
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 0x18b3b2
movq (%rsp), %rsi
callq 0x334a6
jmp 0x18b3bb
movq (%rsp), %rsi
callq 0x333e0
addq %r12, %r14
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x18b467
movl $0x1c, %r13d
xorl %r12d, %r12d
movq 0x58(%r14), %rdx
movswl -0x8(%rdx,%r13), %ecx
cmpl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x18b3fb
movl (%rdx,%r13), %esi
testl %esi, %esi
jne 0x18b3ff
xorl %esi, %esi
cmpw $0x0, -0xa(%rdx,%r13)
jns 0x18b3ff
jmp 0x18b457
movl (%rdx,%r13), %esi
movl -0x4(%rdx,%r13), %eax
addq %rax, %rax
addq 0x70(%r14), %rax
movq %rax, 0xd8(%rsp)
movl %esi, %eax
movq %rax, 0xd0(%rsp)
movq %rax, 0xc8(%rsp)
movq -0x1c(%rdx,%r13), %rax
movq %rax, 0x3c(%rsp)
movq -0x14(%rdx,%r13), %rax
movq %rax, 0x30(%rsp)
movl %ecx, 0x4c(%rsp)
movl %ecx, 0x48(%rsp)
movq (%rbx), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x98a19
testl %eax, %eax
je 0x18b491
movq 0x48(%r14), %rax
incq %r12
addq $0x20, %r13
cmpq %rax, %r12
jb 0x18b3d4
movq 0x18(%rsp), %rax
incq %rax
cmpq 0x10(%rsp), %rax
movq 0x8(%rsp), %r12
jne 0x18b38b
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x22ad8
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
testq %rax, %rax
je 0x190717
movq 0x10(%rdi), %r8
xorl %r10d, %r10d
movw $0xffff, %r11w          # imm = 0xFFFF
leaq -0x14(%rsp), %rbx
xorl %r9d, %r9d
xorl %edi, %edi
xorl %r15d, %r15d
movzwl (%r8,%r15,2), %ebp
movl %ebp, %r12d
shrl $0xe, %r12d
movw %r11w, -0x14(%rsp)
movw %r11w, -0x12(%rsp)
leal -0x2(%r12), %ecx
cmpl $0x2, %ecx
jae 0x190618
movw $0xfff, %dx             # imm = 0xFFF
movw $0xc, %cx
movq %rbx, %rsi
jmp 0x19063b
movw $0x3fff, %dx            # imm = 0x3FFF
testl %r12d, %r12d
je 0x19064a
movl %ebp, %ecx
shrl $0xc, %ecx
andl $0x3, %ecx
movw %cx, -0x14(%rsp)
movw $0x3ff, %dx             # imm = 0x3FF
movw $0xa, %cx
leaq -0x12(%rsp), %rsi
movzwl %bp, %r14d
shrl %cl, %r14d
andl $0x3, %r14d
movw %r14w, (%rsi)
movzwl %dx, %ecx
andl %ebp, %ecx
incl %r15d
cmpq %r15, %rax
jbe 0x1906d4
movzwl -0x12(%rsp), %ebp
movzwl -0x14(%rsp), %r13d
movzwl (%r8,%r15,2), %r14d
movl %r14d, %edx
shrl $0xe, %edx
cmpl %r12d, %edx
jne 0x1906d4
movzwl %r12w, %edx
leal -0x2(%rdx), %esi
cmpl $0x2, %esi
jae 0x190690
movl %r14d, %edx
shrl $0xc, %edx
andl $0x3, %edx
andl $0xfff, %r14d           # imm = 0xFFF
jmp 0x19069f
testl %edx, %edx
jne 0x1906a6
andl $0x3fff, %r14d          # imm = 0x3FFF
movw $0xffff, %dx            # imm = 0xFFFF
movl $0xffff, %esi           # imm = 0xFFFF
jmp 0x1906bf
movl %r14d, %edx
shrl $0xc, %edx
andl $0x3, %edx
movl %r14d, %esi
shrl $0xa, %esi
andl $0x3, %esi
andl $0x3ff, %r14d           # imm = 0x3FF
cmpl %ebp, %esi
jne 0x1906d4
cmpw %dx, %r13w
jne 0x1906d4
addl %r14d, %ecx
incl %r15d
cmpq %r15, %rax
ja 0x190662
cmpw $0x3, %r12w
jne 0x1906ec
movzwl -0x14(%rsp), %edx
movw %dx, -0x12(%rsp)
movw $0xffff, -0x14(%rsp)    # imm = 0xFFFF
cmpw $0x2, %r12w
movl %ecx, %ecx
movq %rcx, %rdx
cmoveq %r10, %rdx
addq %rdx, %rdi
cmpw $0x3, %r12w
movl %r15d, %r15d
cmoveq %r10, %rcx
addq %rcx, %r9
cmpq %r15, %rax
ja 0x1905e9
jmp 0x19071c
xorl %edi, %edi
xorl %r9d, %r9d
movq -0x10(%rsp), %rax
movq %rdi, (%rax)
movq -0x8(%rsp), %rax
movq %r9, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x103466(%rip), %rbx    # 0x296230
movq 0x78(%rbx), %rcx
leaq (%rsi,%rsi,2), %r13
cmpl $0x0, 0xc(%rcx,%r13,8)
je 0x192ea7
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 0x333e0
movq 0x78(%rbx), %rax
cmpl $0x0, 0xc(%rax,%r13,8)
je 0x192e8c
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 0x192e67
leaq (%r15,%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
leaq 0x1036e1(%rip), %r8     # 0x296538
callq 0x189b65
movb $0x1, %cl
movq 0x8(%rsp), %rdx
testl %eax, %eax
jne 0x192e6d
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 0x192e36
movl $0x80, %esi
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19698b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/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 0x103038(%rip), %rax    # 0x296550
movb $0x0, (%rax,%rsi)
leaq 0x102d0d(%rip), %r12    # 0x296230
movq 0x78(%r12), %rax
leaq (%rsi,%rsi,2), %r13
cmpl $0x0, 0xc(%rax,%r13,8)
je 0x1935ff
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 0x333e0
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
shlq $0x3, %r13
addq 0x78(%r12), %r13
addq %r15, %rbp
addq $0x20, %rbp
subq $0x8, %rsp
leaq 0x102fa0(%rip), %rax    # 0x296538
movsd 0x9e000(%rip), %xmm0    # 0x2315a0
movl $0x200, %r8d            # imm = 0x200
movl $0x4, %r9d
movq %rcx, %r15
movq %r13, %rdx
movq %r12, %rcx
pushq %rax
pushq %rbp
pushq %r14
callq 0x189dfb
addq $0x20, %rsp
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
movq 0x102f7f(%rip), %rdx    # 0x296550
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 0x19698b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/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 0x32e2d
leaq 0x28(%rsp), %rdi
callq 0x32e2d
movq %r15, %rdi
callq 0x2090
movq %rax, %r14
leaq 0x101790(%rip), %rax    # 0x295758
movq 0x10(%rax), %r12
movq %r12, %rdi
callq 0x2090
leaq (%r14,%rax), %rdi
addq $0x24, %rdi
callq 0x2280
movq %rax, %r14
leaq 0xa5027(%rip), %rsi     # 0x239012
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2050
leaq 0xb46e0(%rip), %rsi     # 0x2486e2
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
movq %r14, %rdi
callq 0x2220
leaq 0x102214(%rip), %r12    # 0x296230
cmpq $0x0, 0x50(%r12)
je 0x1940e2
xorl %ebx, %ebx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x333e0
movq 0x102521(%rip), %rcx    # 0x296568
testq %rcx, %rcx
je 0x194069
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq %rbx, %rcx
leaq 0x28(%rsp), %r14
movq %r14, %rdx
movq %r13, %r8
callq 0x18f6f8
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 0x19402d
movq %r15, %rdi
callq 0x2190
leaq 0x8(%rsp), %rdi
callq 0x32d68
leaq 0x28(%rsp), %rdi
callq 0x32d68
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rdi
callq 0x2280
movq %rax, %rbx
testq %r14, %r14
je 0x1941aa
xorl %r12d, %r12d
movq %rbx, %r13
movq %r14, %rbp
leaq 0x18(%r13), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq %r12, 0x10(%r13)
callq 0x32e2d
movq %r12, 0x48(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r13)
addq $0x50, %r13
decq %rbp
jne 0x19413f
leaq 0x732(%rip), %rsi       # 0x1948a2
movl %r14d, %edi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x108f2c
movq %rbx, %r15
addq $0x48, %r15
movq -0x38(%r15), %rdi
callq 0x2220
leaq -0x30(%r15), %rdi
callq 0x32d68
movq (%r15), %rdi
callq 0x2220
addq $0x50, %r15
decq %r14
jne 0x194185
jmp 0x1941be
leaq 0x6f1(%rip), %rsi       # 0x1948a2
xorl %edi, %edi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x108f2c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/chhylp123[P]hifiasm/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 0xab37f(%rip), %rsi     # 0x23f79e
movq %rax, %rcx
xorl %eax, %eax
callq 0x22b0
leaq 0x9dea3(%rip), %rax     # 0x2322d3
movsbl (%r15,%rax), %edx
leaq 0xb39ae(%rip), %rsi     # 0x247dea
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22b0
movq %r14, (%rsp)
movq %rbx, %rdi
leaq 0xab34a(%rip), %rsi     # 0x23f79e
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq %r12, %r9
xorl %eax, %eax
callq 0x22b0
leaq 0xab33d(%rip), %rdi     # 0x23f7b0
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
movq 0xa8(%rbp), %rax
testq %rax, %rax
je 0x1944fa
leaq 0x9ded6(%rip), %r14     # 0x23236e
xorl %r15d, %r15d
movq 0xb8(%rbp), %rsi
movzwl (%rsi,%r15,2), %edx
movl %edx, %ecx
shrl $0xe, %ecx
andl $0x3fff, %edx           # imm = 0x3FFF
incl %r15d
cmpq %r15, %rax
jbe 0x1944db
movzwl (%rsi,%r15,2), %edi
movl %edi, %r8d
shrl $0xe, %r8d
cmpl %ecx, %r8d
jne 0x1944d8
andl $0x3fff, %edi           # imm = 0x3FFF
addl %edi, %edx
incl %r15d
jmp 0x1944b5
movl %r15d, %r15d
movsbl (%r13,%rcx), %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x22b0
movq 0xa8(%rbp), %rax
cmpq %r15, %rax
ja 0x19449b
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_O3/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 0x10122b(%rip), %rax    # 0x295758
movq 0x10(%rax), %r12
movq %r12, %rdi
callq 0x2090
leaq 0x40(%rax), %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x9c937(%rip), %rsi     # 0x230e83
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 0xb416d(%rip), %rsi     # 0x2486e2
movq %rbx, %rdi
callq 0x2210
movq %rax, 0x10(%r12)
leaq 0x30(%rip), %rsi        # 0x1945b9
movl $0x3, %edi
movq %r12, %rdx
movl $0x3, %ecx
callq 0x1090f4
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_O3/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 0x19483a
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 0x194820
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_O3/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 0x17fcf7
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
testq %r12, %r12
jne 0x19488a
callq 0x22bd3
jmp 0x19488f
callq 0x22b8e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18002d