LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %edx
movq -0x30(%rbp), %rcx
movq 0x40(%rbp), %r8
movq 0x30(%rbp), %r9
movq 0x38(%rbp), %rax
leaq 0x126351(%rip), %rsi    # 0x39037d
movq %rax, (%rsp)
movb $0x0, %al
callq 0x22a0
movq -0x8(%rbp), %rdi
movq 0x48(%rbp), %rcx
leaq 0x118e55(%rip), %rax    # 0x382e9b
movsbl (%rax,%rcx), %edx
leaq 0x12ea89(%rip), %rsi    # 0x398ada
movb $0x0, %al
callq 0x22a0
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
movq 0x28(%rbp), %r8
movq 0x18(%rbp), %r9
movq 0x20(%rbp), %rax
leaq 0x126307(%rip), %rsi    # 0x39037d
movq %rax, (%rsp)
movb $0x0, %al
callq 0x22a0
movq -0x8(%rbp), %rdi
leaq 0x126303(%rip), %rsi    # 0x39038f
movb $0x0, %al
callq 0x22a0
movq -0x38(%rbp), %rax
movq 0x50(%rbp), %rcx
cmpq 0xa8(%rcx), %rax
jae 0x26a0eb
movq 0x50(%rbp), %rdi
addq $0xa8, %rdi
movq -0x38(%rbp), %rax
movl %eax, %esi
leaq -0x3a(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0xa1ee0
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %edx
movq 0x58(%rbp), %rax
movzwl -0x3a(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
leaq 0x118e54(%rip), %rsi    # 0x382f36
movb $0x0, %al
callq 0x22a0
jmp 0x26a093
movq -0x8(%rbp), %rdi
leaq 0x11c932(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x15a6c9(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdi
callq 0x20a0
movq %rax, %rdi
addq $0x40, %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x15a6a1(%rip), %rax    # 0x3c47f8
movq 0x10(%rax), %rdx
leaq 0x117a4b(%rip), %rsi    # 0x381bad
movb $0x0, %al
callq 0x2050
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x2c(%rbp)
movl $0x7d0, -0x28(%rbp)     # imm = 0x7D0
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x12f232(%rip), %rsi    # 0x3993d2
callq 0x2200
movq %rax, -0x20(%rbp)
movl $0x3, %ecx
leaq 0x2b(%rip), %rsi        # 0x26a1e0
leaq -0x30(%rbp), %rdx
movl %ecx, %edi
callq 0x16d950
movq -0x20(%rbp), %rdi
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0x24ac00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x26a869
leaq 0x15ad9f(%rip), %rdi    # 0x3c55d8
callq 0x26a760
leaq 0x15adb3(%rip), %rdi    # 0x3c55f8
callq 0x26a760
leaq 0x15adc7(%rip), %rdi    # 0x3c5618
callq 0x26a760
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x267f50
jmp 0x26a89e
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x267970
leaq 0x15ad57(%rip), %rdi    # 0x3c55d8
callq 0x26a760
leaq 0x15ad6b(%rip), %rdi    # 0x3c55f8
callq 0x26a760
leaq 0x15ad7f(%rip), %rdi    # 0x3c5618
callq 0x26a760
movq -0x20(%rbp), %rdi
callq 0x24afe0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0x24ac00
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x26b419
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26b3c7
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xd2(%rip), %rsi        # 0x26b500
callq 0x16d710
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x26b4ae
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq 0xc0(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x1, 0xc8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26b43b
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x3d(%rip), %rsi        # 0x26b500
callq 0x16d710
movq 0x158b11(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rcx
leaq 0x124efb(%rip), %rsi    # 0x3903d8
leaq 0x124f13(%rip), %rdx    # 0x3903f7
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rdi
callq 0x24afe0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0x24ac00
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x26b861
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26b80f
movq -0x10(%rbp), %rdi
shlq $0x0, %rdi
callq 0x2270
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xdd(%rip), %rsi        # 0x26b970
callq 0x16d710
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x26b913
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq 0xc0(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x0, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
imulq $0x5c0, -0x20(%rbp), %rcx # imm = 0x5C0
addq %rcx, %rax
movq $0x1, 0xc8(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26b8a0
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x48(%rip), %rsi        # 0x26b970
callq 0x16d710
movq 0x1586ac(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rcx
leaq 0x124a96(%rip), %rsi    # 0x3903d8
leaq 0x124ac2(%rip), %rdx    # 0x39040b
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x24afe0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2100
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x26bd2e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x40(%rbp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x26bcf8
movq -0x30(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2270
movq %rax, -0x20(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x26bdc2
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
imulq $0x28, -0x40(%rbp), %rdx
addq %rdx, %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x26bdb2
movq -0x40(%rbp), %rdx
shlq $0x20, %rdx
orq -0x48(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x26bd64
jmp 0x26bdb4
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x26bd4f
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0x24ac00
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x30(%rbp), %rcx
leaq 0x2e(%rip), %rsi        # 0x26be10
leaq -0x38(%rbp), %rdx
callq 0x16d710
movq -0x38(%rbp), %rdi
callq 0x24afe0
movq -0x20(%rbp), %rdi
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: worker_ec_polish(void*, long, int)
static void worker_ec_polish(void *data, long i, int tid)
{
    ec_ovec_buf_t0 *b = &(((ec_polish_buf_t*)data)->p->a[tid]);
    uint64_t *idx = &(((ec_polish_buf_t*)data)->idx.a[i]);

    if(get_candidate_rrs(&(((ec_polish_buf_t*)data)->ug->u.a[(*idx)>>32]), (uint32_t)(*idx))) {
        *idx = (uint64_t)-1;
    }

   refresh_ec_ovec_buf_t0(b, REFRESH_N);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x5c0, %rcx, %rcx      # imm = 0x5C0
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %eax, %eax
movl %eax, %esi
callq 0x25c8f0
cmpq $0x0, %rax
je 0x26be95
movq -0x28(%rbp), %rax
movq $-0x1, (%rax)
movq -0x20(%rbp), %rdi
movl $0x80, %esi
callq 0x26e2d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x26cd5d
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movl %eax, -0x24(%rbp)
jmp 0x26cd8f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x26cdf6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl -0x10(%rbp), %eax
jne 0x26cde9
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
addl 0x4(%rax,%rcx,8), %edx
movl %edx, 0x4(%rax,%rcx,8)
jmp 0x26cdf6
jmp 0x26cdeb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26cd95
movl -0x1c(%rbp), %edx
movl -0x24(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovbl %ecx, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/ecovlp.cpp
// Function: insert_cns_node(cns_gfa*)
inline uint32_t insert_cns_node(cns_gfa *cns)
{
    cns_t *p; uint32_t m0; 
    if (((*cns)).n == ((*cns)).m) { 
        m0 = ((*cns)).m;
        ((*cns)).m = ((*cns)).m? ((*cns)).m<<1 : 2; 
        ((*cns)).a = (cns_t*)realloc(((*cns)).a, sizeof(cns_t) * ((*cns)).m); 
        if(((*cns)).m > m0) {
            memset(((*cns)).a + m0, 0, sizeof(cns_t)*(((*cns)).m-m0));
        }
    } 
    *(&p) = &((*cns)).a[((*cns)).n++];
    p->arc.n = p->arc.nou = 0;
    p->c = p->f = p->sc = 0;
    return ((*cns)).n - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x26e24d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x26e1d8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x26e1e3
movl $0x2, %eax
movq %rax, -0x20(%rbp)
jmp 0x26e1e3
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x28, 0x8(%rax), %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x26e24b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
subq %rcx, %rax
imulq $0x28, %rax, %rdx
xorl %esi, %esi
callq 0x2100
jmp 0x26e24d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0x7, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $-0x5, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $-0x4, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: destroy_clean_mul_t(clean_mul_t**)
void destroy_clean_mul_t(clean_mul_t **p)
{
    uint32_t i;
    clean_t *kt = NULL;
    free((*p)->bs_flag);
    for (i = 0; i < (*p)->n; i++)
    {
        kt = &((*p)->a[i]);
        kv_destroy(kt->tt.a);
        kv_destroy(kt->stack.a);
        free(kt->vis);
        destory_pdq(&kt->pq_p);
        destory_pdq(&kt->pq_a);
        free(kt->b.a); free(kt->b.S.a); free(kt->b.T.a); free(kt->b.b.a); free(kt->b.e.a);
    }
    free((*p)->a);
    free((*p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
callq 0x2210
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x26e98c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x1a0, %rcx, %rcx      # imm = 0x1A0
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x1cbb60
movq -0x18(%rbp), %rdi
addq $0xb0, %rdi
callq 0x1cbb60
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x130(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x178(%rax), %rdi
callq 0x2210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26e8bb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: init_utg_trans_t(ma_ug_t*, ma_hit_t_alloc*, ma_sub_t*, R_to_U*, asg_t*, int, int)
utg_trans_t *init_utg_trans_t(ma_ug_t *ug, ma_hit_t_alloc* reverse_sources, ma_sub_t *coverage_cut, R_to_U* ruIndex, asg_t *read_g, int max_hang, int min_ovlp)
{
    utg_trans_t *o = NULL; 
    CALLOC(o, 1);
    o->reverse_sources = reverse_sources;
    o->coverage_cut = coverage_cut;
    o->ruIndex = ruIndex;
    o->read_g = read_g;
    o->rn = read_g->n_seq;
    memset(&(o->b0), 0, sizeof(o->b0));
    memset(&(o->b1), 0, sizeof(o->b1));
    MALLOC(o->pos_idx, o->rn); memset(o->pos_idx, -1, o->rn*sizeof(uint64_t));
    o->cug = copy_untig_graph(ug);
    o->max_hang = max_hang;
    o->min_ovlp = min_ovlp;
    return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x1, %edi
movl $0x230, %esi            # imm = 0x230
callq 0x2140
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movq %rcx, 0xe8(%rax)
movq -0x38(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
xorl %esi, %esi
movl $0x68, %edx
callq 0x2100
movq -0x38(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
xorl %esi, %esi
movl $0x68, %edx
callq 0x2100
movq -0x38(%rbp), %rax
movq 0xe8(%rax), %rdi
shlq $0x3, %rdi
callq 0x2270
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x38(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0xe8(%rax), %rdx
shlq $0x3, %rdx
movl $0xff, %esi
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x10ba70
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x108(%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x110(%rax)
movl 0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x114(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: get_utg_chain_length(ma_ug_t*, unsigned int*, unsigned int)
uint64_t get_utg_chain_length(ma_ug_t *ug, uint32_t *a, uint32_t a_n)
{
    uint64_t i, k, l, qn, v, w, nv, offset;
    asg_arc_t *av  = NULL;
    for (i = 0, offset = 0; i < a_n; i++)
    {
        qn = a[i]>>1;
        l = ug->g->seq[qn].len;
        if(i + 1 < a_n)
        {
            v = a[i]; w = a[i+1];
            av = asg_arc_a(ug->g, v);
            nv = asg_arc_n(ug->g, v);
            for (k = 0; k < nv; k++)
            {
                if(av[k].del) continue;
                if(av[k].v == w) 
                {
                    l = asg_arc_len(av[k]);
                    break;
                }
            }
            if(k >= nv) fprintf(stderr, "ERROR-mc\n");
        }
        offset += l;
    }
    return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x26ec90
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq -0x38(%rbp), %rcx
movl (%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x26ec73
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq -0x40(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
movq %rax, -0x50(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x26ec4f
movq -0x60(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x26ec13
jmp 0x26ec41
movq -0x60(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpq -0x48(%rbp), %rax
jne 0x26ec3f
movq -0x60(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x26ec4f
jmp 0x26ec41
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26ebf0
movq -0x28(%rbp), %rax
cmpq -0x50(%rbp), %rax
jb 0x26ec71
movq 0x155380(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x12190e(%rip), %rsi    # 0x390578
movb $0x0, %al
callq 0x22a0
jmp 0x26ec73
movq -0x30(%rbp), %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26eb2b
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: reset_utg_trans_hit_idx(utg_trans_hit_idx*, unsigned int*, unsigned int, ma_ug_t*, utg_trans_t*, unsigned int, unsigned int)
void reset_utg_trans_hit_idx(utg_trans_hit_idx *t, uint32_t* i_x_a, uint32_t i_x_n, ma_ug_t *i_ug, 
utg_trans_t *i_o, uint32_t i_cBeg, uint32_t i_cEnd)
{
    t->a = i_x_a;
    t->an = i_x_n;
    t->ug = i_ug;
    t->o = i_o;
    t->cBeg = i_cBeg;
    t->cEnd = i_cEnd;
    t->ui = t->len = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: collect_trans_ovlp(char const*, buf_t*, unsigned long, buf_t*, unsigned long, ma_ug_t*, utg_trans_t*)
void collect_trans_ovlp(const char* cmd, buf_t* pri, uint64_t pri_offset, buf_t* aux, uint64_t aux_offset,
ma_ug_t *ug, utg_trans_t *o)
{
    uint32_t thre_pri;
    uint64_t len_aux;
    if(pri->b.n == 0 || aux->b.n == 0) return;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x27221d
movq -0x30(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x272222
jmp 0x272344
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %esi
movq -0x40(%rbp), %rdx
movq 0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rbp), %rax
movq 0xe0(%rax), %r8
xorl %r9d, %r9d
movl $0x0, (%rsp)
callq 0xf7330
movl %eax, %eax
movq %rax, -0x50(%rbp)
movq 0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %r8
movq -0x50(%rbp), %rax
movl %eax, %r9d
xorl %eax, %eax
movl %eax, %edi
leaq -0x44(%rbp), %rax
movq %rax, (%rsp)
callq 0x1738b0
cmpl $0x0, -0x44(%rbp)
jbe 0x272307
movq 0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %edx
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movq 0x48(%rax), %r9
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %r14d
movq -0x38(%rbp), %rax
movl %eax, %ebx
movq -0x40(%rbp), %r10
xorl %eax, %eax
movl %eax, %r8d
leaq -0x50(%rbp), %r11
movsd 0x11455c(%rip), %xmm0   # 0x386838
leaq 0x11e2cf(%rip), %rax    # 0x3905b2
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x26f970
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movl %eax, %esi
movq -0x40(%rbp), %rdx
movq 0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rbp), %rax
movq 0xe0(%rax), %r8
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xf7330
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: get_dir_v(unsigned int, buf_t*)
uint32_t get_dir_v(uint32_t x, buf_t *b)
{
    uint32_t i;
    for (i = 0; i < b->b.n; i++)
    {
        if((b->b.a[i]>>1) == x) return b->b.a[i];
    }

    return (uint32_t)-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x272e84
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl %eax
cmpl -0x8(%rbp), %eax
jne 0x272e77
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x272e8b
jmp 0x272e79
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x272e42
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: is_pop_bub(unsigned int, asg_t*, ma_ug_t*, buf_t*, unsigned long, unsigned char*)
int is_pop_bub(uint32_t v, asg_t *g, ma_ug_t *ug, buf_t *b, uint64_t max_dist, uint8_t *bs_flag)
{
    bs_flag[v] = 4;
    asg_arc_t *av = NULL;
    uint32_t nv, i, n_arc;
    int occ = 0;
    nv = asg_arc_n(g, v);
    av = asg_arc_a(g, v);
    ///some node could be deleted
    if (nv < 2 || g->seq[v>>1].del || g->seq[v>>1].c == ALTER_LABLE) return occ;
    ///some edges could be deleted
    for (i = n_arc = 0; i < nv; ++i) // asg_bub_pop1() may delete some edges/arcs
        if (!av[i].del) ++n_arc;
    if (n_arc < 2) return occ;
    if(asg_bub_pop1_primary_trio(ug->g, NULL, v, max_dist, b, (uint32_t)-1, (uint32_t)-1, 0, NULL, NULL, NULL, 0, 0, NULL))
    {
        //beg is v, end is b.S.a[0]
        //note b.b include end, does not include beg
        bs_flag[v] = 0;
        occ = 1;
    }
    return occ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x8(%rbp), %ecx
movb $0x4, (%rax,%rcx)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x8(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x8(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x3c(%rbp)
jb 0x2733dd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x8(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x2733dd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x8(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movzbl 0x4(%rax,%rcx,8), %eax
cmpl $0x1, %eax
jne 0x2733e8
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2734c3
movl $0x0, -0x44(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x27342d
movq -0x38(%rbp), %rax
movl -0x40(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x273420
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x273422
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2733f6
cmpl $0x2, -0x44(%rbp)
jae 0x27343e
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2734c3
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x8(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
callq 0xfe040
cmpq $0x0, %rax
je 0x2734bd
movq -0x30(%rbp), %rax
movl -0x8(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl $0x1, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: bub_iden_worker(void*, long, int)
static void bub_iden_worker(void *_data, long eid, int tid)
{
    clean_mul_t *buf = (clean_mul_t*)_data;
    clean_t *b = &(buf->a[tid]);
    if(is_pop_bub(eid, buf->g, buf->ug, &(b->b), buf->max_dist, buf->bs_flag))
    {
        b->is_b = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x1a0, %rcx, %rcx      # imm = 0x1A0
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %edi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x28(%rbp), %rcx
addq $0x118, %rcx            # imm = 0x118
movq -0x20(%rbp), %rax
movq 0x18(%rax), %r8
movq -0x20(%rbp), %rax
movq 0x20(%rax), %r9
callq 0x273330
cmpl $0x0, %eax
je 0x273cdd
movq -0x28(%rbp), %rax
movl $0x1, 0x198(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: unitig_iden_worker(void*, long, int)
static void unitig_iden_worker(void *_data, long eid, int tid)
{
    long long d;
    clean_mul_t *buf = (clean_mul_t*)_data;
    clean_t *b = &(buf->a[tid]);
    if(is_pop_unitig(eid, buf->g, buf->ug, &(b->tt), &(b->stack), b->vis, &(b->pq_p), &(b->pq_a), buf->fp, buf->fa, &d))
    {
        if(b->min_v == (uint32_t)-1 || (b->min_d > d) || 
        (b->min_d == d && buf->g->seq[b->min_v>>1].len > buf->g->seq[eid>>1].len) ||
        (b->min_d == d && buf->g->seq[b->min_v>>1].len == buf->g->seq[eid>>1].len && b->min_v > eid))
        {
            b->min_v = eid; b->min_d = d;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x1a0, %rcx, %rcx      # imm = 0x1A0
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %edi
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x40(%rbp), %rcx
movq -0x40(%rbp), %r8
addq $0x20, %r8
movq -0x40(%rbp), %rax
movq 0x40(%rax), %r9
movq -0x40(%rbp), %r14
addq $0x48, %r14
movq -0x40(%rbp), %rbx
addq $0xb0, %rbx
movq -0x38(%rbp), %rax
movb 0x28(%rax), %r11b
movq -0x38(%rbp), %r10
leaq -0x30(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movzbl %r11b, %r11d
movl %r11d, 0x10(%rsp)
movzbl 0x29(%r10), %r10d
movl %r10d, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x272e90
cmpl $0x0, %eax
je 0x273ea0
movq -0x40(%rbp), %rax
cmpl $-0x1, 0x180(%rax)
je 0x273e7f
movq -0x40(%rbp), %rax
movq 0x190(%rax), %rax
cmpq -0x30(%rbp), %rax
jg 0x273e7f
movq -0x40(%rbp), %rax
movq 0x190(%rax), %rax
cmpq -0x30(%rbp), %rax
jne 0x273e1c
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rax
movq -0x40(%rbp), %rcx
movl 0x180(%rcx), %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq -0x38(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq -0x20(%rbp), %rdx
sarq %rdx
movl (%rcx,%rdx,8), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jg 0x273e7f
movq -0x40(%rbp), %rax
movq 0x190(%rax), %rax
cmpq -0x30(%rbp), %rax
jne 0x273e9e
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rax
movq -0x40(%rbp), %rcx
movl 0x180(%rcx), %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq -0x38(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq -0x20(%rbp), %rdx
sarq %rdx
movl (%rcx,%rdx,8), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jne 0x273e9e
movq -0x40(%rbp), %rax
movl 0x180(%rax), %eax
cmpq -0x20(%rbp), %rax
jle 0x273e9e
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x180(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x190(%rax)
jmp 0x273ea0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: pt_collect_minimizers(ma_ug_t*, asg_t*, ma_sub_t*, ma_hit_t_alloc*, kvec_asg_arc_t_warp*, int, int)
pt_mz1_v *pt_collect_minimizers(ma_ug_t *ug, asg_t *read_g, ma_sub_t *coverage_cut, ma_hit_t_alloc* sources, 
kvec_asg_arc_t_warp* edge, int max_hang, int min_ovlp)
{
    uint32_t i;
    pt_mz1_v *mz = NULL; CALLOC(mz, 1);
    
    for (i = 0; i < ug->u.n; i++)
    {
        if(!ug->u.a[i].len) continue;
        pt_sketch(ug->u.a[i].s, ug->u.a[i].len, asm_opt.mz_win, asm_opt.k_mer_length, i, 0, mz);
    }

    radix_sort_mz(mz->a, mz->a + mz->n);
    return mz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x2140
movq %rax, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x277681
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0x277615
jmp 0x277673
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
leaq 0x14d1ac(%rip), %rax    # 0x3c47f8
movl 0x94(%rax), %edx
leaq 0x14d19f(%rip), %rax    # 0x3c47f8
movl 0x80(%rax), %ecx
movl -0x30(%rbp), %r8d
movq -0x38(%rbp), %rax
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x276510
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2775e5
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rax
movl (%rax), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x275bb0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: pt_lis_64(int, unsigned long const*, int*, int*)
int32_t pt_lis_64(int32_t n, const uint64_t *a_idx, int32_t *b, int32_t *M)
{
	int32_t i, k, L = 0, *P = b;
	// MALLOC(M, n+1);
	for (i = 0; i < n; ++i) {
		int32_t lo = 1, hi = L, newL;
		while (lo <= hi) {
			int32_t mid = (lo + hi + 1) >> 1;
			if ((uint32_t)a_idx[M[mid]] < (uint32_t)a_idx[i]) lo = mid + 1;
			else hi = mid - 1;
		}
		newL = lo, P[i] = M[newL - 1], M[newL] = i;
		if (newL > L) L = newL;
	}
	k = M[L];
	memcpy(M, P, n * sizeof(int32_t));
	for (i = L - 1; i >= 0; --i) b[i] = k, k = M[k];
	// free(M);
	return L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x277e83
movl $0x1, -0x3c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jg 0x277e36
movl -0x3c(%rbp), %eax
addl -0x40(%rbp), %eax
addl $0x1, %eax
sarl %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x48(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl %ecx, %eax
jae 0x277e2b
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x277e34
movl -0x48(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x277de6
movl -0x3c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x277e73
movl -0x44(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x277e75
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x277dcd
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movslq -0x4(%rbp), %rdx
shlq $0x2, %rdx
callq 0x2180
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x277edc
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x277eaf
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: debug_lis_64(unsigned long const*, int*, unsigned long)
uint32_t debug_lis_64(const uint64_t *a, int32_t *b, uint64_t n)
{
    uint32_t i;
    if(n <= 1) return 1;
    for (i = 0; i+1 < n; i++)
    {
        if(((a[b[i]]>>32) > (a[b[i+1]]>>32)) || (((uint32_t)a[b[i]]) > ((uint32_t)a[b[i+1]])))
        {
            i = (uint32_t)-1;
            break;
        }
    } 
    if(i == (uint32_t)-1)
    {
        fprintf(stderr, "\nERROR-chain\n");   
        for (i = 0; i < n; i++)
        {
            fprintf(stderr, "x-%lu, y-%lu\n", (a[b[i]]>>32), (uint64_t)((uint32_t)a[b[i]]));
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
ja 0x277f17
movl $0x1, -0x4(%rbp)
jmp 0x278038
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
cmpq -0x20(%rbp), %rax
jae 0x277fb0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x24(%rbp), %edx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %esi
addl $0x1, %esi
movl %esi, %esi
movslq (%rdx,%rsi,4), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
cmpq %rcx, %rax
ja 0x277f97
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x24(%rbp), %edx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %esi
addl $0x1, %esi
movl %esi, %esi
movslq (%rdx,%rsi,4), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl %ecx, %eax
jbe 0x277fa0
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x277fb0
jmp 0x277fa2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x277f1e
cmpl $-0x1, -0x24(%rbp)
jne 0x278031
movq 0x14c023(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x1186ea(%rip), %rsi    # 0x3906b1
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae 0x27802f
movq 0x14bffb(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x24(%rbp), %edx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdx
shrq $0x20, %rdx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x24(%rbp), %esi
movslq (%rcx,%rsi,4), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1186a2(%rip), %rsi    # 0x3906bf
movb $0x0, %al
callq 0x22a0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x277fd5
jmp 0x278031
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/tovlp.cpp
// Function: update_mz_ovlp(unsigned int*, unsigned int*, long, unsigned int*, unsigned int*, long, unsigned int)
void update_mz_ovlp(uint32_t* n_x_beg, uint32_t* n_x_end, int64_t xLen, 
uint32_t* n_y_beg, uint32_t* n_y_end, int64_t yLen, uint32_t rev)
{
    int64_t x_beg = (*n_x_beg), x_end = (*n_x_end);
    int64_t y_beg = (*n_y_beg), y_end = (*n_y_end);
    if(x_beg <= y_beg)
    {
        y_beg = y_beg - x_beg;
        x_beg = 0;
    }
    else
    {
        x_beg = x_beg - y_beg;
        y_beg = 0;
    }

    long long x_right_length = xLen - x_end - 1;
    long long y_right_length = yLen - y_end - 1;


    if(x_right_length <= y_right_length)
    {
        x_end = xLen - 1;
        y_end = y_end + x_right_length;        
    }
    else
    {
        x_end = x_end + y_right_length;
        y_end = yLen - 1;
    }

    if(rev == 0)
    {
        (*n_y_beg) = y_beg;
        (*n_y_end) = y_end + 1;
    }
    else
    {
        (*n_y_beg) = yLen - y_end - 1;
        (*n_y_end) = yLen - y_beg - 1 + 1;
    }

    (*n_x_beg) = x_beg;
    (*n_x_end) = x_end + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jg 0x2780b7
movq -0x48(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0x2780cb
movq -0x38(%rbp), %rax
subq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
subq -0x40(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
subq -0x50(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
jg 0x27810f
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rax
addq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x278127
movq -0x40(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, 0x10(%rbp)
jne 0x27814b
movq -0x48(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x278177
movq -0x30(%rbp), %rax
subq -0x50(%rbp), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
subq -0x48(%rbp), %rax
subq $0x1, %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)