LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: gen_hpc_str(char const*, unsigned int, UC_Read*, unsigned long*)
uint64_t gen_hpc_str(const char *in, uint32_t in_l, UC_Read *z, uint64_t *in_hl)
{
    uint64_t hl, k, l;
    if(in_hl) {
        hl = (*in_hl);
    } else {
        for (l = hl = 0, k = 1; k <= in_l; k++) {
            if((k == in_l) || (in[k] != in[l]) || (seq_nt4_table[(uint8_t)in[l]] >= 4)) {
                hl++; l = k;
            }
        }
    }
    resize_UC_Read(z, hl); z->length = 0;
    for (l = 0, k = 1; k <= in_l; k++) {
        if((k == in_l) || (in[k] != in[l]) || (seq_nt4_table[(uint8_t)in[l]] >= 4)) {
            z->seq[z->length++] = in[l]; l = k;
        }
    }
    return hl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4dffe
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4e08e
movq $0x0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
ja 0x4e08c
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
je 0x4e068
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4e068
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x33c781(%rip), %rax    # 0x38a7e0
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jl 0x4e07c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4e07e
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4e016
jmp 0x4e08e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa62c0
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, -0x38(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
ja 0x4e150
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
je 0x4e10d
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4e10d
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x33c6dc(%rip), %rax    # 0x38a7e0
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jl 0x4e13d
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4e13f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4e0b7
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: prt_cigar(unsigned short*, unsigned int)
void prt_cigar(uint16_t *ca, uint32_t cn)
{
    uint32_t k;
    for (k = 0; k < cn; k++) {
        fprintf(stderr, "%u%c", ca[k]&0x3fff, "EMDI"[ca[k]>>14]);
    }
    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x4f01e
movq 0x37500b(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movzwl (%rax,%rcx,2), %edx
andl $0x3fff, %edx           # imm = 0x3FFF
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
sarl $0xe, %eax
movslq %eax, %rcx
leaq 0x333f3a(%rip), %rax    # 0x382f3b
movsbl (%rax,%rcx), %ecx
leaq 0x333f2a(%rip), %rsi    # 0x382f36
movb $0x0, %al
callq 0x22a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4efc6
movq 0x374fbb(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x3379f9(%rip), %rsi    # 0x386a28
movb $0x0, %al
callq 0x22a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: push_anchors(window_list*, window_list_alloc*, asg64_v*, unsigned long*, long, long*, unsigned int)
void push_anchors(window_list *z, window_list_alloc *zidx, asg64_v *anchor, uint64_t *qhp, int64_t qhp_l, int64_t *qhp_k, uint32_t mcl)
{
    int64_t xi = 0, yi = 0, ci, cn = z->clen; uint8_t c = (uint8_t)-1; uint32_t cl = (uint32_t)-1;
    for (ci = 0; ci < cn; ci++) {
        get_cigar_cell(z, zidx, ci, &c, &cl);
        if (c == 0) { //match   
            if(cl >= mcl) {
                ;
                ;
                ;
                ;
            }
            xi += cl; yi += cl;
        } else if (c == 1) {
            xi += cl; yi += cl;
        } else if (c == 2) {///y has more bases than x
            yi += cl;
        } else if (c == 3) {///x has more bases than y
            xi += cl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq %rax, -0x50(%rbp)
movb $-0x1, -0x51(%rbp)
movl $0xffffffff, -0x58(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
jge 0x538d9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rax
movl %eax, %edx
leaq -0x51(%rbp), %rcx
leaq -0x58(%rbp), %r8
callq 0x2c960
movzbl -0x51(%rbp), %eax
cmpl $0x0, %eax
jne 0x53875
movl -0x58(%rbp), %eax
cmpl 0x10(%rbp), %eax
jb 0x5385d
jmp 0x5385d
movl -0x58(%rbp), %eax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x58(%rbp), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x538c6
movzbl -0x51(%rbp), %eax
cmpl $0x1, %eax
jne 0x53896
movl -0x58(%rbp), %eax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x58(%rbp), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x538c4
movzbl -0x51(%rbp), %eax
cmpl $0x2, %eax
jne 0x538ac
movl -0x58(%rbp), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x538c2
movzbl -0x51(%rbp), %eax
cmpl $0x3, %eax
jne 0x538c0
movl -0x58(%rbp), %eax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x538c2
jmp 0x538c4
jmp 0x538c6
jmp 0x538c8
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x53821
addq $0x60, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: wcigar_check(window_list*, window_list_alloc*, char*, char*)
int64_t wcigar_check(window_list *p, window_list_alloc *z, char *qstr, char *tstr)
{
    bit_extz_t ez;
    ez.cigar.a = z->c.a+p->cidx; ez.cigar.n = ez.cigar.m = p->clen;
    ez.ps = p->y_start; ez.pe = p->y_end;
    ez.ts = p->x_start; ez.te = p->x_end;
    ez.err = p->error;
    // prt_cigar(ez.cigar.a, ez.cigar.n);
    return cigar_check_dbg(tstr, qstr, &ez);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xe8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xe4(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xdc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xd8(%rbp)
movq -0x8(%rbp), %rax
movswl 0x14(%rax), %eax
movl %eax, -0xcc(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xf8(%rbp), %rdx
callq 0xa9670
movl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: update_semi_coord(ul_idx_t const*, hpc_t*, All_reads*, overlap_region*, long, long, long, long*, long*, long*)
int64_t update_semi_coord(const ul_idx_t *uref, hpc_t *hpc_g, All_reads *rref, overlap_region *z, 
int64_t qs, int64_t qe, int64_t thre, int64_t *ts, int64_t *te, int64_t *aux_beg)
{
    int64_t ql = qe - qs, aln_l, t_tot_l, id = z->y_id, aux_end, tl; 
    (*ts) = (qs - z->x_pos_s) + z->y_pos_s;
    (*ts) += y_start_offset(qs, &(z->f_cigar));
    aln_l = ql + (thre<<1);
    if(hpc_g) t_tot_l = hpc_len(*hpc_g, id);
    else if(uref) t_tot_l = uref->ug->u.a[id].len;
    else t_tot_l = Get_READ_LENGTH((*rref), id);
    if(!init_waln(thre, (*ts), t_tot_l, aln_l, aux_beg, &aux_end, ts, &tl)) {
        (*ts) = (*te) = (*aux_beg) = -1;
        return 0;
    }
    (*te) = (*ts) + tl; 
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
subq %rax, %rcx
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
addq %rax, %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x38, %rsi
callq 0x331a0
movq %rax, %rcx
movq 0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq 0x10(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x58004
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x58(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
sarl %eax
cltq
movq %rax, -0x50(%rbp)
jmp 0x58043
cmpq $0x0, -0x10(%rbp)
je 0x5802d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x58(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x58041
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
jmp 0x58043
movq 0x10(%rbp), %rdi
movq 0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq 0x28(%rbp), %r8
movq 0x18(%rbp), %r10
leaq -0x60(%rbp), %r9
leaq -0x68(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x33f90
cmpl $0x0, %eax
jne 0x580a4
movq 0x28(%rbp), %rax
movq $-0x1, (%rax)
movq 0x20(%rbp), %rax
movq $-0x1, (%rax)
movq 0x18(%rbp), %rax
movq $-0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x580be
movq 0x18(%rbp), %rax
movq (%rax), %rcx
addq -0x68(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: update_semi_non_retrieve_coord(overlap_region*, long, long, long, long, long*, long*, long*)
int64_t update_semi_non_retrieve_coord(overlap_region *z, int64_t qs, int64_t qe, int64_t thre, int64_t t_tot_l, int64_t *ts, int64_t *te, int64_t *aux_beg)
{
    int64_t ql = qe - qs, aln_l, aux_end, tl; 
    (*ts) = (qs - z->x_pos_s) + z->y_pos_s;
    (*ts) += y_start_offset(qs, &(z->f_cigar));
    aln_l = ql + (thre<<1);
    
    if(!init_waln(thre, (*ts), t_tot_l, aln_l, aux_beg, &aux_end, ts, &tl)) {
        (*ts) = (*te) = (*aux_beg) = -1;
        return 0;
    }
    (*te) = (*ts) + tl; 
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x331a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq 0x18(%rbp), %r8
movq -0x38(%rbp), %r10
leaq -0x50(%rbp), %r9
leaq -0x58(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x33f90
cmpl $0x0, %eax
jne 0x581b4
movq 0x18(%rbp), %rax
movq $-0x1, (%rax)
movq 0x10(%rbp), %rax
movq $-0x1, (%rax)
movq -0x38(%rbp), %rax
movq $-0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x581ce
movq -0x38(%rbp), %rax
movq (%rax), %rcx
addq -0x58(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: adjust_ext_offset(long*, long*, long*, long*, long, long, long, long)
void adjust_ext_offset(int64_t *qs, int64_t *qe, int64_t *ts, int64_t *te, int64_t ql, int64_t tl, int64_t thre, int64_t mode)
{
    int64_t qoff, toff;
    if(mode == 1) {///forward extension
        qoff = ql - (*qs); toff = tl - (*ts);
        if(qoff <= toff) {
            (*qe) = ql; (*te) = (*ts) + qoff + thre;
        } else {
            (*te) = tl; (*qe) = (*qs) + toff + thre;
        }
    } else if(mode == 2) {///backward extension
        qoff = (*qe); toff = (*te);
        if(qoff <= toff) {
            (*qs) = 0; (*ts) = (*te) - qoff - thre;
        } else {
            (*ts) = 0; (*qs) = (*qe) - toff - thre;
        }
    }
    if((*qs) < 0) (*qs) = 0;
    if((*ts) < 0) (*ts) = 0;
    if((*qe) > ql) (*qe) = ql;
    if((*te) > tl) (*te) = tl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x1, 0x18(%rbp)
jne 0x58279
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x58256
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq -0x38(%rbp), %rcx
addq 0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x58277
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq -0x40(%rbp), %rcx
addq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x582e8
cmpq $0x2, 0x18(%rbp)
jne 0x582e6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x582c3
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
subq -0x38(%rbp), %rcx
subq 0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x582e4
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq -0x40(%rbp), %rcx
subq 0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x582e6
jmp 0x582e8
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x582fd
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x58312
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jle 0x5832a
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jle 0x58342
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: gen_weight_khits0(unsigned int, unsigned int, k_mer_hit*, long, long, unsigned long)
int64_t gen_weight_khits0(uint32_t qs, uint32_t qe, k_mer_hit *a, int64_t an, int64_t k, uint64_t dp)///[qs, qe)
{
    for (; k >= 0 && a[k].self_offset >= qs; k--); 
    for (k = ((k>=0)?k:0); k < an && a[k].self_offset < qe; k++) {
        if((a[k].self_offset >= qs) && (a[k].self_offset < qe) && (!is_alnw(a[k]))) {
            a[k].readID = dp;
        }
    }
    return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
jl 0x5a501
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x4(%rbp), %eax
setae %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x5a50a
jmp 0x5a51a
jmp 0x5a50c
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5a4da
cmpq $0x0, -0x20(%rbp)
jl 0x5a52b
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5a533
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x5a533
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x39(%rbp)
jge 0x5a565
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x8(%rbp), %eax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5a571
jmp 0x5a5f6
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x4(%rbp), %eax
jb 0x5a5e3
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x8(%rbp), %eax
jae 0x5a5e3
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x5a5e3
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0x5a5e5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5a53b
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: gen_weight_khits(asg64_v*, k_mer_hit*, long)
void gen_weight_khits(asg64_v* idx, k_mer_hit *a, int64_t an)
{
    int64_t i, idx_n = idx->n, dp, old_dp, beg, end, k;
    // fprintf(stderr, "[M::%s::] idx->n::%ld\n", __func__, (int64_t)idx->n);
    for (i = k = 0, dp = old_dp = 0, beg = 0, end = -1; i < idx_n; ++i) {///[beg, end) but coordinates in idx is [, ]
        ///if idx->a.a[] is qe
        old_dp = dp;
        if ((idx->a[i]>>32)&1) {
            --dp; end = (idx->a[i]>>33)+1;
        }else {
            //meet a new overlap; the overlaps are pushed by the x_pos_s
            ++dp; end = (idx->a[i]>>33);
        }
        // fprintf(stderr, "[M::%s::] beg::%ld, end::%ld, old_dp::%ld\n", __func__, beg, end, old_dp);
        if(end > beg) k = gen_weight_khits0(beg, end, a, an, k, old_dp);
        beg = end;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq $-0x1, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x5a719
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5a6ad
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x5a6d1
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x21, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x5a700
movq -0x40(%rbp), %rax
movl %eax, %edi
movq -0x48(%rbp), %rax
movl %eax, %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x5a4c0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5a64f
addq $0x50, %rsp
popq %rbp
retq
nop
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: prt_khit(Candidates_list*, overlap_region_alloc*, overlap_region*, unsigned long, char const*)
void prt_khit(Candidates_list *cl, overlap_region_alloc* ol, overlap_region *z, uint64_t utg_id, const char *cmd)
{
    uint64_t k, cid; int64_t i; 
    if(!z) {
        for (k = 0; k < ol->length; k++) {
            z = &(ol->list[k]);
            if(z->y_id == utg_id) break;
        }
    }
    if((z) || (z->y_id == utg_id)) {
            fprintf(stderr, "[M::%s::cmd->%s] ******\n", __func__, (char *)cmd);
        for (i = z->shared_seed, cid = cl->list[i].readID; i < cl->length && cl->list[i].readID == cid; i++) {
            fprintf(stderr, "[M::%s::i->%lu] qoff::%u, toff::%u, cid::%lu, cl->length::%lld\n", __func__, i, 
                        cl->list[i].self_offset, cl->list[i].offset, cid, cl->length);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a790
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x5a78e
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0xa8, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpq -0x20(%rbp), %rax
jne 0x5a77e
jmp 0x5a78e
jmp 0x5a780
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5a74b
jmp 0x5a790
cmpq $0x0, -0x18(%rbp)
jne 0x5a7a8
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpq -0x20(%rbp), %rax
jne 0x5a8ae
movq 0x369831(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rcx
leaq 0x328e58(%rip), %rsi    # 0x383615
leaq 0x328e6a(%rip), %rdx    # 0x38362e
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
movslq 0x24(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x41(%rbp)
jge 0x5a82e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
cmpq -0x38(%rbp), %rax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5a837
jmp 0x5a8ac
movq 0x3697a2(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl 0x8(%rax), %r8d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl 0x4(%rax), %r9d
movq -0x38(%rbp), %r10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x328db3(%rip), %rsi    # 0x383637
leaq 0x328da3(%rip), %rdx    # 0x38362e
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x22a0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x5a7f6
jmp 0x5a8ae
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cigar_gen_cns(overlap_region*, Candidates_list*, ul_ov_t*, unsigned long, unsigned long, unsigned long, ul_idx_t const*, hpc_t*, All_reads*, char*, UC_Read*, bit_extz_t*, double, long, unsigned long, asg64_v*, ul_ov_t*)
uint64_t cigar_gen_cns(overlap_region *z, Candidates_list *cl, ul_ov_t *ov, uint64_t on, uint64_t qn, uint64_t wl,  
const ul_idx_t *uref, hpc_t *hpc_g, All_reads *rref, char* qstr, UC_Read *tu, bit_extz_t *exz, double e_rate, 
int64_t ql, uint64_t rid, asg64_v* iidx, ul_ov_t *des)
{
    if(on <= 0 || iidx->n <= 0) return 0;
    uint64_t i; 
    for (i = 0; i < on; i++) {
        assert((i<=0)||(ov[i].qs > ov[i-1].qe));
        sub_ciagar_gen(z, cl, ov[i].qs, ov[i].qe, wl, uref, hpc_g, rref, qstr, tu, exz, e_rate, ql, rid);
    }
    return on;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %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
movq 0x10(%rbp), %rax
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
movsd %xmm0, -0x60(%rbp)
cmpq $0x0, -0x48(%rbp)
jbe 0x5ac98
movq 0x50(%rbp), %rax
cmpq $0x0, (%rax)
ja 0x5aca5
movq $0x0, -0x28(%rbp)
jmp 0x5adaf
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x5ada7
movb $0x1, %al
cmpq $0x0, -0x68(%rbp)
movb %al, -0x69(%rbp)
jbe 0x5acf2
movq -0x40(%rbp), %rax
imulq $0x1c, -0x68(%rbp), %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x40(%rbp), %rcx
movq -0x68(%rbp), %rdx
subq $0x1, %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
seta %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x5acfb
jmp 0x5acfd
jmp 0x5ad1c
leaq 0x32874a(%rip), %rdi    # 0x38344e
leaq 0x327610(%rip), %rsi    # 0x38231b
movl $0x3a3e, %edx           # imm = 0x3A3E
leaq 0x328960(%rip), %rcx    # 0x383677
callq 0x2130
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rax
imulq $0x1c, -0x68(%rbp), %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, %edx
movq -0x40(%rbp), %rax
imulq $0x1c, -0x68(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x58(%rbp), %r8
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %r12
movq 0x20(%rbp), %r15
movq 0x28(%rbp), %r14
movq 0x30(%rbp), %rbx
movq 0x38(%rbp), %r11
movsd -0x60(%rbp), %xmm0
movq 0x40(%rbp), %r10
movq 0x48(%rbp), %rax
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x59650
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x5acad
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: retrive_str_piece_exz(All_reads*, ul_idx_t const*, char*, long, long, long, long)
char* retrive_str_piece_exz(All_reads *rref, const ul_idx_t *uref, char *buf, int64_t s, int64_t l, int64_t rev, int64_t id)
{
	if(rref) recover_UC_Read_sub_region(buf, s, l, rev, rref, id); 
	else if(uref) retrieve_u_seq(NULL, buf, &(uref->ug->u.a[id]), rev, s, l, NULL); 
	else return NULL;
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5ae1d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %r8
movq 0x10(%rbp), %r9
movzbl %al, %ecx
callq 0x9a30
jmp 0x5ae69
cmpq $0x0, -0x18(%rbp)
je 0x5ae5d
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdx
imulq $0x28, 0x10(%rbp), %rax
addq %rax, %rdx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
xorl %ecx, %ecx
movl %ecx, %edi
movzbl %al, %ecx
movq $0x0, (%rsp)
callq 0x10980
jmp 0x5ae67
movq $0x0, -0x8(%rbp)
jmp 0x5ae71
jmp 0x5ae69
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_global(char*, int, char*, int, int, bit_extz_t*)
void cal_exz_global(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_global_64_w_trace(pstr, pn, tstr, tn, thre, ez);
    } else if(nword == 2) {
        ed_band_cal_global_128_w_trace(pstr, pn, tstr, tn, thre, ez);
    } else {
        ed_band_cal_global_infi_w_trace(pstr, pn, tstr, tn, thre, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x6, %eax
movl -0x2c(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
jg 0x5e7cf
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xa9890
jmp 0x5e817
cmpl $0x2, -0x30(%rbp)
jne 0x5e7f2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xac2d0
jmp 0x5e815
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %rax
leaq -0x30(%rbp), %r9
movq %rax, (%rsp)
callq 0xb16d0
jmp 0x5e817
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_global_simi(char*, int, char*, int, int, bit_extz_t*)
void cal_exz_global_simi(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_global_64_w(pstr, pn, tstr, tn, thre, ez);
    } else if(nword == 2) {
        ed_band_cal_global_128_w(pstr, pn, tstr, tn, thre, ez);
    } else {
        ed_band_cal_global_infi_w(pstr, pn, tstr, tn, thre, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x6, %eax
movl -0x2c(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
jg 0x5e88f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xb73d0
jmp 0x5e8d7
cmpl $0x2, -0x30(%rbp)
jne 0x5e8b2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xb78d0
jmp 0x5e8d5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %rax
leaq -0x30(%rbp), %r9
movq %rax, (%rsp)
callq 0xb8760
jmp 0x5e8d7
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_extension_0(char*, int, char*, int, int, bit_extz_t*)
void cal_exz_extension_0(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_extension_64_0_w_trace(pstr, pn, tstr, tn, thre, ez);
    } else if(nword == 2) {
        ed_band_cal_extension_128_0_w_trace(pstr, pn, tstr, tn, thre, ez);
    } else {
        ed_band_cal_extension_infi_0_w_trace(pstr, pn, tstr, tn, thre, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x6, %eax
movl -0x2c(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
jg 0x5e94f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xaa130
jmp 0x5e997
cmpl $0x2, -0x30(%rbp)
jne 0x5e972
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xad640
jmp 0x5e995
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %rax
leaq -0x30(%rbp), %r9
movq %rax, (%rsp)
callq 0xb2c20
jmp 0x5e997
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_extension_0_simi(char*, int, char*, int, int, bit_extz_t*)
void cal_exz_extension_0_simi(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_extension_64_0_w(pstr, pn, tstr, tn, thre, ez);
    } else if(nword == 2) {
        ed_band_cal_extension_128_0_w(pstr, pn, tstr, tn, thre, ez);
    } else {
        ed_band_cal_extension_infi_0_w(pstr, pn, tstr, tn, thre, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x6, %eax
movl -0x2c(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
jg 0x5ea0f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xb97f0
jmp 0x5ea57
cmpl $0x2, -0x30(%rbp)
jne 0x5ea32
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xb9ed0
jmp 0x5ea55
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %rax
leaq -0x30(%rbp), %r9
movq %rax, (%rsp)
callq 0xbaf40
jmp 0x5ea57
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_extension_1(char*, int, char*, int, int, bit_extz_t*)
void cal_exz_extension_1(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_extension_64_1_w_trace(pstr, pn, tstr, tn, thre, ez);
    } else if(nword == 2) {
        ed_band_cal_extension_128_1_w_trace(pstr, pn, tstr, tn, thre, ez);
    } else {
        ed_band_cal_extension_infi_1_w_trace(pstr, pn, tstr, tn, thre, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x6, %eax
movl -0x2c(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
jg 0x5eacf
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xaac90
jmp 0x5eb17
cmpl $0x2, -0x30(%rbp)
jne 0x5eaf2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xaec30
jmp 0x5eb15
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %rax
leaq -0x30(%rbp), %r9
movq %rax, (%rsp)
callq 0xb4420
jmp 0x5eb17
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_extension_1_simi(char*, int, char*, int, int, bit_extz_t*)
void cal_exz_extension_1_simi(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_extension_64_1_w(pstr, pn, tstr, tn, thre, ez);
    } else if(nword == 2) {
        ed_band_cal_extension_128_1_w(pstr, pn, tstr, tn, thre, ez);
    } else {
        ed_band_cal_extension_infi_1_w(pstr, pn, tstr, tn, thre, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x6, %eax
movl -0x2c(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
jg 0x5eb8f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xbc1c0
jmp 0x5ebd7
cmpl $0x2, -0x30(%rbp)
jne 0x5ebb2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xbc900
jmp 0x5ebd5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %rax
leaq -0x30(%rbp), %r9
movq %rax, (%rsp)
callq 0xbd9b0
jmp 0x5ebd7
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_semi(char*, int, char*, int, int, int, bit_extz_t*)
void cal_exz_semi(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, int32_t aux_beg, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_semi_64_w_absent_diag_trace(pstr, pn, tstr, tn, thre, aux_beg, ez);
    } else if(nword == 2) {
        ed_band_cal_semi_128_w_absent_diag_trace(pstr, pn, tstr, tn, thre, aux_beg, ez);
    } else {
        ed_band_cal_semi_infi_w_absent_diag_trace(pstr, pn, tstr, tn, thre, aux_beg, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
sarl $0x6, %eax
movl -0x28(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jg 0x5ec5b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0xab870
jmp 0x5ecb4
cmpl $0x2, -0x2c(%rbp)
jne 0x5ec86
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0xb02c0
jmp 0x5ecb2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %rax
leaq -0x2c(%rbp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xb5cb0
jmp 0x5ecb4
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: cal_exz_semi_simi(char*, int, char*, int, int, int, bit_extz_t*)
void cal_exz_semi_simi(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, int32_t aux_beg, bit_extz_t *ez)
{
    int32_t bd, nword;
    bd = (((thre)<<1)+1); nword = ((bd>>bitw)+(!!(bd&bitz)));

    if(nword <= 1) {
        ed_band_cal_semi_64_w_absent_diag(pstr, pn, tstr, tn, thre, aux_beg, ez);
    } else if(nword == 2) {
        ed_band_cal_semi_128_w_absent_diag(pstr, pn, tstr, tn, thre, aux_beg, ez);
    } else {
        ed_band_cal_semi_infi_w_absent_diag(pstr, pn, tstr, tn, thre, aux_beg, &nword, ez);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
sarl $0x6, %eax
movl -0x28(%rbp), %ecx
andl $0x3f, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jg 0x5ed3b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0xa8960
jmp 0x5ed94
cmpl $0x2, -0x2c(%rbp)
jne 0x5ed66
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0xbec80
jmp 0x5ed92
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %rax
leaq -0x2c(%rbp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xbfb90
jmp 0x5ed94
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: adjust_ext_offset_fixed_t(long*, long*, long*, long*, long, long, long, long, long, long)
void adjust_ext_offset_fixed_t(int64_t *qs, int64_t *qe, int64_t *ts, int64_t *te, 
int64_t qmin, int64_t qmax, int64_t tmin, int64_t tmax, int64_t thre, int64_t mode)
{
    int64_t qoff, toff;
    if(mode == 1) {///forward extension
        qoff = qmax - (*qs); toff = tmax - (*ts);
        if(qoff <= toff) {
            (*qe) = qmax; (*te) = (*ts) + qoff + thre;
        } else {
            (*te) = tmax; (*qe) = (*qs) + toff + thre;
        }
    } else if(mode == 2) {///backward extension
        qoff = (*qe) - qmin; toff = (*te) - tmin;
        if(qoff <= toff) {
            (*qs) = qmin; (*ts) = (*te) - qoff - thre;
        } else {
            (*ts) = tmin; (*qs) = (*qe) - toff - thre;
        }
    }
    if((*qs) < qmin) (*qs) = qmin;
    if((*ts) < tmin) (*ts) = tmin;
    if((*qe) > qmax) (*qe) = qmax;
    if((*te) > tmax) (*te) = tmax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x1, 0x28(%rbp)
jne 0x5fec1
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x5fe9e
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq -0x38(%rbp), %rcx
addq 0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5febf
movq 0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq -0x40(%rbp), %rcx
addq 0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5ff38
cmpq $0x2, 0x28(%rbp)
jne 0x5ff36
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
subq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x5ff13
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
subq -0x38(%rbp), %rcx
subq 0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5ff34
movq 0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq -0x40(%rbp), %rcx
subq 0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5ff36
jmp 0x5ff38
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jge 0x5ff50
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq 0x10(%rbp), %rax
jge 0x5ff68
movq 0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jle 0x5ff80
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq 0x18(%rbp), %rax
jle 0x5ff98
movq 0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/Correct.cpp
// Function: push_unmap_alnw(overlap_region*, int, long, long, long, long)
void push_unmap_alnw(overlap_region *aux_o, int32_t qs, int64_t qe, int64_t ts, int64_t te, int64_t mode)
{
    window_list *p = NULL;
    kv_pushp(window_list, aux_o->w_list, &p);
    p->x_start = qs; p->x_end = qe;
    p->y_start = ts; p->y_end = te;
    p->error_threshold = mode; p->error = INT16_MAX;
    p->extra_begin = p->extra_end = -1;
    p->cidx = p->clen = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x60d70
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x60d35
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x60d40
movl $0x2, %eax
movq %rax, -0x40(%rbp)
jmp 0x60d40
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
shlq $0x5, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x48(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x48(%rdx)
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x30(%rbp), %rax
movw %ax, %cx
movq -0x38(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x38(%rbp), %rax
movw $0x7fff, 0x14(%rax)     # imm = 0x7FFF
movq -0x38(%rbp), %rax
movw $0xffff, 0x12(%rax)     # imm = 0xFFFF
movq -0x38(%rbp), %rax
movw $0xffff, 0x10(%rax)     # imm = 0xFFFF
movq -0x38(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop