LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: ksw_gen_ts_mat
static void ksw_gen_ts_mat(int m, int8_t *mat, int8_t a, int8_t b, int8_t transition, int8_t sc_ambi)
{
	assert(m == 5);
	ksw_gen_simple_mat(m, mat, a, b, sc_ambi);
	if (transition == 0 || transition == b) return;
	transition = transition > 0? -transition : transition;
	mat[0 * m + 2] = transition;  // A->G
	mat[1 * m + 3] = transition;  // C->T
	mat[2 * m + 0] = transition;  // G->A
	mat[3 * m + 1] = transition;  // T->C
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %r8d, -0x2c(%rbp)
movl %ecx, %eax
movl -0x2c(%rbp), %ecx
movl %eax, -0x28(%rbp)
movl %edx, %eax
movl -0x28(%rbp), %edx
movl %eax, -0x24(%rbp)
movq %rsi, %rax
movl -0x24(%rbp), %esi
movq %rax, -0x20(%rbp)
movl %edi, %r8d
movq -0x20(%rbp), %rdi
movb %r9b, %al
movl %r8d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movb %dl, -0x12(%rbp)
movb %cl, -0x13(%rbp)
movb %al, -0x14(%rbp)
cmpl $0x5, -0x4(%rbp)
jne 0x2615d
jmp 0x2617c
leaq 0x32157(%rip), %rdi     # 0x582bb
leaq 0x32044(%rip), %rsi     # 0x581af
movl $0x1c, %edx
leaq 0x3214b(%rip), %rcx     # 0x582c2
callq 0x21a0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %cl
movb -0x12(%rbp), %al
movsbl %cl, %edx
movsbl %al, %ecx
movsbl -0x14(%rbp), %r8d
callq 0x28940
movsbl -0x13(%rbp), %eax
cmpl $0x0, %eax
je 0x261ae
movsbl -0x13(%rbp), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x261b0
jmp 0x26226
movsbl -0x13(%rbp), %eax
cmpl $0x0, %eax
jle 0x261c6
movsbl -0x13(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x30(%rbp)
jmp 0x261cd
movsbl -0x13(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
imull $0x0, -0x4(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shll $0x0, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shll %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
imull $0x3, -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: mm_adjust_minier
static inline void mm_adjust_minier(const mm_idx_t *mi, uint8_t *const qseq0[2], mm128_t *a, int32_t *r, int32_t *q)
{
	if (mi->flag & MM_I_HPC) {
		const uint8_t *qseq = qseq0[a->x>>63];
		int i, c;
		*q = (int32_t)a->y;
		for (i = *q - 1, c = qseq[*q]; i > 0; --i)
			if (qseq[i] != c) break;
		*q = i + 1;
		c = mm_get_hplen_back(mi, a->x<<1>>33, (int32_t)a->x);
		*r = (int32_t)a->x + 1 - c;
	} else {
		*r = (int32_t)a->x - (mi->k>>1);
		*q = (int32_t)a->y - (mi->k>>1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x27202
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x3f, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x271ba
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x38(%rbp), %eax
je 0x271ad
jmp 0x271ba
jmp 0x271af
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x27194
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shlq %rax
shrq $0x21, %rax
movl %eax, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
callq 0x28ed0
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
addl $0x1, %ecx
subl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x27237
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
sarl %eax
subl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
sarl %eax
subl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: mm_append_cigar
static void mm_append_cigar(mm_reg1_t *r, uint32_t n_cigar, const uint32_t *cigar)
{
	mm_extra_t *p;
	if (n_cigar == 0) return;
	mm_enlarge_cigar(r, n_cigar);
	p = r->p;
	if (p->n_cigar > 0 && (p->cigar[p->n_cigar-1]&0xf) == (cigar[0]&0xf)) { // same CIGAR op at the boundary
		p->cigar[p->n_cigar-1] += cigar[0]>>4<<4;
		if (n_cigar > 1) memcpy(p->cigar + p->n_cigar, cigar + 1, (n_cigar - 1) * 4);
		p->n_cigar += n_cigar - 1;
	} else {
		memcpy(p->cigar + p->n_cigar, cigar, n_cigar * 4);
		p->n_cigar += n_cigar;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2789e
jmp 0x2798a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x22560
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jbe 0x27954
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl 0x1c(%rax,%rcx,4), %eax
andl $0xf, %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
jne 0x27954
movq -0x18(%rbp), %rax
movl (%rax), %edx
shrl $0x4, %edx
shll $0x4, %edx
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
addl 0x1c(%rax,%rcx,4), %edx
movl %edx, 0x1c(%rax,%rcx,4)
cmpl $0x1, -0xc(%rbp)
jbe 0x27942
movq -0x20(%rbp), %rdi
addq $0x1c, %rdi
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
movl -0xc(%rbp), %eax
subl $0x1, %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2290
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
jmp 0x2798a
movq -0x20(%rbp), %rdi
addq $0x1c, %rdi
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2290
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: ksw_gen_simple_mat
static void ksw_gen_simple_mat(int m, int8_t *mat, int8_t a, int8_t b, int8_t sc_ambi)
{
	int i, j;
	a = a < 0? -a : a;
	b = b > 0? -b : b;
	sc_ambi = sc_ambi > 0? -sc_ambi : sc_ambi;
	for (i = 0; i < m - 1; ++i) {
		for (j = 0; j < m - 1; ++j)
			mat[i * m + j] = i == j? a : b;
		mat[i * m + m - 1] = sc_ambi;
	}
	for (j = 0; j < m; ++j)
		mat[(m - 1) * m + j] = sc_ambi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %cl, -0x12(%rbp)
movb %al, -0x13(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jge 0x2896d
movsbl -0x11(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
jmp 0x28974
movsbl -0x11(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0x11(%rbp)
movsbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jle 0x28990
movsbl -0x12(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x28997
movsbl -0x12(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, -0x12(%rbp)
movsbl -0x13(%rbp), %eax
cmpl $0x0, %eax
jle 0x289b3
movsbl -0x13(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0x289ba
movsbl -0x13(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, -0x13(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x28a4c
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x28a24
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x289f9
movsbl -0x11(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x28a00
movsbl -0x12(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x289db
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x289c7
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x28a80
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
imull -0x4(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x28a53
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: mm_get_hplen_back
static inline int mm_get_hplen_back(const mm_idx_t *mi, uint32_t rid, uint32_t x)
{
	int64_t i, off0 = mi->seq[rid].offset, off = off0 + x;
	int c = mm_seq4_get(mi->S, off);
	for (i = off - 1; i >= off0; --i)
		if (mm_seq4_get(mi->S, i) != c) break;
	return (int)(off - i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
sarq $0x3, %rcx
movl (%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
andq $0x7, %rcx
shlq $0x2, %rcx
shrl %cl, %eax
andl $0xf, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x28f7e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
sarq $0x3, %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
andq $0x7, %rcx
shlq $0x2, %rcx
shrl %cl, %eax
andl $0xf, %eax
cmpl -0x2c(%rbp), %eax
je 0x28f6e
jmp 0x28f7e
jmp 0x28f70
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x28f39
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/align.c
// Function: update_max_zdrop
static inline void update_max_zdrop(int32_t score, int i, int j, int32_t *max, int *max_i, int *max_j, int e, int *max_zdrop, int pos[2][2])
{
	if (score < *max) {
		int li = i - *max_i;
		int lj = j - *max_j;
		int diff = li > lj? li - lj : lj - li;
		int z = *max - score - diff * e;
		if (z > *max_zdrop) {
			*max_zdrop = z;
			pos[0][0] = *max_i, pos[0][1] = i;
			pos[1][0] = *max_j, pos[1][1] = j;
		}
	} else *max = score, *max_i = i, *max_j = j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x4(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x29055
movl -0x8(%rbp), %eax
movq -0x20(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x28fee
movl -0x2c(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x28ff7
movl -0x30(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl -0x4(%rbp), %eax
movl -0x34(%rbp), %ecx
imull 0x10(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq 0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x29053
movl -0x38(%rbp), %ecx
movq 0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x29070
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/hit.c
// Function: mm_mark_alt
void mm_mark_alt(const mm_idx_t *mi, int n, mm_reg1_t *r)
{
	int i;
	if (mi->n_alt == 0) return;
	for (i = 0; i < n; ++i)
		if (mi->seq[r[i].rid].is_alt)
			r[i].is_alt = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x2a19b
jmp 0x2a200
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2a200
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
movslq 0x8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x14(%rax)
je 0x2a1f3
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x3c(%rax), %ecx
andl $0xfdffffff, %ecx       # imm = 0xFDFFFFFF
orl $0x2000000, %ecx        # imm = 0x2000000
movl %ecx, 0x3c(%rax)
jmp 0x2a1f5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a1a2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/hit.c
// Function: mm_split_reg
void mm_split_reg(mm_reg1_t *r, mm_reg1_t *r2, int n, int qlen, mm128_t *a, int is_qstrand)
{
	if (n <= 0 || n >= r->cnt) return;
	*r2 = *r;
	r2->id = -1;
	r2->sam_pri = 0;
	r2->p = 0;
	r2->split_inv = 0;
	r2->cnt = r->cnt - n;
	r2->score = (int32_t)(r->score * ((float)r2->cnt / r->cnt) + .499);
	r2->as = r->as + n;
	if (r->parent == r->id) r2->parent = MM_PARENT_TMP_PRI;
	mm_reg_set_coor(r2, qlen, a, is_qstrand);
	r->cnt -= r2->cnt;
	r->score -= r2->score;
	mm_reg_set_coor(r, qlen, a, is_qstrand);
	r->split |= 1, r2->split |= 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x2a240
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x2a245
jmp 0x2a3a1
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x2290
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
orl $0x0, %ecx
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
andl $0xfeffffff, %ecx       # imm = 0xFEFFFFFF
orl $0x0, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cvtsi2ssl 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
cvtsi2ssl 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
cvtsi2ssl 0x4(%rax), %xmm2
divss %xmm2, %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2ad45(%rip), %xmm1    # 0x55018
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
addl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x2a30d
movq -0x10(%rbp), %rax
movl $0xfffffffe, 0x20(%rax) # imm = 0xFFFFFFFE
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x29fa0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x29fa0
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %edx
shrl $0x8, %edx
andl $0x3, %edx
orl $0x1, %edx
movl 0x3c(%rax), %ecx
andl $0x3, %edx
shll $0x8, %edx
andl $0xfffffcff, %ecx       # imm = 0xFFFFFCFF
orl %edx, %ecx
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %edx
shrl $0x8, %edx
andl $0x3, %edx
orl $0x2, %edx
movl 0x3c(%rax), %ecx
andl $0x3, %edx
shll $0x8, %edx
andl $0xfffffcff, %ecx       # imm = 0xFFFFFCFF
orl %edx, %ecx
movl %ecx, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/hit.c
// Function: mm_set_sam_pri
int mm_set_sam_pri(int n, mm_reg1_t *r)
{
	int i, n_pri = 0;
	for (i = 0; i < n; ++i)
		if (r[i].id == r[i].parent) {
			++n_pri;
			r[i].sam_pri = (n_pri == 1);
		} else r[i].sam_pri = 0;
	return n_pri;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2ae52
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x20(%rcx), %eax
jne 0x2ae24
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x3c(%rax), %ecx
andl $0x1, %edx
shll $0xc, %edx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
orl %edx, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x2ae42
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x3c(%rax), %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
orl $0x0, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x2ae44
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2adb9
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/hit.c
// Function: mm_filter_strand_retained
int mm_filter_strand_retained(int n_regs, mm_reg1_t *r)
{
	int i, k;
	for (i = k = 0; i < n_regs; ++i) {
		int p = r[i].parent;
		if (!r[i].strand_retained || r[i].div < r[p].div * 5.0f || r[i].div < 0.01f) {
			if (k < i) r[k++] = r[i];
			else ++k;
		}
	}
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2b4d3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl 0x3c(%rax), %eax
shrl $0x1a, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2b47d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movss 0x44(%rax), %xmm1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movss 0x2b3d6(%rip), %xmm0    # 0x5682c
mulss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
ja 0x2b47d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movss 0x2b3ad(%rip), %xmm0    # 0x56824
ucomiss 0x44(%rax), %xmm0
jbe 0x2b4c3
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2b4b8
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
cltq
imulq $0x50, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rsi
movl $0x50, %edx
callq 0x2290
jmp 0x2b4c1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b4c3
jmp 0x2b4c5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b3ed
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/hit.c
// Function: mm_filter_regs
void mm_filter_regs(const mm_mapopt_t *opt, int qlen, int *n_regs, mm_reg1_t *regs)
{ // NB: after this call, mm_reg1_t::parent can be -1 if its parent filtered out
	int i, k;
	for (i = k = 0; i < *n_regs; ++i) {
		mm_reg1_t *r = &regs[i];
		int flt = 0;
		if (!r->inv && !r->seg_split && r->cnt < opt->min_cnt) flt = 1;
		if (r->p) { // these filters are only applied when base-alignment is available
			if (r->mlen < opt->min_chain_score) flt = 1;
			else if (r->p->dp_max < opt->min_dp_max) flt = 1;
			else if (r->qs > qlen * opt->max_clip_ratio && qlen - r->qe > qlen * opt->max_clip_ratio) flt = 1;
			if (flt) free(r->p);
		}
		if (!flt) {
			if (k < i) regs[k++] = regs[i];
			else ++k;
		}
	}
	*n_regs = k;
}

// 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)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2b670
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl 0x3c(%rax), %eax
shrl $0xb, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2b569
movq -0x30(%rbp), %rax
movl 0x3c(%rax), %eax
shrl $0xf, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2b569
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x2b569
movl $0x1, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2b614
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jge 0x2b591
movl $0x1, -0x34(%rbp)
jmp 0x2b5ff
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x9c(%rcx), %eax
jge 0x2b5b1
movl $0x1, -0x34(%rbp)
jmp 0x2b5fd
movq -0x30(%rbp), %rax
cvtsi2ssl 0x10(%rax), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
mulss 0xac(%rax), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2b5fb
movl -0xc(%rbp), %eax
movq -0x30(%rbp), %rcx
subl 0x14(%rcx), %eax
cvtsi2ss %eax, %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
mulss 0xac(%rax), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2b5fb
movl $0x1, -0x34(%rbp)
jmp 0x2b5fd
jmp 0x2b5ff
cmpl $0x0, -0x34(%rbp)
je 0x2b612
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2040
jmp 0x2b614
cmpl $0x0, -0x34(%rbp)
jne 0x2b660
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2b655
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x28(%rbp)
cltq
imulq $0x50, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rsi
movl $0x50, %edx
callq 0x2290
jmp 0x2b65e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2b660
jmp 0x2b662
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b505
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/hit.c
// Function: mm_squeeze_a
int mm_squeeze_a(void *km, int n_regs, mm_reg1_t *regs, mm128_t *a)
{ // squeeze out regions in a[] that are not referenced by regs[]
	int i, as = 0;
	uint64_t *aux;
	aux = (uint64_t*)kmalloc(km, n_regs * 8);
	for (i = 0; i < n_regs; ++i)
		aux[i] = (uint64_t)regs[i].as << 32 | i;
	radix_sort_64(aux, aux + n_regs);
	for (i = 0; i < n_regs; ++i) {
		mm_reg1_t *r = &regs[(int32_t)aux[i]];
		if (r->as != as) {
			memmove(&a[as], &a[r->as], r->cnt * 16);
			r->as = as;
		}
		as += r->cnt;
	}
	kfree(km, aux);
	return as;
}

// 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)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x3, %eax
movslq %eax, %rsi
callq 0x1aae0
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2b6f8
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq 0x28(%rax), %rdx
shlq $0x20, %rdx
movslq -0x24(%rbp), %rax
orq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b6bb
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x5f90
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2b7a6
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq %ecx, %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x28(%rbp), %eax
je 0x2b78b
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rax
movslq 0x28(%rax), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
shll $0x4, %eax
movslq %eax, %rdx
callq 0x2330
movl -0x28(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b717
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1a8c0
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/hit.c
// Function: mm_cal_fuzzy_len
static inline void mm_cal_fuzzy_len(mm_reg1_t *r, const mm128_t *a)
{
	int i;
	r->mlen = r->blen = 0;
	if (r->cnt <= 0) return;
	r->mlen = r->blen = a[r->as].y>>32&0xff;
	for (i = r->as + 1; i < r->as + r->cnt; ++i) {
		int span = a[i].y>>32&0xff;
		int tl = (int32_t)a[i].x - (int32_t)a[i-1].x;
		int ql = (int32_t)a[i].y - (int32_t)a[i-1].y;
		r->blen += tl > ql? tl : ql;
		r->mlen += tl > span && ql > span? span : tl < ql? tl : ql;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jg 0x2c701
jmp 0x2c848
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x28(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xff, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x28(%rcx), %ecx
movq -0x8(%rbp), %rdx
addl 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0x2c848
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xff, %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x2c7e6
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2c7ec
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x2c811
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x2c811
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x2c82d
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2c821
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2c827
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c73f
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/jump.c
// Function: mm_jump_check
static int32_t mm_jump_check(void *km, const mm_idx_t *mi, int32_t qlen, const uint8_t *qseq0, const mm_reg1_t *r, int32_t ext, int32_t is_left) // TODO: check close N
{
	int32_t clip, clen, e = !r->rev ^ !is_left; // 0 for left of the alignment; 1 for right
	uint32_t cigar;
	if (!r->p || r->p->n_cigar <= 0) return -1; // only working with CIGAR
	clip = e == 0? r->qs : qlen - r->qe;
	cigar = r->p->cigar[is_left? 0 : r->p->n_cigar - 1];
	clen = (cigar&0xf) == MM_CIGAR_MATCH? cigar>>4 : 0;
	if (clen <= ext) return -1;
	if (is_left) {
		if (clip >= r->rs) return -1; // no space to jump
	} else {
		if (clip >= mi->seq[r->rid].len - r->re) return -1; // no space to jump
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl 0x3c(%rax), %eax
shrl $0xa, %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, 0x10(%rbp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2e606
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x18(%rax)
ja 0x2e612
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e6ff
cmpl $0x0, -0x40(%rbp)
jne 0x2e624
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x48(%rbp)
jmp 0x2e631
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
addq $0x1c, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0x2e654
xorl %eax, %eax
movl %eax, -0x54(%rbp)
jmp 0x2e665
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rax
movl -0x54(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x2e68a
movl -0x44(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x58(%rbp)
jmp 0x2e691
xorl %eax, %eax
movl %eax, -0x58(%rbp)
jmp 0x2e691
movl -0x58(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jg 0x2e6a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e6ff
cmpl $0x0, 0x10(%rbp)
je 0x2e6c5
movl -0x38(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x2e6c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e6ff
jmp 0x2e6f8
movl -0x38(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x30(%rbp), %rdx
movslq 0x8(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl 0x10(%rcx), %ecx
movq -0x30(%rbp), %rdx
subl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jb 0x2e6f6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e6ff
jmp 0x2e6f8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/ksw2_dispatch.c
// Function: ksw_extz2_sse
void ksw_extz2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat, int8_t q, int8_t e, int w, int zdrop, int end_bonus, int flag, ksw_extz_t *ez)
{
	extern void ksw_extz2_sse2(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat, int8_t q, int8_t e, int w, int zdrop, int end_bonus, int flag, ksw_extz_t *ez);
	extern void ksw_extz2_sse41(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat, int8_t q, int8_t e, int w, int zdrop, int end_bonus, int flag, ksw_extz_t *ez);
	if (ksw_simd < 0) ksw_simd = x86_simd();
	if (ksw_simd & SIMD_SSE4_1)
		ksw_extz2_sse41(km, qlen, query, tlen, target, m, mat, q, e, w, zdrop, end_bonus, flag, ez);
	else if (ksw_simd & SIMD_SSE2)
		ksw_extz2_sse2(km, qlen, query, tlen, target, m, mat, q, e, w, zdrop, end_bonus, flag, ez);
	else abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movb %r9b, %al
movq 0x48(%rbp), %r9
movl 0x40(%rbp), %r9d
movl 0x38(%rbp), %r9d
movl 0x30(%rbp), %r9d
movl 0x28(%rbp), %r9d
movb 0x20(%rbp), %r9b
movb 0x18(%rbp), %r9b
movq 0x10(%rbp), %r9
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movq %rdx, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq %r8, -0x50(%rbp)
movb %al, -0x51(%rbp)
cmpl $0x0, 0x2f180(%rip)     # 0x5e920
jge 0x2f7ad
callq 0x2f8c0
movl %eax, 0x2f173(%rip)     # 0x5e920
movl 0x2f16d(%rip), %eax     # 0x5e920
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2f82c
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdx
movl -0x44(%rbp), %ecx
movq -0x50(%rbp), %r8
movb -0x51(%rbp), %r9b
movq 0x10(%rbp), %r13
movb 0x18(%rbp), %r12b
movb 0x20(%rbp), %r15b
movl 0x28(%rbp), %r14d
movl 0x30(%rbp), %ebx
movl 0x38(%rbp), %r11d
movl 0x40(%rbp), %r10d
movq 0x48(%rbp), %rax
movsbl %r9b, %r9d
movq %r13, (%rsp)
movsbl %r12b, %r12d
movl %r12d, 0x8(%rsp)
movsbl %r15b, %r15d
movl %r15d, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movl %ebx, 0x20(%rsp)
movl %r11d, 0x28(%rsp)
movl %r10d, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x2fe20
jmp 0x2f8af
movl 0x2f0ee(%rip), %eax     # 0x5e920
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2f8a8
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdx
movl -0x44(%rbp), %ecx
movq -0x50(%rbp), %r8
movb -0x51(%rbp), %r9b
movq 0x10(%rbp), %r13
movb 0x18(%rbp), %r12b
movb 0x20(%rbp), %r15b
movl 0x28(%rbp), %r14d
movl 0x30(%rbp), %ebx
movl 0x38(%rbp), %r11d
movl 0x40(%rbp), %r10d
movq 0x48(%rbp), %rax
movsbl %r9b, %r9d
movq %r13, (%rsp)
movsbl %r12b, %r12d
movl %r12d, 0x8(%rsp)
movsbl %r15b, %r15d
movl %r15d, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movl %ebx, 0x20(%rsp)
movl %r11d, 0x28(%rsp)
movl %r10d, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x415b0
jmp 0x2f8ad
callq 0x2050
jmp 0x2f8af
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap2/ksw2_dispatch.c
// Function: x86_simd
static int x86_simd(void)
{
	int flag = 0, cpuid[4], max_id;
	__cpuidex(cpuid, 0, 0);
	max_id = cpuid[0];
	if (max_id == 0) return 0;
	__cpuidex(cpuid, 1, 0);
	if (cpuid[3]>>25&1) flag |= SIMD_SSE;
	if (cpuid[3]>>26&1) flag |= SIMD_SSE2;
	if (cpuid[2]>>0 &1) flag |= SIMD_SSE3;
	if (cpuid[2]>>9 &1) flag |= SIMD_SSSE3;
	if (cpuid[2]>>19&1) flag |= SIMD_SSE4_1;
	if (cpuid[2]>>20&1) flag |= SIMD_SSE4_2;
	if (cpuid[2]>>28&1) flag |= SIMD_AVX;
	if (max_id >= 7) {
		__cpuidex(cpuid, 7, 0);
		if (cpuid[1]>>5 &1) flag |= SIMD_AVX2;
		if (cpuid[1]>>16&1) flag |= SIMD_AVX512F;
	}
	return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2f700
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2f8f4
movl $0x0, -0x4(%rbp)
jmp 0x2f9f5
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2f700
movl -0x14(%rbp), %eax
sarl $0x19, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f91b
movl -0x8(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
sarl $0x1a, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f932
movl -0x8(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x18(%rbp), %eax
sarl $0x0, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f949
movl -0x8(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x18(%rbp), %eax
sarl $0x9, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f960
movl -0x8(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x18(%rbp), %eax
sarl $0x13, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f977
movl -0x8(%rbp), %eax
orl $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x18(%rbp), %eax
sarl $0x14, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f98e
movl -0x8(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x8(%rbp)
movl -0x18(%rbp), %eax
sarl $0x1c, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f9a5
movl -0x8(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x8(%rbp)
cmpl $0x7, -0x24(%rbp)
jl 0x2f9ef
leaq -0x20(%rbp), %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0x2f700
movl -0x1c(%rbp), %eax
sarl $0x5, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f9d4
movl -0x8(%rbp), %eax
orl $0x80, %eax
movl %eax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x10, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2f9ed
movl -0x8(%rbp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x8(%rbp)
jmp 0x2f9ef
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server.c
// Function: loadCertificate
static UA_ByteString loadCertificate(void) {
	UA_ByteString certificate = UA_STRING_NULL;
	FILE *fp = NULL;
	if(!(fp=fopen("server_cert.der", "rb"))) {
        errno = 0; // we read errno also from the tcp layer...
        return certificate;
    }

    fseek(fp, 0, SEEK_END);
    certificate.length = (size_t)ftell(fp);
    certificate.data = malloc(certificate.length*sizeof(UA_Byte));
	if(!certificate.data){
		fclose(fp);
		return certificate;
	}

    fseek(fp, 0, SEEK_SET);
    if(fread(certificate.data, sizeof(UA_Byte), certificate.length, fp) < (size_t)certificate.length)
        UA_ByteString_deleteMembers(&certificate); // error reading the cert
    fclose(fp);

    return certificate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x2fe1(%rip), %rax      # 0x6fe0
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x118a(%rip), %rdi      # 0x51a7
leaq 0x1193(%rip), %rsi      # 0x51b7
callq 0x2210
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4040
callq 0x2050
movl $0x0, (%rax)
jmp 0x40bf
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21e0
movq -0x18(%rbp), %rdi
callq 0x2170
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
shlq $0x0, %rdi
callq 0x21a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4082
movq -0x18(%rbp), %rdi
callq 0x20b0
jmp 0x40bf
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2080
cmpq -0x10(%rbp), %rax
jae 0x40b6
leaq -0x10(%rbp), %rdi
callq 0x4980
movq -0x18(%rbp), %rdi
callq 0x20b0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server.c
// Function: readTimeData
static UA_StatusCode
readTimeData(void *handle, const UA_NodeId nodeId, UA_Boolean sourceTimeStamp,
             const UA_NumericRange *range, UA_DataValue *value) {
    if(range) {
        value->hasStatus = true;
        value->status = UA_STATUSCODE_BADINDEXRANGEINVALID;
        return UA_STATUSCODE_GOOD;
    }
	UA_DateTime currentTime = UA_DateTime_now();
    UA_Variant_setScalarCopy(&value->value, &currentTime, &UA_TYPES[UA_TYPES_DATETIME]);
	value->hasValue = true;
	if(sourceTimeStamp) {
		value->hasSourceTimestamp = true;
		value->sourceTimestamp = currentTime;
	}
	return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4115
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movl $0x80360000, 0x38(%rax) # imm = 0x80360000
movl $0x0, -0x4(%rbp)
jmp 0x4172
callq 0x21f0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
movq 0x2e9f(%rip), %rdx      # 0x6fd0
addq $0x1e0, %rdx            # imm = 0x1E0
callq 0x2150
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
testb $0x1, -0x11(%rbp)
je 0x416b
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server.c
// Function: readTemperature
static UA_StatusCode
readTemperature(void *handle, const UA_NodeId nodeId, UA_Boolean sourceTimeStamp,
                const UA_NumericRange *range, UA_DataValue *value) {
    if(range) {
        value->hasStatus = true;
        value->status = UA_STATUSCODE_BADINDEXRANGEINVALID;
        return UA_STATUSCODE_GOOD;
    }

	rewind(temperatureFile);
	fflush(temperatureFile);

	UA_Double currentTemperature;
	if(fscanf(temperatureFile, "%lf", &currentTemperature) != 1){
		UA_LOG_WARNING(logger, UA_LOGCATEGORY_USERLAND, "Can not parse temperature");
		exit(1);
	}

	currentTemperature /= 1000.0;

	value->sourceTimestamp = UA_DateTime_now();
	value->hasSourceTimestamp = true;
    UA_Variant_setScalarCopy(&value->value, &currentTemperature, &UA_TYPES[UA_TYPES_DOUBLE]);
	value->hasValue = true;
	return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x42f8
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movl $0x80360000, 0x38(%rax) # imm = 0x80360000
movl $0x0, -0x4(%rbp)
jmp 0x43c7
movq 0x2e59(%rip), %rdi      # 0x7158
callq 0x2100
movq 0x2e4d(%rip), %rdi      # 0x7158
callq 0x21b0
movq 0x2e41(%rip), %rdi      # 0x7158
leaq 0xe9c(%rip), %rsi       # 0x51ba
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x2070
cmpl $0x1, %eax
je 0x435f
jmp 0x4330
cmpq $0x0, 0x2e10(%rip)      # 0x7148
je 0x4353
movl $0x3, %edi
movl $0x5, %esi
leaq 0xe73(%rip), %rdx       # 0x51be
movb $0x0, %al
callq *0x2df5(%rip)           # 0x7148
jmp 0x4355
movl $0x1, %edi
callq 0x2230
movsd -0x30(%rbp), %xmm0
movsd 0xc9c(%rip), %xmm1      # 0x5008
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x21f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, (%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
movq 0x2c2a(%rip), %rdx      # 0x6fd0
addq $0x190, %rdx            # imm = 0x190
callq 0x2150
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server.c
// Function: readLedStatus
static UA_StatusCode
readLedStatus(void *handle, UA_NodeId nodeid, UA_Boolean sourceTimeStamp,
              const UA_NumericRange *range, UA_DataValue *value) {
    if(range)
        return UA_STATUSCODE_BADINDEXRANGEINVALID;

    value->hasValue = true;
    UA_StatusCode retval = UA_Variant_setScalarCopy(&value->value, &ledStatus,
                                                    &UA_TYPES[UA_TYPES_BOOLEAN]);

    if(retval != UA_STATUSCODE_GOOD)
        return retval;
  
    if(sourceTimeStamp) {
        value->sourceTimestamp = UA_DateTime_now();
        value->hasSourceTimestamp = true;
    }
    return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x43fc
movl $0x80360000, -0x4(%rbp) # imm = 0x80360000
jmp 0x4461
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2d57(%rip), %rsi      # 0x7170
movq 0x2bb0(%rip), %rdx      # 0x6fd0
callq 0x2150
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x4436
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4461
testb $0x1, -0x11(%rbp)
je 0x445a
callq 0x21f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rax
movb (%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server.c
// Function: writeLedStatus
static UA_StatusCode
writeLedStatus(void *handle, const UA_NodeId nodeid,
               const UA_Variant *data, const UA_NumericRange *range) {
    if(range)
        return UA_STATUSCODE_BADINDEXRANGEINVALID;

#ifdef UA_ENABLE_MULTITHREADING
	pthread_rwlock_wrlock(&writeLock);
#endif
	if(data->data)
		ledStatus = *(UA_Boolean*)data->data;

	if(triggerFile)
		fseek(triggerFile, 0, SEEK_SET);

	if(ledFile) {
		if(ledStatus == 1)
			fprintf(ledFile, "%s", "1");
		else
			fprintf(ledFile, "%s", "0");
		fflush(ledFile);
	}
#ifdef UA_ENABLE_MULTITHREADING
	pthread_rwlock_unlock(&writeLock);
#endif
	return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4497
movl $0x80360000, -0x4(%rbp) # imm = 0x80360000
jmp 0x4537
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x44b4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, 0x2cbc(%rip)       # 0x7170
cmpq $0x0, 0x2ca4(%rip)      # 0x7160
je 0x44d0
movq 0x2c9b(%rip), %rdi      # 0x7160
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21e0
cmpq $0x0, 0x2c90(%rip)      # 0x7168
je 0x4530
movb 0x2c90(%rip), %al       # 0x7170
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4508
movq 0x2c77(%rip), %rdi      # 0x7168
leaq 0xba0(%rip), %rsi       # 0x5098
leaq 0xba1(%rip), %rdx       # 0x50a0
movb $0x0, %al
callq 0x2160
jmp 0x4524
movq 0x2c59(%rip), %rdi      # 0x7168
leaq 0xb82(%rip), %rsi       # 0x5098
leaq 0xc78(%rip), %rdx       # 0x5195
movb $0x0, %al
callq 0x2160
movq 0x2c3d(%rip), %rdi      # 0x7168
callq 0x21b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/../include/ua_server.h
// Function: UA_Server_addObjectNode
static UA_INLINE UA_StatusCode
UA_Server_addObjectNode(UA_Server *server, const UA_NodeId requestedNewNodeId,
                        const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
                        const UA_QualifiedName browseName, const UA_NodeId typeDefinition,
                        const UA_ObjectAttributes attr,
                        UA_InstantiationCallback *instantiationCallback,
                        UA_NodeId *outNewNodeId) {
    return __UA_Server_addNode(server, UA_NODECLASS_OBJECT, requestedNewNodeId, parentNodeId,
                               referenceTypeId, browseName, typeDefinition,
                               (const UA_NodeAttributes*)&attr,
                               &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],
                               instantiationCallback, outNewNodeId); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rcx
leaq 0x88(%rbp), %rdx
leaq 0x70(%rbp), %rax
leaq 0x58(%rbp), %r10
leaq 0x40(%rbp), %r11
leaq 0x28(%rbp), %rbx
leaq 0x10(%rbp), %r14
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x1, %esi
movq 0x284e(%rip), %rcx      # 0x6fd0
addq $0x1018, %rcx           # imm = 0x1018
movq (%r14), %r15
movq %r15, (%rsp)
movq 0x8(%r14), %r15
movq %r15, 0x8(%rsp)
movq 0x10(%r14), %r14
movq %r14, 0x10(%rsp)
movq (%rbx), %r14
movq %r14, 0x18(%rsp)
movq 0x8(%rbx), %r14
movq %r14, 0x20(%rsp)
movq 0x10(%rbx), %rbx
movq %rbx, 0x28(%rsp)
movq (%r11), %rbx
movq %rbx, 0x30(%rsp)
movq 0x8(%r11), %rbx
movq %rbx, 0x38(%rsp)
movq 0x10(%r11), %r11
movq %r11, 0x40(%rsp)
movq (%r10), %r11
movq %r11, 0x48(%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x50(%rsp)
movq 0x10(%r10), %r10
movq %r10, 0x58(%rsp)
movq (%rax), %r10
movq %r10, 0x60(%rsp)
movq 0x8(%rax), %r10
movq %r10, 0x68(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x70(%rsp)
callq 0x21d0
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)