LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: mem_opt_init
mem_opt_t *mem_opt_init()
{
	mem_opt_t *o;
	o = calloc(1, sizeof(mem_opt_t));
	o->outputStream = stdout;
	o->outputType = OUTPUT_TYPE_UNIPROT_FULL;
	o->flag = 0;
	o->a = 1; o->b = 3; //4;
	o->o_del = o->o_ins = 0; //6
	o->e_del = o->e_ins = 1;
	o->w = 100;
	o->T = 15;
	o->zdrop = 100;
	o->pen_unpaired = 17;
	o->pen_clip5 = o->pen_clip3 = 0;
	o->max_mem_intv = 20;
	o->min_orf_len = 250;
	o->min_orf_percent = 0;
	o->proteinFlag = 0;
	o->proteinFlag |= ALIGN_FLAG_BRUTE_ORF;
	o->proteinFlag |= ALIGN_FLAG_ADJUST_ORF;
	o->min_seed_len = 11;
	o->split_width = 10;
	o->max_occ = 500;
	o->max_chain_gap = 10000;
	o->max_ins = 10000;
	o->mask_level = 0.50;
	o->drop_ratio = 0.50;
	o->XA_drop_ratio = 0.8;
	o->split_factor = 1.5;
	o->chunk_size = 10000000;
	o->n_threads = 1;
	o->max_XA_hits = 5;
	o->max_XA_hits_alt = 200;
	o->max_matesw = 50;
	o->mask_level_redun = 0.95;
	o->min_chain_weight = 0;
	o->max_chain_extend = 1<<30;
	o->mapQ_coef_len = 50; o->mapQ_coef_fac = log(o->mapQ_coef_len);
	bwa_fill_scmat(o->a, o->b, o->mat);
	return o;
}

// Assembly:
pushq %rbx
leaq 0x12014(%rip), %rdx     # 0x23850
leaq 0x12016(%rip), %r8      # 0x23859
pushq $0x1
popq %rdi
pushq $0x35
popq %rcx
movl $0x2a8, %esi            # imm = 0x2A8
callq 0x1dfd0
movq %rax, %rbx
movq 0x1a74b(%rip), %rax     # 0x2bfa8
movq (%rax), %rax
movq %rax, 0x38(%rbx)
movaps 0x11f25(%rip), %xmm0    # 0x23790
movups %xmm0, 0x40(%rbx)
movaps 0x11f2a(%rip), %xmm0    # 0x237a0
movups %xmm0, (%rbx)
movl $0x64, 0x28(%rbx)
movabsq $0x6400000000, %rax     # imm = 0x6400000000
movq %rax, 0x20(%rbx)
movaps 0x11f1b(%rip), %xmm0    # 0x237b0
movups %xmm0, 0x10(%rbx)
movq $0x14, 0x30(%rbx)
movq $0xfa, 0x68(%rbx)
movl $0xb, 0x78(%rbx)
movl $0x3fc00000, 0x84(%rbx) # imm = 0x3FC00000
movl $0x989680, 0x98(%rbx)   # imm = 0x989680
movaps 0x11ef5(%rip), %xmm0    # 0x237c0
movups %xmm0, 0x88(%rbx)
movl $0xc8, 0xc0(%rbx)
movaps 0x11eed(%rip), %xmm0    # 0x237d0
movups %xmm0, 0x9c(%rbx)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x7c(%rbx)
movl $0x42480000, 0xac(%rbx) # imm = 0x42480000
movaps 0x11ed7(%rip), %xmm0    # 0x237e0
movups %xmm0, 0xb0(%rbx)
leaq 0xc4(%rbx), %rdx
pushq $0x1
popq %rdi
pushq $0x3
popq %rsi
callq 0x1050a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: filterCompetingAln
void filterCompetingAln(worker_t * passWorker, int passCount, int passDisable) {
	int seqIdx, alnIdx, bestIdx;
	int currentSeq, readSeq;
	int seqTotal, bestTotal;

	currentSeq = 0;
	bestIdx = 0;
	bestTotal = 0;

	// Iterate through each sequence and alignment
	for (seqIdx = 0 ; seqIdx < passCount - 1 ; seqIdx++) {
        // If filtering disabled, simply mark sequence as best
        if (passDisable) {
            passWorker->regs[seqIdx].active = 1;
            continue;
        }

		// Check if we're in a new sequence or in an alternate frame
		sscanf(passWorker->seqs[seqIdx].name, "%d:", &readSeq);
		if (readSeq != currentSeq) {
			// New sequence - mark best as active in previous sequence
			passWorker->regs[bestIdx].active = 1;

			// Reset search to current sequence
			currentSeq = readSeq;
			bestTotal = 0;
			bestIdx = seqIdx;
		}

        // Aggregate all score totals for this sequence
        seqTotal = 0;
        for (alnIdx = 0 ; alnIdx < passWorker->regs[seqIdx].n ; alnIdx++) {
            seqTotal += passWorker->regs[seqIdx].a[alnIdx].score;
        }

		// Check if current alignment is best so far
		if (seqTotal > bestTotal) {
			bestTotal = seqTotal;
			bestIdx = seqIdx;
		}
	}

	// Filter final sequence
    if (!passDisable) passWorker->regs[bestIdx].active = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
pushq $0x1
popq %r12
cmovgel %esi, %r12d
decl %r12d
xorl %r14d, %r14d
xorl %r13d, %r13d
movl $0x0, 0xc(%rsp)
xorl %r15d, %r15d
movl %edx, 0x14(%rsp)
movslq %r13d, %rbp
cmpq %r12, %r14
je 0x11a06
testl %edx, %edx
je 0x11980
movq 0x38(%rbx), %rax
movq %r14, %rcx
shlq $0x5, %rcx
movl $0x1, 0x10(%rax,%rcx)
jmp 0x119fe
movq 0x30(%rbx), %rax
imulq $0x30, %r14, %rcx
movq 0x8(%rax,%rcx), %rdi
leaq 0x11ed2(%rip), %rsi     # 0x23866
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x32e0
movq 0x38(%rbx), %rax
movl 0xc(%rsp), %ecx
cmpl %ecx, 0x10(%rsp)
je 0x119c8
shlq $0x5, %rbp
movl $0x1, 0x10(%rax,%rbp)
movl 0x10(%rsp), %ecx
movl %ecx, 0xc(%rsp)
xorl %r15d, %r15d
movl %r14d, %r13d
movq %r14, %rdx
shlq $0x5, %rdx
leaq (%rax,%rdx), %rcx
movq (%rax,%rdx), %rdx
xorl %eax, %eax
pushq $0x1c
popq %rsi
subq $0x1, %rdx
jb 0x119ef
movq 0x18(%rcx), %rdi
addl (%rdi,%rsi), %eax
addq $0x60, %rsi
jmp 0x119dc
cmpl %r15d, %eax
cmovgl %r14d, %r13d
cmovgl %eax, %r15d
movl 0x14(%rsp), %edx
incq %r14
jmp 0x1195b
testl %edx, %edx
jne 0x11a1a
movq 0x38(%rbx), %rax
shlq $0x5, %rbp
movl $0x1, 0x10(%rax,%rbp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: getAlignmentType
int getAlignmentType(worker_t * passWorker, int passEntry, int passAlignment) {
	mem_alnreg_t * currentAlignment;

	currentAlignment = passWorker->regs[passEntry].a + passAlignment;

	if (currentAlignment->secondary < 0) {
		// Primary scores below threshold are not aligned
		if (currentAlignment->score < passWorker->opt->T) return MEM_ALIGN_NONE_PRIMARY;

		return MEM_ALIGN_PRIMARY;
	}
	else {
		// Secondary scores below threshold are not aligned
		if (currentAlignment->score < passWorker->opt->T) return MEM_ALIGN_NONE_SECONDARY;

		// Secondary alignments must also pass score ratio requirements
		if (currentAlignment->is_alt) return MEM_ALIGN_NONE_SECONDARY;
		if (currentAlignment->secondary < INT_MAX &&
			currentAlignment->score < passWorker->regs[passEntry].a[currentAlignment->secondary].score * passWorker->opt->drop_ratio) return MEM_ALIGN_NONE_SECONDARY;

		return MEM_ALIGN_SECONDARY;
	}
}

// Assembly:
movq (%rdi), %rcx
movq 0x38(%rdi), %rax
movslq %esi, %rsi
shlq $0x5, %rsi
movq 0x18(%rax,%rsi), %rsi
movslq %edx, %rax
imulq $0x60, %rax, %r8
movslq 0x3c(%rsi,%r8), %rdx
movl 0x1c(%rsi,%r8), %edi
movl 0x44(%rcx), %r9d
testq %rdx, %rdx
js 0x11a92
pushq $-0x2
popq %rax
cmpl %r9d, %edi
jl 0x11a91
addq %rsi, %r8
cmpl $0x3fffffff, 0x48(%r8)  # imm = 0x3FFFFFFF
ja 0x11a91
cmpl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
je 0x11a8e
cvtsi2ss %edi, %xmm0
imulq $0x60, %rdx, %rdx
cvtsi2ssl 0x1c(%rsi,%rdx), %xmm1
mulss 0xa0(%rcx), %xmm1
ucomiss %xmm0, %xmm1
ja 0x11a91
pushq $0x1
popq %rax
retq
xorl %eax, %eax
cmpl %r9d, %edi
setl %al
negl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: mem_chain_weight
int mem_chain_weight(const mem_chain_t *c)
{
	int64_t end;
	int j, w = 0, tmp;
	for (j = 0, end = 0; j < c->n; ++j) {
		const mem_seed_t *s = &c->seeds[j];
		if (s->qbeg >= end) w += s->len;
		else if (s->qbeg + s->len > end) w += s->qbeg + s->len - end;
		end = end > s->qbeg + s->len? end : s->qbeg + s->len;
	}
	tmp = w; w = 0;
	for (j = 0, end = 0; j < c->n; ++j) {
		const mem_seed_t *s = &c->seeds[j];
		if (s->rbeg >= end) w += s->len;
		else if (s->rbeg + s->len > end) w += s->rbeg + s->len - end;
		end = end > s->rbeg + s->len? end : s->rbeg + s->len;
	}
	w = w < tmp? w : tmp;
	return w < 1<<30? w : (1<<30)-1;
}

// Assembly:
movl (%rdi), %eax
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
imulq $0x18, %rax, %rcx
xorl %eax, %eax
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x125d9
movq 0x20(%rdi), %r9
movslq 0x8(%r9,%rdx), %r8
movl 0xc(%r9,%rdx), %r9d
cmpq %r8, %rsi
jle 0x125c3
addl %r8d, %r9d
movslq %r9d, %r8
cmpq %r8, %rsi
jge 0x125cc
subl %esi, %eax
addl %r9d, %eax
jmp 0x125cc
addl %r9d, %eax
addl %r9d, %r8d
movslq %r8d, %r8
cmpq %r8, %rsi
cmovleq %r8, %rsi
addq $0x18, %rdx
jmp 0x12599
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rsi, %rcx
je 0x1261d
movq 0x20(%rdi), %r10
movq (%r10,%rsi), %r9
movslq 0xc(%r10,%rsi), %r10
cmpq %r8, %r9
jge 0x1260a
addq %r10, %r9
cmpq %r8, %r9
jle 0x12610
movl %r9d, %r10d
subl %r8d, %r10d
addl %r10d, %edx
jmp 0x12610
addl %r10d, %edx
addq %r10, %r9
cmpq %r9, %r8
cmovleq %r9, %r8
addq $0x18, %rsi
jmp 0x125e0
cmpl %eax, %edx
cmovll %edx, %eax
movl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
cmovgel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: mem_print_chain
void mem_print_chain(const bntseq_t *bns, mem_chain_v *chn)
{
	int i, j;
	for (i = 0; i < chn->n; ++i) {
		mem_chain_t *p = &chn->a[i];
		err_printf("* Found CHAIN(%d): n=%d; weight=%d", i, p->n, mem_chain_weight(p));
		for (j = 0; j < p->n; ++j) {
			bwtint_t pos;
			int is_rev;
			pos = bns_depos(bns, p->seeds[j].rbeg, &is_rev);
			if (is_rev) pos -= p->seeds[j].len - 1;
			err_printf("\t%d;%d;%d,%ld(%s:%c%ld)", p->seeds[j].score, p->seeds[j].len, p->seeds[j].qbeg, (long)p->seeds[j].rbeg, bns->anns[p->rid].name, "+-"[is_rev], (long)(pos - bns->anns[p->rid].offset) + 1);
		}
		err_putchar('\n');
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x11280(%rip), %r12     # 0x238c5
xorl %ebx, %ebx
movq %rsi, 0x8(%rsp)
cmpq %rbx, (%rsi)
jbe 0x12734
movq 0x10(%rsi), %rax
imulq $0x28, %rbx, %rcx
leaq (%rax,%rcx), %r15
movl (%rax,%rcx), %ebp
movq %r15, %rdi
callq 0x12588
leaq 0x1122f(%rip), %rdi     # 0x238a2
movq %rbx, 0x10(%rsp)
movl %ebx, %esi
movl %ebp, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0xcda0
pushq $0x10
popq %rbp
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x12710
movq 0x20(%r15), %rax
movq -0x10(%rax,%rbp), %r8
movq (%r14), %rcx
cmpq %r8, %rcx
jg 0x126bb
leaq (%rcx,%rcx), %rsi
movl -0x4(%rax,%rbp), %edx
subq %r8, %rsi
movl %edx, %edi
negl %edi
movslq %edi, %r10
addq %rsi, %r10
jmp 0x126c2
movl -0x4(%rax,%rbp), %edx
movq %r8, %r10
xorl %edi, %edi
cmpq %r8, %rcx
setle %dil
movl -0x8(%rax,%rbp), %ecx
movl (%rax,%rbp), %esi
movq 0x10(%r14), %rax
movslq 0xc(%r15), %r9
imulq $0x28, %r9, %r11
movq 0x18(%rax,%r11), %r9
leaq 0x111f3(%rip), %rbx     # 0x238dd
movsbl (%rdi,%rbx), %ebx
subq (%rax,%r11), %r10
incq %r10
movq %r12, %rdi
xorl %eax, %eax
pushq %r10
pushq %rbx
callq 0xcda0
popq %rcx
popq %rdx
incq %r13
addq $0x18, %rbp
jmp 0x1268b
movq 0x19891(%rip), %rax     # 0x2bfa8
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0xcf06
movq 0x10(%rsp), %rbx
incq %rbx
movq 0x8(%rsp), %rsi
jmp 0x1264c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: mem_seed_sw
int mem_seed_sw(const mem_opt_t *opt, const bntseq_t *bns, const uint8_t *pac, int l_query, const uint8_t *query, const mem_seed_t *s)
{
	int qb, qe, rid;
	int64_t rb, re, mid, l_pac = bns->l_pac;
	uint8_t *rseq = 0;
	kswr_t x;

	if (s->len >= MEM_SHORT_LEN) return -1; // the seed is longer than the max-extend; no need to do SW
	qb = s->qbeg, qe = s->qbeg + s->len;
	rb = s->rbeg, re = s->rbeg + s->len;
	mid = (rb + re) >> 1;
	qb -= MEM_SHORT_EXT; qb = qb > 0? qb : 0;
	qe += MEM_SHORT_EXT; qe = qe < l_query? qe : l_query;
	rb -= MEM_SHORT_EXT; rb = rb > 0? rb : 0;
	re += MEM_SHORT_EXT; re = re < l_pac<<1? re : l_pac<<1;
	if (rb < l_pac && l_pac < re) {
		if (mid < l_pac) re = l_pac;
		else rb = l_pac;
	}
	if (qe - qb >= MEM_SHORT_LEN || re - rb >= MEM_SHORT_LEN) return -1; // the seed seems good enough; no need to do SW

	rseq = bns_fetch_seq(bns, pac, &rb, mid, &re, &rid);
	x = ksw_align2(qe - qb, (uint8_t*)query + qb, re - rb, rseq, VALUE_DEFINED, opt->mat, opt->o_del, opt->e_del, opt->o_ins, opt->e_ins, KSW_XSTART, 0);
	free(rseq);
	return x.score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movslq 0xc(%r9), %r8
pushq $-0x1
popq %r15
cmpq $0xc7, %r8
jg 0x18184
movl %ecx, %ebp
movq %rdi, %r14
movq (%rsi), %rax
movl 0x8(%r9), %edi
movq (%r9), %r9
leaq (%r9,%r8), %rcx
addq %r9, %rcx
sarq %rcx
cmpl $0x33, %edi
pushq $0x32
popq %r13
cmovgel %edi, %r13d
addl $-0x32, %r13d
addl %r8d, %edi
addl $0x32, %edi
cmpl %ebp, %edi
cmovll %edi, %ebp
cmpq $0x33, %r9
pushq $0x32
popq %rdi
cmovgeq %r9, %rdi
addq $-0x32, %rdi
movq %rdi, 0x8(%rsp)
addq %r8, %r9
addq $0x32, %r9
leaq (%rax,%rax), %r8
cmpq %r8, %r9
cmovlq %r9, %r8
movq %r8, 0x10(%rsp)
cmpq %rax, %rdi
jge 0x180dd
cmpq %r8, %rax
jge 0x180dd
cmpq %rax, %rcx
jge 0x180d5
movq %rax, 0x10(%rsp)
jmp 0x180e0
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r8, %rax
subl %r13d, %ebp
cmpl $0xc7, %ebp
jg 0x18184
subq %rdi, %rax
cmpq $0xc7, %rax
jg 0x18184
leaq 0x8(%rsp), %rax
leaq 0x10(%rsp), %r15
leaq 0x18(%rsp), %r9
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movq %r15, %r8
callq 0xfb6d
movq %rax, %r12
movl %r13d, %eax
addq %rax, %rbx
movl (%r15), %ecx
leaq 0x8(%rsp), %rax
subl (%rax), %ecx
leaq 0xc4(%r14), %rax
movl 0x8(%r14), %r10d
movl 0xc(%r14), %r11d
movl 0x10(%r14), %r15d
movl 0x14(%r14), %r13d
subq $0x8, %rsp
leaq 0x24(%rsp), %r14
pushq $0x16
popq %r9
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r12, %r8
pushq $0x0
pushq $0x80000                # imm = 0x80000
pushq %r13
pushq %r15
pushq %r11
pushq %r10
pushq %rax
callq 0x1edb1
addq $0x40, %rsp
movl (%r14), %r15d
movq %r12, %rdi
callq 0x3390
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: mem_flt_chained_seeds
void mem_flt_chained_seeds(const mem_opt_t *opt, const bntseq_t *bns, const uint8_t *pac, int l_query, const uint8_t *query, int n_chn, mem_chain_t *a)
{
	double min_l = opt->min_chain_weight? MEM_HSP_COEF * opt->min_chain_weight : MEM_MINSC_COEF * log(l_query);
	int i, j, k, min_HSP_score = (int)(opt->a * min_l + .499);
	if (min_l > MEM_SEEDSW_COEF * l_query) return; // don't run the following for short reads
	for (i = 0; i < n_chn; ++i) {
		mem_chain_t *c = &a[i];
		for (j = k = 0; j < c->n; ++j) {
			mem_seed_t *s = &c->seeds[j];
			s->score = mem_seed_sw(opt, bns, pac, l_query, query, s);
			if (s->score < 0 || s->score >= min_HSP_score) {
				s->score = s->score < 0? s->len * opt->a : s->score;
				c->seeds[k++] = *s;
			}
		}
		c->n = k;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebx
movq %r8, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, 0x10(%rsp)
movl 0x7c(%rdi), %eax
testl %eax, %eax
movl %ecx, 0xc(%rsp)
je 0x181d8
cvtsi2ss %eax, %xmm0
mulss 0xb676(%rip), %xmm0     # 0x23848
cvtss2sd %xmm0, %xmm0
jmp 0x181ed
cvtsi2sd %ecx, %xmm0
callq 0x3250
movl 0xc(%rsp), %ecx
mulsd 0xb62b(%rip), %xmm0     # 0x23818
cvtsi2ss %ecx, %xmm1
mulss 0xb653(%rip), %xmm1     # 0x2384c
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x18212
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
cvtsi2sdl (%rax), %xmm1
mulsd %xmm0, %xmm1
addsd 0x8579(%rip), %xmm1     # 0x207a0
cvttsd2si %xmm1, %eax
movl %eax, 0x1c(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
movq %rbx, 0x20(%rsp)
cmpq 0x20(%rsp), %rax
je 0x18203
movq %rax, 0x28(%rsp)
imulq $0x28, %rax, %r14
addq 0x80(%rsp), %r14
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x182d9
movq 0x20(%r14), %r13
movq %r13, %rbx
addq %rbp, %rbx
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %r8
movq %rbx, %r9
callq 0x1803b
movl %eax, 0x10(%r13,%rbp)
testl %eax, %eax
js 0x18298
cmpl 0x1c(%rsp), %eax
jl 0x182cc
testl %eax, %eax
jns 0x182a9
movq 0x10(%rsp), %rax
movl (%rax), %eax
imull 0xc(%r13,%rbp), %eax
movl %eax, 0x10(%r13,%rbp)
movq 0x20(%r14), %rax
movslq %r15d, %rcx
incl %r15d
imulq $0x18, %rcx, %rcx
movq 0x10(%rbx), %rdx
movq %rdx, 0x10(%rax,%rcx)
movups (%rbx), %xmm0
movups %xmm0, (%rax,%rcx)
incq %r12
addq $0x18, %rbp
movl 0xc(%rsp), %ecx
jmp 0x1825b
movl %r15d, (%r14)
movq 0x28(%rsp), %rax
incq %rax
jmp 0x1823b
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: cal_max_gap
static inline int cal_max_gap(const mem_opt_t *opt, int qlen)
{
	int l_del = (int)((double)(qlen * opt->a - opt->o_del) / opt->e_del + 1.);
	int l_ins = (int)((double)(qlen * opt->a - opt->o_ins) / opt->e_ins + 1.);
	int l = l_del > l_ins? l_del : l_ins;
	l = l > 1? l : 1;
	return l < opt->w<<1? l : opt->w<<1;
}

// Assembly:
imull (%rdi), %esi
movl %esi, %eax
subl 0x8(%rdi), %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl 0xc(%rdi), %xmm1
divsd %xmm1, %xmm0
movsd 0xa3a5(%rip), %xmm1     # 0x234c8
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl 0x10(%rdi), %esi
cvtsi2sd %esi, %xmm0
cvtsi2sdl 0x14(%rdi), %xmm2
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
cmpl $0x2, %ecx
pushq $0x1
popq %rdx
cmovgel %ecx, %edx
movl 0x24(%rdi), %eax
addl %eax, %eax
cmpl %eax, %edx
cmovll %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/./kstring.h
// Function: kputl
static inline int kputl(long c, kstring_t *s)
{
	char buf[32];
	long l, x;
	if (c == 0) return kputc('0', s);
	for (l = 0, x = c < 0? -c : c; x > 0; x /= 10) buf[l++] = x%10 + '0';
	if (c < 0) buf[l++] = '-';
	if (s->l + l + 1 >= s->m) {
		s->m = s->l + l + 2;
		kroundup32(s->m);
		s->s = (char*)realloc(s->s, s->m);
	}
	for (x = l - 1; x >= 0; --x) s->s[s->l++] = buf[x];
	s->s[s->l] = 0;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x19f0a
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
xorl %r14d, %r14d
pushq $0xa
popq %rcx
testq %rax, %rax
je 0x19e65
xorl %edx, %edx
divq %rcx
orb $0x30, %dl
movb %dl, (%rsp,%r14)
incq %r14
jmp 0x19e4f
testq %rdi, %rdi
jns 0x19e72
movb $0x2d, (%rsp,%r14)
incq %r14
movq (%rbx), %rax
addq %r14, %rax
incq %rax
cmpq 0x8(%rbx), %rax
jb 0x19ef2
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq 0x98b0(%rip), %rdx      # 0x23774
leaq 0xa2bc(%rip), %r8       # 0x24187
pushq $0x6a
popq %rcx
callq 0x1e0b4
movq %rax, 0x10(%rbx)
jmp 0x19ef2
movb -0x1(%rsp,%r14), %al
decq %r14
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rbx)
movb %al, (%rdx,%rcx)
testq %r14, %r14
jg 0x19ed9
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx,%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x30
popq %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x19c9f
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: get_rlen
static inline int get_rlen(int n_cigar, const uint32_t *cigar)
{
	int k, l;
	for (k = l = 0; k < n_cigar; ++k) {
		int op = cigar[k]&0xf;
		if (op == 0 || op == 2)
			l += cigar[k]>>4;
	}
	return l;
}

// Assembly:
xorl %ecx, %ecx
testl %edi, %edi
cmovlel %ecx, %edi
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rdi
je 0x19f47
movl (%rsi,%rdx,4), %r8d
movl %r8d, %r9d
shrl $0x4, %r9d
testb $0xd, %r8b
cmovnel %ecx, %r9d
addl %r9d, %eax
incq %rdx
jmp 0x19f27
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: worker1
static void worker1(void *data, int i, int tid)
{
	worker_t *w = (worker_t*)data;
	if (!(w->opt->flag&MEM_F_PE)) {
		if (bwa_verbose >= 4) printf("=====> Processing read '%s' <=====\n", w->seqs[i].name);
		w->regs[i] = mem_align1_core(w->opt, w->bwt, w->bns, w->pac, w->seqs[i].l_seq, w->seqs[i].seq, w->aux[tid]);
	} else {
		if (bwa_verbose >= 4) printf("=====> Processing read '%s'/1 <=====\n", w->seqs[i<<1|0].name);
		w->regs[i<<1|0] = mem_align1_core(w->opt, w->bwt, w->bns, w->pac, w->seqs[i<<1|0].l_seq, w->seqs[i<<1|0].seq, w->aux[tid]);
		if (bwa_verbose >= 4) printf("=====> Processing read '%s'/2 <=====\n", w->seqs[i<<1|1].name);
		w->regs[i<<1|1] = mem_align1_core(w->opt, w->bwt, w->bns, w->pac, w->seqs[i<<1|1].l_seq, w->seqs[i<<1|1].seq, w->aux[tid]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rsi
testb $0x2, 0x48(%rsi)
leaq 0x11f3f(%rip), %rax     # 0x2ce40
movl (%rax), %eax
jne 0x1af2d
cmpl $0x3, %eax
jle 0x1af58
movq 0x30(%rbx), %rax
movslq %r14d, %r14
imulq $0x30, %r14, %rcx
movq 0x8(%rax,%rcx), %rsi
leaq 0x926c(%rip), %rdi      # 0x2418d
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rsi
jmp 0x1af5b
cmpl $0x3, %eax
jle 0x1af93
movq 0x30(%rbx), %rax
addl %r14d, %r14d
movslq %r14d, %r12
imulq $0x30, %r12, %rcx
movq 0x8(%rax,%rcx), %rsi
leaq 0x9265(%rip), %rdi      # 0x241b1
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rsi
jmp 0x1af99
movslq %r14d, %r14
movq 0x38(%rbx), %r15
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
movq 0x30(%rbx), %rax
imulq $0x30, %r14, %r10
shlq $0x5, %r14
movl (%rax,%r10), %r9d
movq 0x28(%rbx), %r11
movslq %ebp, %r12
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
pushq (%r11,%r12,8)
jmp 0x1b057
addl %r14d, %r14d
movslq %r14d, %r12
movq 0x38(%rbx), %r13
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
movq 0x30(%rbx), %rax
imulq $0x30, %r12, %r10
shlq $0x5, %r12
movl (%rax,%r10), %r9d
movq 0x28(%rbx), %r11
movslq %ebp, %rbp
leaq 0x8(%rsp), %r15
movq %r15, %rdi
pushq (%r11,%rbp,8)
pushq 0x18(%rax,%r10)
callq 0x1a9e2
popq %rax
popq %rcx
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%r13,%r12)
movups %xmm0, (%r13,%r12)
leaq 0x11e4c(%rip), %rax     # 0x2ce40
cmpl $0x3, (%rax)
jle 0x1b01d
movq 0x30(%rbx), %rax
orl $0x1, %r14d
movslq %r14d, %r14
imulq $0x30, %r14, %rcx
movq 0x8(%rax,%rcx), %rsi
leaq 0x91c3(%rip), %rdi      # 0x241d7
xorl %eax, %eax
callq 0x3060
jmp 0x1b024
orl $0x1, %r14d
movslq %r14d, %r14
movq 0x38(%rbx), %r15
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
movq 0x30(%rbx), %rax
imulq $0x30, %r14, %r10
shlq $0x5, %r14
movl (%rax,%r10), %r9d
movq 0x28(%rbx), %r11
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
pushq (%r11,%rbp,8)
pushq 0x18(%rax,%r10)
callq 0x1a9e2
popq %rax
popq %rcx
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%r15,%r14)
movups %xmm0, (%r15,%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: worker2
static void worker2(void *data, int i, int tid)
{
	extern int mem_sam_pe(const mem_opt_t *opt, const bntseq_t *bns, const uint8_t *pac, const mem_pestat_t pes[4], uint64_t id, bseq1_t s[2], mem_alnreg_v a[2]);
	extern void mem_reg2ovlp(const mem_opt_t *opt, const bntseq_t *bns, const uint8_t *pac, bseq1_t *s, mem_alnreg_v *a);
	worker_t *w = (worker_t*)data;
	if (!(w->opt->flag&MEM_F_PE)) {
		if (bwa_verbose >= 4) printf("=====> Finalizing read '%s' <=====\n", w->seqs[i].name);
		if (w->opt->flag & MEM_F_ALN_REG) {
			mem_reg2ovlp(w->opt, w->bns, w->pac, &w->seqs[i], &w->regs[i]);
		} else {
			mem_mark_primary_se(w->opt, w->regs[i].n, w->regs[i].a, w->n_processed + i);
			mem_reg2sam(w->opt, w->bns, w->pac, &w->seqs[i], &w->regs[i], 0, 0);
		}

		//free(w->regs[i].a);
	} else {
		if (bwa_verbose >= 4) printf("=====> Finalizing read pair '%s' <=====\n", w->seqs[i<<1|0].name);
		mem_sam_pe(w->opt, w->bns, w->pac, w->pes, (w->n_processed>>1) + i, &w->seqs[i<<1], &w->regs[i<<1]);
		free(w->regs[i<<1|0].a); free(w->regs[i<<1|1].a);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x48(%rdi), %eax
leaq 0x11da2(%rip), %rcx     # 0x2ce40
movl (%rcx), %ecx
testb $0x2, %al
jne 0x1b12e
cmpl $0x4, %ecx
jl 0x1b0d1
movq 0x30(%rbx), %rax
movslq %r14d, %rcx
imulq $0x30, %rcx, %rcx
movq 0x8(%rax,%rcx), %rsi
leaq 0x9139(%rip), %rdi      # 0x241fd
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rdi
movl 0x48(%rdi), %eax
testb %al, %al
js 0x1b15a
movq 0x38(%rbx), %rax
movslq %r14d, %r15
movq %r15, %r14
shlq $0x5, %r14
movl (%rax,%r14), %esi
movq 0x18(%rax,%r14), %rdx
movq 0x40(%rbx), %rcx
addq %r15, %rcx
callq 0x17c4f
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
imulq $0x30, %r15, %rcx
addq 0x30(%rbx), %rcx
addq 0x38(%rbx), %r14
andq $0x0, (%rsp)
movq %r14, %r8
xorl %r9d, %r9d
callq 0x1a112
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, %ecx
jle 0x1b184
movq 0x30(%rbx), %rax
leal (%r14,%r14), %ebp
movslq %ebp, %r15
imulq $0x30, %r15, %rcx
movq 0x8(%rax,%rcx), %rsi
leaq 0x90d3(%rip), %rdi      # 0x24221
xorl %eax, %eax
callq 0x3060
movq (%rbx), %rdi
jmp 0x1b18b
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movslq %r14d, %r8
imulq $0x30, %r8, %rcx
addq 0x30(%rbx), %rcx
shlq $0x5, %r8
addq 0x38(%rbx), %r8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d6ce
leal (%r14,%r14), %ebp
movslq %ebp, %r15
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %rcx
movq 0x40(%rbx), %rax
sarq %rax
movslq %r14d, %r8
imulq $0x30, %r15, %r9
addq 0x30(%rbx), %r9
addq %rax, %r8
shlq $0x5, %r15
movq 0x38(%rbx), %rax
addq %r15, %rax
movq %rax, (%rsp)
callq 0x1c742
movq 0x38(%rbx), %rax
movq 0x18(%rax,%r15), %rdi
callq 0x3390
movq 0x38(%rbx), %rax
orl $0x1, %ebp
movslq %ebp, %rcx
shlq $0x5, %rcx
movq 0x18(%rax,%rcx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3390
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem.c
// Function: _kb_getp_aux_chn
static int test_and_merge(const mem_opt_t *opt, int64_t l_pac, mem_chain_t *c, const mem_seed_t *p, int seed_rid)
{
	int64_t qend, rend, x, y;
	const mem_seed_t *last = &c->seeds[c->n-1];
	qend = last->qbeg + last->len;
	rend = last->rbeg + last->len;
	if (seed_rid != c->rid) return 0; // different chr; request a new chain
	if (p->qbeg >= c->seeds[0].qbeg && p->qbeg + p->len <= qend && p->rbeg >= c->seeds[0].rbeg && p->rbeg + p->len <= rend)
		return 1; // contained seed; do nothing
	if ((last->rbeg < l_pac || c->seeds[0].rbeg < l_pac) && p->rbeg >= l_pac) return 0; // don't chain if on different strand
	x = p->qbeg - last->qbeg; // always non-negtive
	y = p->rbeg - last->rbeg;
	if (y >= 0 && x - y <= opt->w && y - x <= opt->w && x - last->len < opt->max_chain_gap && y - last->len < opt->max_chain_gap) { // grow the chain
		if (c->n == c->m) {
			c->m <<= 1;
			c->seeds = realloc(c->seeds, c->m * sizeof(mem_seed_t));
		}
		c->seeds[c->n++] = *p;
		return 1;
	}
	return 0; // request to add a new chain
}

// Assembly:
movl (%rdi), %eax
cmpl $0x2, %eax
jae 0x1b276
pushq $-0x1
popq %rax
retq
sarl %eax
addq $0x4, %rdi
xorl %ecx, %ecx
movl %eax, %r8d
cmpl %r8d, %ecx
jge 0x1b2ac
leal (%r8,%rcx), %r9d
sarl %r9d
movslq %r9d, %r10
imulq $0x28, %r10, %r10
movq 0x18(%rdi,%r10), %r10
cmpq 0x18(%rsi), %r10
jl 0x1b2a4
movl %r9d, %r8d
jmp 0x1b281
incl %r9d
movl %r9d, %ecx
jmp 0x1b281
cmpl %eax, %ecx
jne 0x1b2be
testq %rdx, %rdx
je 0x1b2bb
movl $0x1, (%rdx)
decl %eax
retq
movslq %ecx, %rax
imulq $0x28, %rax, %rax
movq 0x18(%rdi,%rax), %rdi
movq 0x18(%rsi), %rsi
xorl %eax, %eax
xorl %r8d, %r8d
cmpq %rsi, %rdi
setl %al
setg %r8b
subl %r8d, %eax
testq %rdx, %rdx
je 0x1b2e7
movl %eax, (%rdx)
sarl $0x1f, %eax
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem_pair.c
// Function: cal_sub
static int cal_sub(const mem_opt_t *opt, mem_alnreg_v *r)
{
	int j;
	for (j = 1; j < r->n; ++j) { // choose unique alignment
		int b_max = r->a[j].qb > r->a[0].qb? r->a[j].qb : r->a[0].qb;
		int e_min = r->a[j].qe < r->a[0].qe? r->a[j].qe : r->a[0].qe;
		if (e_min > b_max) { // have overlap
			int min_l = r->a[j].qe - r->a[j].qb < r->a[0].qe - r->a[0].qb? r->a[j].qe - r->a[j].qb : r->a[0].qe - r->a[0].qb;
			if (e_min - b_max >= min_l * opt->mask_level) break; // significant overlap
		}
	}
	return j < r->n? r->a[j].score : opt->min_seed_len * opt->a;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rax
movabsq $0x1, %rdx
movabsq $0x7c, %rcx
cmpq %rdx, %rax
jbe 0x1bb34
movq 0x18(%rsi), %r8
movl -0xc(%r8,%rcx), %r11d
movl -0x8(%r8,%rcx), %r9d
movl 0x10(%r8), %ebx
movl 0x14(%r8), %r10d
cmpl %ebx, %r11d
movl %ebx, %r14d
cmovgl %r11d, %r14d
cmpl %r10d, %r9d
movl %r10d, %ebp
cmovll %r9d, %ebp
subl %r14d, %ebp
jle 0x1bb2b
subl %r11d, %r9d
subl %ebx, %r10d
cmpl %r10d, %r9d
cmovll %r9d, %r10d
cvtsi2ss %ebp, %xmm0
cvtsi2ss %r10d, %xmm1
mulss 0x9c(%rdi), %xmm1
ucomiss %xmm1, %xmm0
jae 0x1bb3c
incq %rdx
addq $0x60, %rcx
jmp 0x1bad4
movl (%rdi), %eax
imull 0x78(%rdi), %eax
jmp 0x1bb40
movl (%r8,%rcx), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem_pair.c
// Function: mem_infer_dir
static inline int mem_infer_dir(int64_t l_pac, int64_t b1, int64_t b2, int64_t *dist)
{
	int64_t p2;
	int r1 = (b1 >= l_pac), r2 = (b2 >= l_pac);
	p2 = r1 == r2? b2 : (l_pac<<1) - 1 - b2; // p2 is the coordinate of read 2 on the read 1 strand
	*dist = p2 > b1? p2 - b1 : b1 - p2;
	return (r1 == r2? 0 : 1) ^ (p2 > b1? 0 : 3);
}

// Assembly:
cmpq %rdi, %rsi
setge %al
cmpq %rdi, %rdx
setl %r8b
xorb %al, %r8b
movq %rdx, %rax
notq %rax
leaq (%rax,%rdi,2), %rax
cmovneq %rdx, %rax
xorl %edx, %edx
subq %rsi, %rax
setle %dl
leal (%rdx,%rdx,2), %edx
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
movq %rsi, (%rcx)
xorb $0x1, %r8b
movzbl %r8b, %eax
xorl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem_extra.c
// Function: smem_itr_init
smem_i *smem_itr_init(const bwt_t *bwt)
{
	smem_i *itr;
	itr = calloc(1, sizeof(smem_i));
	itr->bwt = bwt;
	itr->tmpvec[0] = calloc(1, sizeof(bwtintv_v));
	itr->tmpvec[1] = calloc(1, sizeof(bwtintv_v));
	itr->matches   = calloc(1, sizeof(bwtintv_v));
	itr->sub       = calloc(1, sizeof(bwtintv_v));
	itr->min_intv = 1;
	itr->max_len  = INT_MAX;
	itr->max_intv = 0;
	return itr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r13
leaq 0x7141(%rip), %r14      # 0x245c8
leaq 0x7149(%rip), %rbx      # 0x245d7
pushq $0x1
popq %r12
pushq $0x48
popq %rsi
pushq $0x19
popq %rcx
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %r8
callq 0x1dfd0
movq %rax, %r15
movq %r13, (%rax)
pushq $0x18
popq %r13
pushq $0x1b
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x1dfd0
movq %rax, 0x38(%r15)
pushq $0x1c
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x1dfd0
movq %rax, 0x40(%r15)
pushq $0x1d
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x1dfd0
movq %rax, 0x28(%r15)
pushq $0x1e
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x1dfd0
movq %rax, 0x30(%r15)
movabsq $0x7fffffff00000001, %rax # imm = 0x7FFFFFFF00000001
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem_extra.c
// Function: smem_next
const bwtintv_v *smem_next(smem_i *itr)
{
	int ori_start;
	itr->tmpvec[0]->n = itr->tmpvec[1]->n = itr->matches->n = itr->sub->n = 0;
	if (itr->start >= itr->len || itr->start < 0) return 0;
	while (itr->start < itr->len && itr->query[itr->start] > 3) ++itr->start; // skip ambiguous bases
	if (itr->start == itr->len) return 0;
	ori_start = itr->start;
	itr->start = bwt_smem1a(itr->bwt, itr->len, itr->query, ori_start, itr->min_intv, itr->max_intv, itr->matches, itr->tmpvec); // search for SMEM
	return itr->matches;
}

// Assembly:
pushq %rbx
movq 0x30(%rdi), %rax
andq $0x0, (%rax)
movq 0x28(%rdi), %r10
andq $0x0, (%r10)
movq 0x40(%rdi), %rax
andq $0x0, (%rax)
movq 0x38(%rdi), %rax
andq $0x0, (%rax)
movl 0x10(%rdi), %ecx
movslq 0x14(%rdi), %rdx
cmpl %edx, %ecx
setge %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
je 0x1d5e8
xorl %eax, %eax
popq %rbx
retq
movq %rdi, %rbx
leaq 0x38(%rdi), %r11
movl %edx, %esi
xorl %eax, %eax
cmpq %rdx, %rcx
jge 0x1d5e6
movq 0x8(%rbx), %rdi
cmpb $0x4, (%rdi,%rcx)
jb 0x1d60a
incq %rcx
movl %ecx, 0x10(%rbx)
jmp 0x1d5f3
cmpl %ecx, %esi
je 0x1d5e4
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movl 0x18(%rbx), %r8d
movq 0x20(%rbx), %r9
pushq %r11
pushq %r10
callq 0xdd85
popq %rcx
popq %rdx
movl %eax, 0x10(%rbx)
movq 0x28(%rbx), %rax
jmp 0x1d5e6
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/bwamem_extra.c
// Function: mem_align1
mem_alnreg_v mem_align1(const mem_opt_t *opt, const bwt_t *bwt, const bntseq_t *bns, const uint8_t *pac, int l_seq, const char *seq_)
{ // the difference from mem_align1_core() is that this routine: 1) calls mem_mark_primary_se(); 2) does not modify the input sequence
	extern mem_alnreg_v mem_align1_core(const mem_opt_t *opt, const bwt_t *bwt, const bntseq_t *bns, const uint8_t *pac, int l_seq, char *seq, void *buf);
	extern void mem_mark_primary_se(const mem_opt_t *opt, int n, mem_alnreg_t *a, int64_t id);
	mem_alnreg_v ar;
	char *seq;
	seq = malloc(l_seq);
	memcpy(seq, seq_, l_seq); // makes a copy of seq_
	ar = mem_align1_core(opt, bwt, bns, pac, l_seq, seq, 0);
	mem_mark_primary_se(opt, ar.n, ar.a, lrand48());
	free(seq);
	return ar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movslq %r9d, %r12
leaq 0x6f72(%rip), %rsi      # 0x245c8
leaq 0x6f88(%rip), %rcx      # 0x245e5
pushq $0x52
popq %rdx
movq %r12, %rdi
callq 0x1e045
movq %rax, %r15
movq %rax, %rdi
movq 0x40(%rsp), %rsi
movq %r12, %rdx
callq 0x3260
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq (%rsp), %r8
movl %r12d, %r9d
pushq $0x0
pushq %r15
callq 0x1a9e2
popq %rax
popq %rcx
movl (%rbx), %ebp
movq 0x18(%rbx), %r12
callq 0x3200
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %rax, %rcx
callq 0x17c4f
movq %r15, %rdi
callq 0x3390
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_calloc
void *wrap_calloc(size_t nmemb, size_t size,
				  const char *file, unsigned int line, const char *func) {
	void *p = calloc(nmemb, size);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, nmemb * size, file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
callq 0x31b0
testq %rax, %rax
je 0x1e002
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdfc7(%rip), %rax      # 0x2bfd0
movq (%rax), %rbp
imulq %r13, %r12
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, (%rsp)
leaq 0x664d(%rip), %rsi      # 0x24674
movq %rbp, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x3500
pushq $0x1
popq %rdi
callq 0x33c0
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_malloc
void *wrap_malloc(size_t size,
				  const char *file, unsigned int line, const char *func) {
	void *p = malloc(size);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, size, file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
callq 0x3470
testq %rax, %rax
je 0x1e075
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xdf54(%rip), %rax      # 0x2bfd0
movq (%rax), %r13
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, (%rsp)
leaq 0x65de(%rip), %rsi      # 0x24674
movq %r13, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x3500
pushq $0x1
popq %rdi
callq 0x33c0
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_realloc
void *wrap_realloc(void *ptr, size_t size,
				   const char *file, unsigned int line, const char *func) {
	void *p = realloc(ptr, size);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, size, file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
callq 0x3610
testq %rax, %rax
je 0x1e0e4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xdee5(%rip), %rax      # 0x2bfd0
movq (%rax), %r13
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, (%rsp)
leaq 0x656f(%rip), %rsi      # 0x24674
movq %r13, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x3500
pushq $0x1
popq %rdi
callq 0x33c0
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/malloc_wrap.c
// Function: wrap_strdup
char *wrap_strdup(const char *s,
				  const char *file, unsigned int line, const char *func) {
	char *p = strdup(s);
	if (NULL == p) {
		fprintf(stderr,
				"[%s] Failed to allocate %zd bytes at %s line %u: %s\n",
				func, strlen(s), file, line, strerror(errno));
		exit(EXIT_FAILURE);
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
callq 0x3710
testq %rax, %rax
je 0x1e153
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xde76(%rip), %rax      # 0x2bfd0
movq (%rax), %r13
movq %r12, %rdi
callq 0x3100
movq %rax, %r12
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, (%rsp)
leaq 0x64f5(%rip), %rsi      # 0x24674
movq %r13, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x3500
pushq $0x1
popq %rdi
callq 0x33c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ToniWestbrook[P]paladin/ksw.c
// Function: push_cigar
static inline uint32_t *push_cigar(int *n_cigar, int *m_cigar, uint32_t *cigar, int op, int len)
{
	if (*n_cigar == 0 || op != (cigar[(*n_cigar) - 1]&0xf)) {
		if (*n_cigar == *m_cigar) {
			*m_cigar = *m_cigar? (*m_cigar)<<1 : 4;
			cigar = realloc(cigar, (*m_cigar) << 2);
		}
		cigar[(*n_cigar)++] = len<<4 | op;
	} else cigar[(*n_cigar)-1] += len<<4;
	return cigar;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %rax
movq %rdi, %r14
movslq (%rdi), %rcx
testq %rcx, %rcx
je 0x1fbe3
movl -0x4(%rax,%rcx,4), %edx
movl %edx, %edi
andl $0xf, %edi
cmpl %ebp, %edi
jne 0x1fbe3
shll $0x4, %ebx
addl %ebx, %edx
movl %edx, -0x4(%rax,%rcx,4)
jmp 0x1fc29
cmpl (%rsi), %ecx
jne 0x1fc18
leal (%rcx,%rcx), %edx
testl %ecx, %ecx
pushq $0x4
popq %rcx
cmovnel %edx, %ecx
movl %ecx, (%rsi)
shll $0x2, %ecx
movslq %ecx, %rsi
leaq 0x4ac7(%rip), %rdx      # 0x246c8
leaq 0x4b9a(%rip), %r8       # 0x247a2
movq %rax, %rdi
movl $0x1f9, %ecx            # imm = 0x1F9
callq 0x1e0b4
movl (%r14), %ecx
shll $0x4, %ebx
orl %ebp, %ebx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movslq %ecx, %rcx
movl %ebx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/zepl.c
// Function: new_buffer
buffer_t* new_buffer()
{
	buffer_t *bp = (buffer_t *)malloc(sizeof(buffer_t));
	assert(bp != NULL);
	bp->b_point = 0;
	bp->b_mark = NOMARK;
	bp->b_page = 0;
	bp->b_epage = 0;
	bp->b_flags = 0;
	bp->b_buf = NULL;
	bp->b_ebuf = NULL;
	bp->b_gap = NULL;
	bp->b_egap = NULL;
	bp->b_fname[0] = '\0';
	bp->w_top = 0;	
	bp->w_rows = LINES - 2;
	return bp;
}

// Assembly:
pushq %rax
movl $0x150, %edi            # imm = 0x150
callq 0x21f0
andq $0x0, 0x8(%rax)
orq $-0x1, (%rax)
xorl %ecx, %ecx
movb %cl, 0x14d(%rax)
movb %cl, 0x4c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movb %cl, 0x40(%rax)
movq 0x9b64(%rip), %rcx      # 0xbfe8
movb (%rcx), %cl
addb $-0x2, %cl
movb %cl, 0x41(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/zepl.c
// Function: fatal
void fatal(char *msg)
{
	noraw();
	endwin();
	printf("\n%s %s:\n%s\n", E_NAME, E_VERSION, msg);
	exit(1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x21a0
callq 0x22e0
leaq 0x4b61(%rip), %rdi      # 0x7004
leaq 0x4b66(%rip), %rsi      # 0x7010
leaq 0x4b64(%rip), %rdx      # 0x7015
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2110
pushq $0x1
popq %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/zepl.c
// Function: msg
int msg(char *msg, ...)
{
	va_list args;
	va_start(args, msg);
	(void)vsprintf(msgline, msg, args);
	va_end(args);
	msgflag = TRUE;
	return FALSE;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2521
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0xa3a8(%rip), %rdi      # 0xc8f0
movq %r10, %rsi
callq 0x2240
movl $0x1, 0xa596(%rip)      # 0xcaf0
xorl %eax, %eax
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/zepl.c
// Function: growgap
int growgap(buffer_t *bp, point_t n)
{
	char_t *new;
	point_t buflen, newlen, xgap, xegap;
		
	assert(bp->b_buf <= bp->b_gap);
	assert(bp->b_gap <= bp->b_egap);
	assert(bp->b_egap <= bp->b_ebuf);

	xgap = bp->b_gap - bp->b_buf;
	xegap = bp->b_egap - bp->b_buf;
	buflen = bp->b_ebuf - bp->b_buf;
    
	/* reduce number of reallocs by growing by a minimum amount */
	n = (n < MIN_GAP_EXPAND ? MIN_GAP_EXPAND : n);
	newlen = buflen + n * sizeof (char_t);

	if (buflen == 0) {
		if (newlen < 0 || MAX_SIZE_T < newlen) fatal("Failed to allocate required memory.\n");
		new = (char_t*) malloc((size_t) newlen);
		if (new == NULL) fatal("Failed to allocate required memory.\n");
	} else {
		if (newlen < 0 || MAX_SIZE_T < newlen) return msg("Failed to allocate required memory");
		new = (char_t*) realloc(bp->b_buf, (size_t) newlen);
		if (new == NULL) return msg("Failed to allocate required memory");
	}

	/* Relocate pointers in new buffer and append the new
	 * extension to the end of the gap.
	 */
	bp->b_buf = new;
	bp->b_gap = bp->b_buf + xgap;      
	bp->b_ebuf = bp->b_buf + buflen;
	bp->b_egap = bp->b_buf + newlen;
	while (xegap < buflen--)
		*--bp->b_egap = *--bp->b_ebuf;
	bp->b_ebuf = bp->b_buf + newlen;

	assert(bp->b_buf < bp->b_ebuf);          /* Buffer must exist. */
	assert(bp->b_buf <= bp->b_gap);
	assert(bp->b_gap < bp->b_egap);          /* Gap must grow only. */
	assert(bp->b_egap <= bp->b_ebuf);
	return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rbp
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
movq 0x38(%rdi), %r13
subq %r15, %r12
cmpq $0x201, %rsi            # imm = 0x201
movl $0x200, %r14d           # imm = 0x200
cmovgeq %rsi, %r14
addq %r12, %r14
testq %r12, %r12
je 0x260b
testq %r14, %r14
js 0x25f9
movq %r15, %rdi
movq %r14, %rsi
callq 0x2220
testq %rax, %rax
jne 0x2618
leaq 0x4a3f(%rip), %rdi      # 0x703f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x24c3
jmp 0x266b
movq %r14, %rdi
callq 0x21f0
testq %rax, %rax
je 0x267c
subq %r15, %rbp
subq %r15, %r13
movq %rax, 0x20(%rbx)
addq %rax, %rbp
movq %rbp, 0x30(%rbx)
leaq (%rax,%r12), %rcx
movq %rcx, 0x28(%rbx)
addq %r14, %rax
movq %rax, 0x38(%rbx)
cmpq %r12, %r13
jge 0x2660
decq %r12
movq 0x28(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x28(%rbx)
movb -0x1(%rax), %al
leaq -0x1(%rcx), %rdx
movq %rdx, 0x38(%rbx)
movb %al, -0x1(%rcx)
jmp 0x2638
addq 0x20(%rbx), %r14
movq %r14, 0x28(%rbx)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4997(%rip), %rdi      # 0x701a
callq 0x248e
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/zepl.c
// Function: movegap
point_t movegap(buffer_t *bp, point_t offset)
{
	char_t *p = ptr(bp, offset);
	while (p < bp->b_gap)
		*--bp->b_egap = *--bp->b_gap;
	while (bp->b_egap < p)
		*bp->b_gap++ = *bp->b_egap++;
	assert(bp->b_gap <= bp->b_egap);
	assert(bp->b_buf <= bp->b_gap);
	assert(bp->b_egap <= bp->b_ebuf);
	return (pos(bp, bp->b_egap));
}

// Assembly:
movq 0x20(%rdi), %rax
testq %rsi, %rsi
js 0x26c7
addq %rsi, %rax
movq 0x30(%rdi), %rdx
cmpq %rdx, %rax
jae 0x26a1
xorl %ecx, %ecx
jmp 0x26a8
movq 0x38(%rdi), %rcx
subq %rdx, %rcx
addq %rcx, %rax
jmp 0x26c7
leaq -0x1(%rcx), %rdx
movq %rdx, 0x30(%rdi)
movb -0x1(%rcx), %cl
movq 0x38(%rdi), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, 0x38(%rdi)
movb %cl, -0x1(%rdx)
movq 0x30(%rdi), %rcx
cmpq %rcx, %rax
jb 0x26ad
jmp 0x26ea
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%rdi)
movb (%rcx), %cl
movq 0x30(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x30(%rdi)
movb %cl, (%rdx)
movq 0x38(%rdi), %rcx
cmpq %rax, %rcx
jb 0x26d2
movq 0x30(%rdi), %rax
subq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/zepl.c
// Function: save_buffer
void save_buffer()
{
	FILE *fp;
	point_t length;

	fp = fopen(curbp->b_fname, "w");
	if (fp == NULL) msg("Failed to open file \"%s\".", curbp->b_fname);
	(void) movegap(curbp, (point_t) 0);
	length = (point_t) (curbp->b_ebuf - curbp->b_egap);
	if (fwrite(curbp->b_egap, sizeof (char), (size_t) length, fp) != length) 
		msg("Failed to write file \"%s\".", curbp->b_fname);
	fclose(fp);
	curbp->b_flags &= ~B_MODIFIED;
	msg("File \"%s\" %ld bytes saved.", curbp->b_fname, pos(curbp, curbp->b_ebuf));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xa3f1(%rip), %rdi      # 0xcaf8
addq $0x4c, %rdi
leaq 0x4bdc(%rip), %rsi      # 0x72ee
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
jne 0x2738
movq 0xa3d2(%rip), %rsi      # 0xcaf8
addq $0x4c, %rsi
leaq 0x4931(%rip), %rdi      # 0x7062
xorl %eax, %eax
callq 0x24c3
movq 0xa3b9(%rip), %rdi      # 0xcaf8
xorl %esi, %esi
callq 0x2688
movq 0xa3ab(%rip), %rax      # 0xcaf8
movq 0x28(%rax), %r14
movq 0x38(%rax), %rdi
subq %rdi, %r14
pushq $0x1
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x22d0
cmpq %r14, %rax
je 0x2784
movq 0xa386(%rip), %rsi      # 0xcaf8
addq $0x4c, %rsi
leaq 0x48ff(%rip), %rdi      # 0x707c
xorl %eax, %eax
callq 0x24c3
movq %rbx, %rdi
callq 0x20d0
movq 0xa365(%rip), %rsi      # 0xcaf8
andb $-0x2, 0x14d(%rsi)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rdx
movq 0x38(%rsi), %rdi
cmpq %rdx, %rdi
jbe 0x27af
xorl %ecx, %ecx
jmp 0x27b6
movq 0x30(%rsi), %rcx
subq %rdi, %rcx
addq $0x4c, %rsi
subq %rax, %rdx
addq %rcx, %rdx
leaq 0x48d0(%rip), %rdi      # 0x7097
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24c3