LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/align.c
// Function: mp_extra_stop
static int32_t mp_extra_stop(const mp_reg1_t *r, const uint8_t *nt, int64_t as, int64_t ae)
{
	int64_t j;
	for (j = r->ve; j + 2 < ae; j += 3) {
		int32_t i = j - as;
		uint8_t codon = nt[i]<<4 | nt[i+1]<<2 | nt[i+2];
		uint8_t aa = nt[i] > 3 || nt[i+1] > 3 || nt[i+2] > 3? ns_tab_aa20['X'] : ns_tab_codon[codon];
		if (aa == 20) return j - r->ve;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jge 0x976c
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x4, %eax
movq -0x18(%rbp), %rcx
movl -0x34(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movl -0x34(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, -0x35(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jg 0x9715
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jg 0x9715
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jle 0x9725
leaq 0x1d0d4(%rip), %rax     # 0x267f0
movzbl 0x58(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x9739
movzbl -0x35(%rbp), %eax
movl %eax, %ecx
leaq 0x1d2be(%rip), %rax     # 0x269f0
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movb %al, -0x36(%rbp)
movzbl -0x36(%rbp), %eax
cmpl $0x14, %eax
jne 0x9759
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x48(%rcx), %rax
movl %eax, -0x4(%rbp)
jmp 0x9773
jmp 0x975b
movq -0x30(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x30(%rbp)
jmp 0x9680
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/align.c
// Function: mp_extra_start
static int32_t mp_extra_start(const mp_reg1_t *r, const uint8_t *nt, int64_t as, int64_t ae)
{
	int64_t j;
	for (j = r->vs; j >= as && j + 2 < ae; j -= 3) {
		int32_t i = j - as;
		uint8_t codon = nt[i]<<4 | nt[i+1]<<2 | nt[i+2];
		uint8_t aa = nt[i] > 3 || nt[i+1] > 3 || nt[i+2] > 3? ns_tab_aa20['X'] : ns_tab_codon[codon];
		if (aa == 20) break;
		if (aa == 12) return r->vs - j;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x37(%rbp)
jl 0x97c1
movq -0x30(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
setl %al
movb %al, -0x37(%rbp)
movb -0x37(%rbp), %al
testb $0x1, %al
jne 0x97cd
jmp 0x98b2
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x4, %eax
movq -0x18(%rbp), %rcx
movl -0x34(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movl -0x34(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, -0x35(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jg 0x9850
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jg 0x9850
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jle 0x9860
leaq 0x1cf99(%rip), %rax     # 0x267f0
movzbl 0x58(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x9874
movzbl -0x35(%rbp), %eax
movl %eax, %ecx
leaq 0x1d183(%rip), %rax     # 0x269f0
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movb %al, -0x36(%rbp)
movzbl -0x36(%rbp), %eax
cmpl $0x14, %eax
jne 0x9885
jmp 0x98b2
movzbl -0x36(%rbp), %eax
cmpl $0xc, %eax
jne 0x989f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
subq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x98b9
jmp 0x98a1
movq -0x30(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x30(%rbp)
jmp 0x97a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/./nasw.h
// Function: ns_push_cigar
static inline uint32_t *ns_push_cigar(void *km, int32_t *n_cigar, int32_t *m_cigar, uint32_t *cigar, uint32_t op, int32_t len)
{
	if (*n_cigar == 0 || op != (cigar[(*n_cigar) - 1]&0xf) || op == NS_CIGAR_F || op == NS_CIGAR_G) {
		if (*n_cigar == *m_cigar) {
			(*m_cigar) += ((*m_cigar)>>1) + 8;
			cigar = Krealloc(km, uint32_t, cigar, *m_cigar);
		}
		cigar[(*n_cigar)++] = len<<4 | op;
	} else cigar[(*n_cigar)-1] += len<<4;
	return cigar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa902
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
jne 0xa902
cmpl $0xa, -0x24(%rbp)
je 0xa902
cmpl $0xb, -0x24(%rbp)
jne 0xa961
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xa93f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
sarl %ecx
addl $0x8, %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq (%rax), %rdx
shlq $0x2, %rdx
callq 0xb100
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %edx
shll $0x4, %edx
orl -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xa97d
movl -0x28(%rbp), %edx
shll $0x4, %edx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/align.c
// Function: mp_score_ungapped
static inline int32_t mp_score_ungapped(int32_t alen, const uint8_t *nseq, const char *aseq, int32_t asize, const int8_t *mat)
{
	int32_t i, j, score = 0;
	for (i = 0, j = 0; i < alen; i += 3, ++j) {
		uint8_t nt_aa, aa_aa, codon = nseq[i]<<4 | nseq[i+1]<<2 | nseq[i+2];
		nt_aa = nseq[i] > 3 || nseq[i+1] > 3 || nseq[i+2] > 3? ns_tab_aa20['X'] : ns_tab_codon[codon];
		aa_aa = ns_tab_aa20[(uint8_t)aseq[j]];
		score += mat[nt_aa * asize + aa_aa];
	}
	return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xaaba
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x4, %eax
movq -0x10(%rbp), %rcx
movl -0x2c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movl -0x2c(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, -0x37(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jg 0xaa3f
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jg 0xaa3f
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jle 0xaa4f
leaq 0x1bdaa(%rip), %rax     # 0x267f0
movzbl 0x58(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xaa63
movzbl -0x37(%rbp), %eax
movl %eax, %ecx
leaq 0x1bf94(%rip), %rax     # 0x269f0
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movb %al, -0x35(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x1bd72(%rip), %rax     # 0x267f0
movb (%rax,%rcx), %al
movb %al, -0x36(%rbp)
movq -0x28(%rbp), %rax
movzbl -0x35(%rbp), %ecx
imull -0x1c(%rbp), %ecx
movzbl -0x36(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xa9bb
movl -0x34(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/nasw-sse.c
// Function: mm_insert_epi32
static inline __m128i _mm_insert_epi32(__m128i a, int b, const int ndx)
{
    switch (ndx & 0x3) {
    case 0: a = _mm_insert_epi16( a, b    , 0 );
            a = _mm_insert_epi16( a, b<<16, 1 ); break;
    case 1: a = _mm_insert_epi16( a, b    , 2 );
            a = _mm_insert_epi16( a, b<<16, 3 ); break;
    case 2: a = _mm_insert_epi16( a, b    , 4 );
            a = _mm_insert_epi16( a, b<<16, 5 ); break;
    case 3: a = _mm_insert_epi16( a, b    , 6 );
            a = _mm_insert_epi16( a, b<<16, 7 ); break;
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps %xmm0, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x1518d
movq -0x20(%rbp), %rax
leaq 0xc79a(%rip), %rcx      # 0x21898
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movaps -0x10(%rbp), %xmm0
movl -0x14(%rbp), %eax
pinsrw $0x0, %eax, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
xorl %eax, %eax
pinsrw $0x1, %eax, %xmm0
movdqa %xmm0, -0x10(%rbp)
jmp 0x1518d
movaps -0x10(%rbp), %xmm0
movl -0x14(%rbp), %eax
pinsrw $0x2, %eax, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
xorl %eax, %eax
pinsrw $0x3, %eax, %xmm0
movdqa %xmm0, -0x10(%rbp)
jmp 0x1518d
movaps -0x10(%rbp), %xmm0
movl -0x14(%rbp), %eax
pinsrw $0x4, %eax, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
xorl %eax, %eax
pinsrw $0x5, %eax, %xmm0
movdqa %xmm0, -0x10(%rbp)
jmp 0x1518d
movaps -0x10(%rbp), %xmm0
movl -0x14(%rbp), %eax
pinsrw $0x6, %eax, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
xorl %eax, %eax
pinsrw $0x7, %eax, %xmm0
movdqa %xmm0, -0x10(%rbp)
movdqa -0x10(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/nasw-sse.c
// Function: ns_prep_nas
static void ns_prep_nas(const char *ns, int32_t nl, const ns_opt_t *opt, uint8_t *nas)
{
	int32_t i, l;
	uint8_t codon;
	memset(nas, opt->aa20['X'], nl);
	for (i = l = 0, codon = 0; i < nl; ++i) { // generate the real nas[]
		uint8_t c = opt->nt4[(uint8_t)ns[i]];
		if (c < 4) {
			codon = (codon << 2 | c) & 0x3f;
			if (++l >= 3)
				nas[i] = opt->codon[codon];
		} else codon = 0, l = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movzbl 0x58(%rax), %eax
movslq -0xc(%rbp), %rdx
movzbl %al, %esi
callq 0x2190
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movb $0x0, -0x29(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15365
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %al
movb %al, -0x2a(%rbp)
movzbl -0x2a(%rbp), %eax
cmpl $0x4, %eax
jge 0x1534d
movzbl -0x29(%rbp), %eax
shll $0x2, %eax
movzbl -0x2a(%rbp), %ecx
orl %ecx, %eax
andl $0x3f, %eax
movb %al, -0x29(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x3, %eax
jl 0x1534b
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movzbl -0x29(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x15358
movb $0x0, -0x29(%rbp)
movl $0x0, -0x28(%rbp)
jmp 0x1535a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x152e5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/nasw-sse.c
// Function: ns_fix_tiny_UV
static void ns_fix_tiny_UV(int32_t n_cigar, uint32_t *cigar) // with certain splice scores, it is possible to have 3828V1U which would lead to overlapping exons
{
	int32_t i;
	for (i = 0; i < n_cigar; ++i) {
		int32_t op = cigar[i]&0xf;
		if ((op == NS_CIGAR_U || op == NS_CIGAR_V) && cigar[i]>>4 < 3)
			cigar[i] = cigar[i]>>4<<4 | NS_CIGAR_G;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x154c6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x18(%rbp)
cmpl $0xc, -0x18(%rbp)
je 0x15487
cmpl $0xd, -0x18(%rbp)
jne 0x154b9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
cmpl $0x3, %eax
jae 0x154b9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
shrl $0x4, %edx
shll $0x4, %edx
orl $0xb, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x154bb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15462
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_merge_name
static void mp_ntseq_merge_name(mp_ntdb_t *nt)
{
	int32_t i;
	char *p;
	nt->l_name = 0;
	for (i = 0; i < nt->n_ctg; ++i)
		nt->l_name += strlen(nt->ctg[i].name) + 1;
	nt->name = Kmalloc(0, char, nt->l_name);
	for (i = 0, p = nt->name; i < nt->n_ctg; ++i) {
		memcpy(p, nt->ctg[i].name, strlen(nt->ctg[i].name) + 1);
		free(nt->ctg[i].name);
		nt->ctg[i].name = p;
		p += strlen(nt->ctg[i].name) + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x163d5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2110
movq %rax, %rdx
addq $0x1, %rdx
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1638e
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
shlq $0x0, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xaeb0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x164d7
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2110
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x2200
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2110
addq $0x1, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16408
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_destroy
void mp_ntseq_destroy(mp_ntdb_t *db)
{
	mp_strmap_t *h = (mp_strmap_t*)db->h;
	if (db == 0) return;
	if (h) mp_strmap_destroy(h);
	if (db->spsc) free(db->spsc);
	free(db->ctg); free(db->seq); free(db->name);
	free(db);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16501
jmp 0x16559
cmpq $0x0, -0x10(%rbp)
je 0x16511
movq -0x10(%rbp), %rdi
callq 0x16560
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x16529
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_get
int64_t mp_ntseq_get(const mp_ntdb_t *db, int32_t cid, int64_t st, int64_t en, int32_t rev, uint8_t *seq)
{
	int64_t i, s, e, k;
	if (cid >= db->n_ctg || cid < 0) return -1;
	if (en < 0 || en > db->ctg[cid].len) en = db->ctg[cid].len;
	s = db->ctg[cid].off + st;
	e = db->ctg[cid].off + en;
	if (!rev) {
		for (i = s, k = 0; i < e; ++i)
			seq[k++] = db->seq[i>>1] >> ((i&1) * 4) & 0xf;
	} else {
		for (i = e - 1, k = 0; i >= s; --i) {
			uint8_t c = db->seq[i>>1] >> ((i&1) * 4) & 0xf;
			seq[k++] = c >= 4? c : 3 - c;
		}
	}
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x165ac
cmpl $0x0, -0x14(%rbp)
jge 0x165b9
movq $-0x1, -0x8(%rbp)
jmp 0x1673b
cmpq $0x0, -0x28(%rbp)
jl 0x165dd
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jle 0x165f8
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x166a3
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
jge 0x1669e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x40(%rbp), %rcx
sarq %rcx
movzbl (%rax,%rcx), %eax
movq -0x40(%rbp), %rcx
andq $0x1, %rcx
shlq $0x2, %rcx
sarl %cl, %eax
andl $0xf, %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x58(%rbp)
movb %dl, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x1664a
jmp 0x16733
movq -0x50(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jl 0x16731
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x40(%rbp), %rcx
sarq %rcx
movzbl (%rax,%rcx), %eax
movq -0x40(%rbp), %rcx
andq $0x1, %rcx
shlq $0x2, %rcx
sarl %cl, %eax
andl $0xf, %eax
movb %al, -0x59(%rbp)
movzbl -0x59(%rbp), %eax
cmpl $0x4, %eax
jl 0x166fa
movzbl -0x59(%rbp), %eax
movl %eax, -0x60(%rbp)
jmp 0x16708
movzbl -0x59(%rbp), %ecx
movl $0x3, %eax
subl %ecx, %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x58(%rbp)
movb %dl, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x166b7
jmp 0x16733
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_get_by_v
int64_t mp_ntseq_get_by_v(const mp_ntdb_t *nt, int32_t vid, int64_t st, int64_t en, uint8_t *seq)
{
	int64_t ctg_len = nt->ctg[vid>>1].len;
	if (st < 0 || en < 0 || st >= ctg_len) return -1;
	en = en <= ctg_len? en : ctg_len;
	return mp_ntseq_get(nt, vid>>1, vid&1? ctg_len - en : st, vid&1? ctg_len - st : en, vid&1, seq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x167a2
cmpq $0x0, -0x28(%rbp)
jl 0x167a2
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jl 0x167af
movq $-0x1, -0x8(%rbp)
jmp 0x16851
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
jg 0x167c3
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x167cb
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x44(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x167fc
movq -0x38(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x16804
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16825
movq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x1682d
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdx
movl -0x44(%rbp), %esi
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rcx
movl -0x14(%rbp), %r8d
andl $0x1, %r8d
movq -0x30(%rbp), %r9
callq 0x16580
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_spsc_get_by_v
int64_t mp_ntseq_spsc_get_by_v(const mp_ntdb_t *nt, int32_t vid, int64_t st, int64_t en, uint8_t *ss)
{
	int64_t ctg_len = nt->ctg[vid>>1].len;
	if (st < 0 || en < 0 || st >= ctg_len) return -1;
	en = en <= ctg_len? en : ctg_len;
	return mp_ntseq_spsc_get(nt, vid>>1, vid&1? ctg_len - en : st, vid&1? ctg_len - st : en, vid&1, ss);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x16c32
cmpq $0x0, -0x28(%rbp)
jl 0x16c32
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jl 0x16c3f
movq $-0x1, -0x8(%rbp)
jmp 0x16ce1
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
jg 0x16c53
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x16c5b
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x44(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16c8c
movq -0x38(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x16c94
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16cb5
movq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x16cbd
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdx
movl -0x44(%rbp), %esi
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rcx
movl -0x14(%rbp), %r8d
andl $0x1, %r8d
movq -0x30(%rbp), %r9
callq 0x16860
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_dump
void mp_ntseq_dump(FILE *fp, const mp_ntdb_t *nt)
{
	int32_t i, x[2];
	int64_t l = (nt->l_seq + 1) >> 1;
	x[0] = nt->n_ctg, x[1] = nt->l_name;
	fwrite(x, 4, 2, fp);
	fwrite(&nt->l_seq, 8, 1, fp);
	for (i = 0; i < nt->n_ctg; ++i)
		fwrite(&nt->ctg[i].len, 8, 1, fp);
	fwrite(nt->seq, 1, l, fp);
	fwrite(nt->name, 1, nt->l_name, fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
sarq %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x2, %edx
callq 0x2310
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2310
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x16d9f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2310
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16d5f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_index_name
void mp_ntseq_index_name(mp_ntdb_t *nt)
{
	mp_strmap_t *h;
	int32_t i;
	h = mp_strmap_init2(0);
	for (i = 0; i < nt->n_ctg; ++i) {
		int absent;
		khint_t k;
		k = mp_strmap_put(h, nt->ctg[i].name, &absent);
		if (!absent) {
			fprintf(stderr, "ERROR: duplicated contig name!\n");
			continue;
		}
		kh_val(h, k) = i;
	}
	nt->h = (void*)h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x170b0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x17095
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdx
callq 0x170d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x17072
movq 0xef99(%rip), %rax      # 0x25ff8
movq (%rax), %rdi
leaq 0xa9f6(%rip), %rsi      # 0x21a5f
movb $0x0, %al
callq 0x21f0
jmp 0x1708a
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x1c(%rbp), %edx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17020
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/ntseq.c
// Function: mp_ntseq_name2id
int32_t mp_ntseq_name2id(const mp_ntdb_t *nt, const char *name)
{
	const mp_strmap_t *h = (const mp_strmap_t*)nt->h;
	khint_t k;
	if (h == 0) return -1;
	k = mp_strmap_get(h, name);
	return k == kh_end(h)? -1 : kh_val(h, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1713c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x171a9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x171c0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x17170
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x2c(%rbp)
jmp 0x17177
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x17177
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1718b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x30(%rbp)
jmp 0x171a3
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/./khashl-km.h
// Function: kh_hash_str
static kh_inline khint_t kh_hash_str(kh_cstr_t s) { /* FNV1a */
	khint_t h = KH_FNV_SEED ^ 2166136261U;
	const unsigned char *t = (const unsigned char*)s;
	for (; *t; ++t)
		h ^= *t, h *= 16777619;
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x811c9dce, -0xc(%rbp) # imm = 0x811C9DCE
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x17eb5
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
imull $0x1000193, -0xc(%rbp), %eax # imm = 0x1000193
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x17e87
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/sketch.c
// Function: mp_sketch_prot
void mp_sketch_prot(void *km, const char *seq, int32_t len, int32_t kmer, int32_t mod_bit, mp64_v *a)
{
	int32_t i, l = 0;
	uint32_t x = 0, y, mask_k = (1U<<kmer*MP_BITS_PER_AA) - 1, mask_mod = (1U<<mod_bit) - 1;
	a->n = 0;
	for (i = 0; i < len; ++i) {
		int32_t c = ns_tab_aa13[(uint8_t)seq[i]];
		if (c < 14) {
			#if MP_BITS_PER_AA == 4
			x = (x<<MP_BITS_PER_AA | c) & mask_k;
			#else
			x = (x<<MP_BITS_PER_AA | c>>1) & mask_k;
			#endif
			if (++l >= kmer) {
				y = mp_hash32_mask(x, mask_k);
				if ((y&mask_mod) == 0)
					kv_push(uint64_t, km, *a, (uint64_t)(y>>mod_bit)<<32 | i);
			}
		} else x = 0, l = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x181ec
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xe80f(%rip), %rax      # 0x268f0
movzbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
cmpl $0xe, -0x44(%rbp)
jge 0x181ce
movl -0x34(%rbp), %eax
shll $0x4, %eax
orl -0x44(%rbp), %eax
andl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl -0x18(%rbp), %eax
jl 0x181cc
movl -0x34(%rbp), %edi
movl -0x3c(%rbp), %esi
callq 0x18200
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
andl -0x40(%rbp), %eax
cmpl $0x0, %eax
jne 0x181ca
jmp 0x18132
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x18195
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x18159
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, -0x48(%rbp)
jmp 0x18163
movl $0x2, %eax
movl %eax, -0x48(%rbp)
jmp 0x18163
movl -0x48(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movslq 0x4(%rax), %rdx
shlq $0x3, %rdx
callq 0xb100
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x38(%rbp), %eax
movl -0x1c(%rbp), %ecx
shrl %cl, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x20, %rdx
movslq -0x2c(%rbp), %rax
orq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x181ca
jmp 0x181cc
jmp 0x181dc
movl $0x0, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
jmp 0x181de
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x180c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/sketch.c
// Function: mp_hash32_mask
static inline uint32_t mp_hash32_mask(uint32_t key, uint32_t mask)
{
	key  = (key + ~(key << 15)) & mask;
	key ^=  (key >> 10);
	key  =  (key + (key <<  3)) & mask;
	key ^=  (key >> 6);
	key  = (key + ~(key << 11)) & mask;
	key ^=  (key >> 16);
	return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shll $0xf, %ecx
xorl $-0x1, %ecx
addl %ecx, %eax
andl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0xa, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shll $0x3, %ecx
addl %ecx, %eax
andl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x6, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shll $0xb, %ecx
xorl $-0x1, %ecx
addl %ecx, %eax
andl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/bseq.c
// Function: mp_bseq_open
mp_bseq_file_t *mp_bseq_open(const char *fn)
{
	mp_bseq_file_t *fp;
	gzFile f;
	f = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(0, "r");
	if (f == 0) return 0;
	fp = (mp_bseq_file_t*)calloc(1, sizeof(mp_bseq_file_t));
	fp->fp = f;
	fp->ks = kseq_init(fp->fp);
	return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1898e
movq -0x10(%rbp), %rdi
leaq 0x8c07(%rip), %rsi      # 0x21575
callq 0x21d0
cmpl $0x0, %eax
je 0x1898e
movq -0x10(%rbp), %rdi
leaq 0x791d(%rip), %rsi      # 0x202a0
callq 0x2290
movq %rax, -0x28(%rbp)
jmp 0x189a0
xorl %edi, %edi
leaq 0x7909(%rip), %rsi      # 0x202a0
callq 0x20e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x189b9
movq $0x0, -0x8(%rbp)
jmp 0x189f6
movl $0x1, %edi
movl $0x30, %esi
callq 0x21c0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x15a10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/bseq.c
// Function: kseq2bseq
static inline void kseq2bseq(kseq_t *ks, mp_bseq1_t *s, int with_comment)
{
	if (ks->name.l == 0)
		fprintf(stderr, "[WARNING]\033[1;31m empty sequence name in the input.\033[0m\n");
	s->name = kstrdup(&ks->name);
	s->seq = kstrdup(&ks->seq);
	s->comment = with_comment && ks->comment.l? kstrdup(&ks->comment) : 0;
	s->l_seq = ks->seq.l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x18e05
movq 0xd204(%rip), %rax      # 0x25ff8
movq (%rax), %rdi
leaq 0x8eb4(%rip), %rsi      # 0x21cb2
movb $0x0, %al
callq 0x21f0
movq -0x8(%rbp), %rdi
callq 0x18e80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x18e80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x18e55
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x18e55
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x18e80
movq %rax, -0x20(%rbp)
jmp 0x18e5d
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x18e5d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/hit.c
// Function: mp_cal_chn_sc_ungap
int32_t mp_cal_chn_sc_ungap(int32_t n_a, const uint64_t *a, int32_t kmer)
{
	int32_t i, x = kmer;
	for (i = 1; i < n_a; ++i) {
		const uint64_t a0 = a[i - 1], a1 = a[i];
		int32_t dq = (int32_t)a1 - (int32_t)a0, dr3 = (a1>>32) - (a0>>32);
		int32_t dr = dr3 / 3, q = dr3 - dr * 3, dg;
		dg = dq < dr? dq : dr;
		if (dq >= dr && q != 0) --x;
		else x += dg < kmer? dg : kmer;
	}
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1a28d
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
shrq $0x20, %rax
movq -0x28(%rbp), %rcx
shrq $0x20, %rcx
subq %rcx, %rax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
imull $0x3, -0x3c(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x1a239
movl -0x34(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x1a23f
movl -0x3c(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jl 0x1a25e
cmpl $0x0, -0x40(%rbp)
je 0x1a25e
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a27d
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1a26e
movl -0x44(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x1a274
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a27f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a1bb
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/hit.c
// Function: mp_cal_chn_sc_ungap_approx
static int32_t mp_cal_chn_sc_ungap_approx(const mp_reg1_t *r, const uint64_t *a, int32_t kmer)
{
	int32_t i, x = kmer;
	for (i = 1; i < r->cnt; ++i) {
		const uint64_t a0 = a[r->off + i - 1], a1 = a[r->off + i];
		int32_t dq = (int32_t)a1 - (int32_t)a0;
		x += dq < kmer? dq : kmer;
		if (a1>>32 == a0>>32) x += MP_BLOCK_BONUS;
	}
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1a6e9
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
addl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1a6ac
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x1a6b2
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
shrq $0x20, %rax
movq -0x28(%rbp), %rcx
shrq $0x20, %rcx
cmpq %rcx, %rax
jne 0x1a6d9
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a6db
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a64c
movl -0x1c(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/hit.c
// Function: mp_collate_a
uint64_t *mp_collate_a(void *km, int32_t n_reg, mp_reg1_t *reg)
{
	uint64_t *a;
	int64_t n_a;
	int32_t i;
	for (i = 0, n_a = 0; i < n_reg; ++i)
		n_a += reg[i].cnt;
	a = Kmalloc(km, uint64_t, n_a);
	for (i = 0, n_a = 0; i < n_reg; ++i) {
		mp_reg1_t *r = &reg[i];
		r->off = n_a;
		memcpy(&a[n_a], r->a, r->cnt * sizeof(uint64_t));
		kfree(km, r->a);
		r->a = &a[n_a];
		n_a += r->cnt;
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1a740
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movslq 0x4(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a712
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0xaeb0
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1a7fd
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x38(%rbp), %rax
movslq 0x4(%rax), %rdx
shlq $0x3, %rdx
callq 0x2200
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0xac90
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x38(%rbp), %rax
movslq 0x4(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a764
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/hit.c
// Function: mp_select_multi_exon
void mp_select_multi_exon(int32_t n, mp_reg1_t *r, int32_t single_penalty)
{
	int32_t i;
	mp_reg1_t t;
	if (n < 2 || r[0].n_exon != 1) return;
	for (i = 1; i < n; ++i)
		if (r[i].n_exon >= 2)
			break;
	if (i == n) return;
	if (r[0].p == 0 || r[i].p == 0) return;
	if (r[0].p->dp_max < r[i].p->dp_max + single_penalty)
		t = r[0], r[0] = r[i], r[i] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2, -0x4(%rbp)
jl 0x1b7f5
movq -0x10(%rbp), %rax
cmpl $0x1, 0x20(%rax)
je 0x1b7fa
jmp 0x1b8d1
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1b82d
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x20(%rax)
jl 0x1b820
jmp 0x1b82d
jmp 0x1b822
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1b801
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x1b83a
jmp 0x1b8d1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1b85b
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x60(%rax)
jne 0x1b85d
jmp 0x1b8d1
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x68, %rdx, %rdx
addq %rdx, %rcx
movq 0x60(%rcx), %rcx
movl 0x4(%rcx), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1b8d1
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x68, %edx
callq 0x2200
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rsi
movl $0x68, %edx
callq 0x2200
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x68, %rax, %rax
addq %rax, %rdi
leaq -0x80(%rbp), %rsi
movl $0x68, %edx
callq 0x2200
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]miniprot/format.c
// Function: str_enlarge
static inline void str_enlarge(kstring_t *s, int l)
{
	if (s->l + l + 1 > s->m) {
		s->m = s->l + l + 1;
		kroundup64(s->m);
		s->s = (char*)realloc(s->s, s->m);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x1c568
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2260
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/filter/iir.c
// Function: iirFilter
static double
iirFilter(int channel,int index)
    {
    int i;
    double total;

    //printf("initial: %f\n",getInput(channel,index));
    total = 0; 
    
    for (i = 0; i < feedforwardTaps; i++) 
        {
        total += feedforward[feedforwardTaps-i-1] * getInput(channel,index-i);
        //printf("    feedforward total now is %f\n",total);
        }
    
    for (i = 0; i < feedbackTaps; i++) 
        {
        total += feedback[feedbackTaps-i-1] * getOutput(channel,index-i-1);
        //printf("    feedback total now is %f\n",total);
        }

    //getchar();
    return total;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x66da(%rip), %eax      # 0x8170
jge 0x1aeb
movl 0x66d2(%rip), %eax      # 0x8170
subl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x66e2(%rip), %rax      # 0x8190
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
subl -0xc(%rbp), %esi
callq 0x1b60
movaps %xmm0, %xmm2
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a8d
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x6679(%rip), %eax      # 0x8174
jge 0x1b53
movl 0x6671(%rip), %eax      # 0x8174
subl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x867d(%rip), %rax      # 0xa190
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
subl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x1bb0
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1af2
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop