LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: Branch::installRanges(int, int, unsigned int, unsigned char const*)
int installRanges(int c, int nextc, uint32_t qAllow, const uint8_t* qs) {
		assert(!exhausted_);
		assert(ranges_ != NULL);
		RangeState& r = ranges_[len_];
		int ret = 0;
		r.eliminated_ = true; // start with everything eliminated
		r.eq.eliminate(); // set all elim flags to 1
		assert_lt(qs[0], 127);
		assert_lt(qs[1], 127);
		assert_lt(qs[2], 127);
		assert_lt(qs[3], 127);
		assert_eq(qs[0], qs[1]);
		assert_eq(qs[0], qs[2]);
		assert_eq(qs[0], qs[3]);
		r.eq.flags.quallo = qs[0];
		if(qs[0] > qAllow) return 0;
		// Set one/both of these to true to do the accounting for
		// insertions and deletions as well as mismatches
		bool doInserts = false;
		bool doDeletes = false;
		// We can proceed on an A
		if(c != 0 && r.bots[0] > r.tops[0] && qs[0] <= qAllow) {
			r.eliminated_ = false;
			r.eq.flags.mmA = 0; // A substitution is an option
			if(doInserts) r.eq.flags.insA = 0;
			if(doDeletes && nextc == 0) r.eq.flags.del = 0;
			ret++;
		}
		// We can proceed on a C
		if(c != 1 && r.bots[1] > r.tops[1] && qs[1] <= qAllow) {
			r.eliminated_ = false;
			r.eq.flags.mmC = 0; // C substitution is an option
			if(doInserts) r.eq.flags.insC = 0;
			if(doDeletes && nextc == 1) r.eq.flags.del = 0;
			ret++;
		}
		// We can proceed on a G
		if(c != 2 && r.bots[2] > r.tops[2] && qs[2] <= qAllow) {
			r.eliminated_ = false;
			r.eq.flags.mmG = 0; // G substitution is an option
			if(doInserts) r.eq.flags.insG = 0;
			if(doDeletes && nextc == 2) r.eq.flags.del = 0;
			ret++;
		}
		// We can proceed on a T
		if(c != 3 && r.bots[3] > r.tops[3] && qs[3] <= qAllow) {
			r.eliminated_ = false;
			r.eq.flags.mmT = 0; // T substitution is an option
			if(doInserts) r.eq.flags.insT = 0;
			if(doDeletes && nextc == 3) r.eq.flags.del = 0;
			ret++;
		}
		return ret;
	}

// Assembly:
movq 0x18(%rdi), %rdx
movzwl 0xe(%rdi), %eax
leaq (%rax,%rax,2), %rdi
shll $0x4, %edi
movb $0x1, 0x28(%rdx,%rdi)
movl $0x1fff, %eax           # imm = 0x1FFF
orq 0x20(%rdx,%rdi), %rax
movq %rax, 0x20(%rdx,%rdi)
movzbl (%r8), %r10d
andl $0x7f, %r10d
shlq $0x29, %r10
movabsq $-0xfe0000000001, %r9   # imm = 0xFFFF01FFFFFFFFFF
andq %rax, %r9
orq %r10, %r9
movq %r9, 0x20(%rdx,%rdi)
movzbl (%r8), %r10d
xorl %eax, %eax
cmpl %ecx, %r10d
ja 0x2d5c2
addq %rdi, %rdx
xorl %eax, %eax
testl %esi, %esi
je 0x2d562
movl 0x10(%rdx), %edi
cmpl (%rdx), %edi
jbe 0x2d562
movb $0x0, 0x28(%rdx)
andq $-0x2, %r9
movq %r9, 0x20(%rdx)
movl $0x1, %eax
cmpl $0x1, %esi
je 0x2d582
movl 0x14(%rdx), %edi
cmpl 0x4(%rdx), %edi
jbe 0x2d582
movzbl 0x1(%r8), %edi
cmpl %ecx, %edi
ja 0x2d582
movb $0x0, 0x28(%rdx)
andb $-0x3, 0x20(%rdx)
incl %eax
cmpl $0x2, %esi
je 0x2d5a2
movl 0x18(%rdx), %edi
cmpl 0x8(%rdx), %edi
jbe 0x2d5a2
movzbl 0x2(%r8), %edi
cmpl %ecx, %edi
ja 0x2d5a2
movb $0x0, 0x28(%rdx)
andb $-0x5, 0x20(%rdx)
incl %eax
cmpl $0x3, %esi
je 0x2d5c2
movl 0x1c(%rdx), %esi
cmpl 0xc(%rdx), %esi
jbe 0x2d5c2
movzbl 0x3(%r8), %esi
cmpl %ecx, %esi
ja 0x2d5c2
movb $0x0, 0x28(%rdx)
andb $-0x9, 0x20(%rdx)
incl %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: Branch::free(unsigned int, AllocOnlyPool<RangeState>&, AllocOnlyPool<Edit>&, AllocOnlyPool<Branch>&)
void free(uint32_t qlen,
	          AllocOnlyPool<RangeState>& rpool,
	          AllocOnlyPool<Edit>& epool,
	          AllocOnlyPool<Branch>& bpool)
	{
		edits_.free(epool, qlen);
		if(ranges_ != NULL) {
			assert_gt(rangesSz_, 0);
			rpool.free(ranges_, rangesSz_);
			ranges_ = NULL;
			rangesSz_ = 0;
		}
		bpool.free(this);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdx, %r15
movq %rdi, %r14
addq $0x50, %rdi
movl %esi, %edx
movq %rcx, %rsi
callq 0x2e68c
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x2ded1
movzwl 0x20(%r14), %edx
movq %r15, %rdi
callq 0x2dee2
movq $0x0, 0x18(%r14)
movw $0x0, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2e6d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::free(RangeState*, unsigned int)
bool free(T* t, uint32_t num) {
		assert(t != NULL);
		if(pool_->verbose) {
			stringstream ss;
			ss << pool_->patid << ": Freeing " << num << " " << name_ << "s";
			glog.msg(ss.str());
		}
		if(num <= cur_ && t == &pools_[curPool_][cur_ - num]) {
			cur_ -= num;
			if(cur_ == 0 && curPool_ > 0) {
				rewindPool();
			}
			return true; // deallocated
		}
		return false; // didn't deallocate
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x2dfff
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x28aa0(%rip), %rsi     # 0x569c9
movl $0xa, %edx
movq %rax, %rdi
callq 0x9560
movl %ebp, %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x28e73(%rip), %rsi     # 0x56dbd
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x2df78
movq %r12, %rdi
callq 0x91b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x2df92
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x98c0
leaq 0x29139(%rip), %rsi     # 0x570d2
movl $0x1, %edx
movq %r15, %rdi
callq 0x9560
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x40665(%rip), %rdi     # 0x6e621
leaq 0x8(%rsp), %rsi
callq 0x2be40
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dfe1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3cf60(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movl 0x5c(%rbx), %eax
movl %eax, %ecx
subl %ebp, %ecx
jb 0x2e020
movl 0x30(%rbx), %edx
movq 0x18(%rbx), %rsi
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq (%rsi,%rdx,8), %rdi
cmpq %r14, %rdi
je 0x2e034
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, 0x5c(%rbx)
cmpl %ebp, %eax
setne %al
testl %edx, %edx
sete %cl
orb %al, %cl
movb $0x1, %bpl
jne 0x2e022
movq %rbx, %rdi
callq 0x2e09e
jmp 0x2e022
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e077
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2e077
jmp 0x2e074
movq %rax, %rbx
movq 0x3ceca(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::rewindPool()
void rewindPool() {
		assert_eq(curPool_+1, pools_.size());
		assert_eq(curPool_, lastCurInPool_.size());
		if(pool_->verbose) {
			stringstream ss;
			ss << pool_->patid << ": Freeing a " << name_ << " pool";
			glog.msg(ss.str());
		}
		pool_->free(pools_.back());
		pools_.pop_back();
		curPool_--;
		assert_gt(lastCurInPool_.size(), 0);
		cur_ = lastCurInPool_.back();
		lastCurInPool_.pop_back();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x2e192
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x92e0
movq %rax, %r14
leaq 0x288f7(%rip), %rsi     # 0x569d4
movl $0xc, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x2e10b
movq %r15, %rdi
callq 0x91b0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x2e125
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x98c0
leaq 0x288b5(%rip), %rsi     # 0x569e1
movl $0x5, %edx
movq %r14, %rdi
callq 0x9560
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x404d2(%rip), %rdi     # 0x6e621
leaq 0x8(%rsp), %rsi
callq 0x2be40
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e174
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3cdcd(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq (%rbx), %rdi
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rsi
callq 0x2e21c
decq 0x28(%rbx)
decl 0x30(%rbx)
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
movl -0x4(%rax,%rcx,4), %eax
movl %eax, 0x5c(%rbx)
decq %rcx
movq %rcx, 0x50(%rbx)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e1f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2e1f6
jmp 0x2e1f3
movq %rax, %rbx
movq 0x3cd4b(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::free(void*)
void free(void *ptr) {
		uint32_t off = (uint32_t)((int8_t*)ptr - pool_);
		assert_eq(0, off % chunkSz_);
		off /= chunkSz_;
		if(verbose) {
			stringstream ss;
			ss << patid << ": Freeing chunk with offset: " << cur_;
			glog.msg(ss.str());
		}
		bits_.clear(off);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movl 0x14(%rdi), %ebp
cmpb $0x1, (%rdi)
jne 0x2e2d3
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movl 0x4(%rbx), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x28785(%rip), %rsi     # 0x569e7
movl $0x1d, %edx
movq %rax, %rdi
callq 0x9560
movl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x92e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x40391(%rip), %rdi     # 0x6e621
leaq 0x8(%rsp), %rsi
callq 0x2be40
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e2b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3cc8c(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
subl %r12d, %r14d
movl %r14d, %eax
xorl %edx, %edx
divl %ebp
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl %eax, %ecx
roll %cl, %edx
movq 0x30(%rbx), %rcx
movl %eax, %esi
shrl $0x5, %esi
andl %edx, (%rcx,%rsi,4)
decl 0x24(%rbx)
cmpl %eax, 0x28(%rbx)
ja 0x2e2ff
incl %eax
movl %eax, 0x28(%rbx)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e334
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2e334
jmp 0x2e331
movq %rax, %rbx
movq 0x3cc0d(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: BranchQueue::pop()
Branch *pop() {
		Branch *b = branchQ_.top(); // get it
		branchQ_.pop(); // remove it
		if(verbose_) {
			stringstream ss;
			ss << patid_ << ": Popping " << b->id_ << ", " << b << ", " << b->cost_ << ", " << b->exhausted_ << ", " << b->curtailed_ << ", " << sz_ << "->" << (sz_-1);
			glog.msg(ss.str());
		}
		sz_--;
		return b;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rbx), %rax
movq (%rax), %r14
callq 0x2e54a
cmpb $0x1, 0x2c(%rbx)
jne 0x2e4ed
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movl 0x28(%rbx), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x28661(%rip), %rsi     # 0x56a05
movl $0xa, %edx
movq %rax, %rdi
callq 0x9560
movl (%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x25b40(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movq %r14, %rsi
callq 0x9390
movq %rax, %r15
leaq 0x25b1e(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzwl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x25afa(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x83(%r14), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x25ad3(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x82(%r14), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x25aac(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x284e0(%rip), %rsi     # 0x5695b
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
decl %esi
movq %r15, %rdi
callq 0x92e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x40177(%rip), %rdi     # 0x6e621
leaq 0x8(%rsp), %rsi
callq 0x2be40
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e4cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3ca72(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
decl (%rbx)
movq %r14, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e524
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2e524
jmp 0x2e521
movq %rax, %rbx
movq 0x3ca1d(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: EditList::free(AllocOnlyPool<Edit>&, unsigned long)
void free(AllocOnlyPool<Edit>& epool, size_t qlen) {
		if(yetMoreEdits_ != NULL)
			epool.free(yetMoreEdits_, (uint32_t)qlen + 10 - numMoreEdits - numEdits);
		if(moreEdits_ != NULL)
			epool.free(moreEdits_, numMoreEdits);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x2e6aa
addl $-0xc, %edx
movq %rbx, %rdi
callq 0x2e848
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x2e6c7
movq %rbx, %rdi
movl $0x10, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e848
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::free(Branch*)
void free(T* t) {
		assert(t != NULL);
		if(pool_->verbose) {
			stringstream ss;
			ss << pool_->patid << ": Freeing a " << name_;
			glog.msg(ss.str());
		}
		if(cur_ > 0 && t == &pools_[curPool_][cur_-1]) {
			cur_--;
			if(cur_ == 0 && curPool_ > 0) {
				rewindPool();
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x2e7b1
leaq 0x20(%rsp), %rdi
callq 0x9310
leaq 0x30(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x282c0(%rip), %rsi     # 0x569d4
movl $0xc, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x2e742
movq %r12, %rdi
callq 0x91b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x2e75c
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x98c0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x97e0
leaq 0x3feb1(%rip), %rdi     # 0x6e621
movq %rsp, %rsi
callq 0x2be40
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e793
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3c7ae(%rip), %rsi     # 0x6af48
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0xa0(%rsp), %rdi
callq 0x9180
movl 0x5c(%rbx), %eax
testl %eax, %eax
je 0x2e7ee
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
decl %eax
movq %rax, %rsi
shlq $0x7, %rsi
leaq (%rsi,%rax,8), %rsi
addq (%rdx,%rcx,8), %rsi
cmpq %r14, %rsi
jne 0x2e7ee
movl %eax, 0x5c(%rbx)
testl %eax, %eax
setne %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
jne 0x2e7ee
movq %rbx, %rdi
callq 0x2eb82
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e822
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2e822
jmp 0x2e81f
movq %rax, %rbx
movq 0x3c71f(%rip), %rsi     # 0x6af48
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0xa0(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: Branch::prep(EbwtParams const&, unsigned char const*)
void prep(const EbwtParams& ep, const uint8_t* ebwt) {
		if(bot_ > top_+1) {
			SideLocus::initFromTopBot(top_, bot_, ep, ebwt, ltop_, lbot_);
		} else if(bot_ > top_) {
			ltop_.initFromRow(top_, ep, ebwt);
			lbot_.invalidate();
		}
		prepped_ = true;
	}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movl 0x24(%rdi), %eax
movl 0x28(%rdi), %esi
leal 0x1(%rax), %edi
cmpl %edi, %esi
jbe 0x2f648
leaq 0x2c(%rbx), %r8
leaq 0x3c(%rbx), %r9
movl %eax, %edi
callq 0x2bf4e
jmp 0x2f65b
cmpl %eax, %esi
jbe 0x2f65b
leaq 0x2c(%rbx), %rdi
movl %eax, %esi
callq 0x1b2d0
movb $-0x1, 0x4a(%rbx)
movb $0x1, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: SingleRangeSourceDriver<EbwtRangeSource>::setQueryImpl(PatternSourcePerThread*, Range*)
virtual void setQueryImpl(PatternSourcePerThread* patsrc, Range *r) {
		this->done = false;
		pm_.reset((uint32_t)patsrc->rdid());
		Read* buf = mate1_ ? &patsrc->bufa() : &patsrc->bufb();
		len_ = buf->length();
		rs_->setQuery(*buf, r);
		initRangeSource((fw_ == ebwtFw_) ? buf->qual : buf->qualRev);
		assert_gt(len_, 0);
		if(this->done) return;
		ASSERT_ONLY(allTops_.clear());
		if(!rs_->done) {
			rs_->initBranch(pm_); // set up initial branch
		}
		uint16_t icost = (r != NULL) ? r->cost : 0;
		this->minCost = max<uint16_t>(icost, this->minCostAdjustment_);
		this->done = rs_->done;
		this->foundRange = rs_->foundRange;
		if(!pm_.empty()) {
			assert(!pm_.front()->curtailed_);
			assert(!pm_.front()->exhausted_);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, 0x9(%rdi)
leaq 0x40(%rdi), %r15
movl 0x50(%rsi), %esi
addl 0x58(%r12), %esi
movq %r15, %rdi
callq 0x2f664
xorl %eax, %eax
movq %rax, 0xa0(%rbx)
movq %rax, 0xc8(%rbx)
movl %eax, 0xd4(%rbx)
movl %eax, 0xa8(%rbx)
movq %rax, 0x160(%rbx)
movq %rax, 0x188(%rbx)
movl %eax, 0x194(%rbx)
movl %eax, 0x168(%rbx)
movq %rax, 0x100(%rbx)
movq %rax, 0x128(%rbx)
movl %eax, 0x134(%rbx)
movl %eax, 0x108(%rbx)
movw $0x0, 0x198(%rbx)
movzbl 0x14(%rbx), %eax
xorl $0x1, %eax
shll $0x5, %eax
movq 0x18(%r12,%rax), %r13
imulq $0x268, 0x50(%r12), %r12 # imm = 0x268
leaq (%r12,%r13), %rsi
leaq (%r12,%r13), %rbp
addq $0x60, %rbp
movl -0x40(%rbp), %eax
movl %eax, 0x10(%rbx)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rdx
callq *0x10(%rax)
movb 0x28(%rbx), %al
cmpb 0x38(%rbx), %al
leaq 0xf0(%r13,%r12), %rsi
cmoveq %rbp, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
cmpb $0x0, 0x9(%rbx)
jne 0x2f885
movq 0x30(%rbx), %rdi
cmpb $0x0, 0x8(%rdi)
jne 0x2f85a
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0x2f866
movzwl 0x8(%r14), %eax
jmp 0x2f868
xorl %eax, %eax
movl 0xc(%rbx), %ecx
cmpw %cx, %ax
cmovbel %ecx, %eax
movw %ax, 0xa(%rbx)
movq 0x30(%rbx), %rax
movb 0x8(%rax), %cl
movb %cl, 0x9(%rbx)
movb 0x9(%rax), %al
movb %al, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtSeededRangeSourceDriver::setQueryImpl(PatternSourcePerThread*, Range*)
virtual void setQueryImpl(PatternSourcePerThread* patsrc, Range *partial) {
		this->done = false;
		rsSeed_->setQuery(patsrc, partial);
		this->minCostAdjustment_ = max(rsSeed_->minCostAdjustment_, rsSeed_->minCost);
		this->minCost = this->minCostAdjustment_;
		rsFull_.clearSources();
		rsFull_.setQuery(patsrc, partial);
		rsFull_.minCost = this->minCost;
		assert_gt(rsFull_.minCost, 0);
		patsrc_ = patsrc;
		// The minCostAdjustment comes from the seed range source
		// driver, based on Ns and quals in the hi-half
		this->foundRange = false;
		ASSERT_ONLY(allTops_.clear());
		assert_eq(this->minCost, min<uint16_t>(rsSeed_->minCost, rsFull_.minCost));
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movb %bpl, 0x9(%rdi)
movq 0xa8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0xa8(%rbx), %rax
movzwl 0xc(%rax), %ecx
movzwl 0xa(%rax), %eax
cmpw %ax, %cx
cmoval %ecx, %eax
movw %ax, 0xc(%rbx)
movw %ax, 0xa(%rbx)
leaq 0x18(%rbx), %r12
movq %r12, %rdi
callq 0x30ab8
movq 0x18(%rbx), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x18(%rax)
movzwl 0xa(%rbx), %eax
movw %ax, 0x22(%rbx)
movq %r14, 0xb0(%rbx)
movb %bpl, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::~CostAwareRangeSourceDriver()
virtual ~CostAwareRangeSourceDriver() {
		const size_t rssSz = rss_.size();
		for(size_t i = 0; i < rssSz; i++) {
			delete rss_[i];
		}
		rss_.clear();
		active_.clear();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x39deb(%rip), %rax     # 0x6a190
movq %rax, (%rdi)
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x303cf
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x303c7
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
cmpq %r15, %r14
jne 0x303b4
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %rax, 0x48(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x303fa
leaq 0x38(%rbx), %r14
callq 0x95e0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3041a
addq $0x18, %rbx
callq 0x95e0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::setQueryImpl(PatternSourcePerThread*, Range*)
virtual void setQueryImpl(PatternSourcePerThread* patsrc, Range *r) {
		this->done = false;
		this->foundRange = false;
		lastRange_ = NULL;
		delayedRange_ = NULL;
		ASSERT_ONLY(allTopsRc_.clear());
		patsrc_ = patsrc;
		rand_.init(patsrc->bufa().seed);
		const size_t rssSz = rss_.size();
		if(rssSz == 0) return;
		for(size_t i = 0; i < rssSz; i++) {
			// Assuming that all
			rss_[i]->setQuery(patsrc, r);
		}
		active_ = rss_;
		this->minCost = 0;
		sortActives();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movw $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movq %rsi, 0x80(%rdi)
movq 0x18(%rsi), %rax
imulq $0x268, 0x50(%rsi), %rcx # imm = 0x268
movl 0x18c(%rax,%rcx), %eax
movl %eax, 0x60(%rdi)
movb $0x1, 0x68(%rdi)
movl $0x1e, 0x64(%rdi)
movq 0x28(%rdi), %r13
testq %r13, %r13
je 0x304d4
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
xorl %ebp, %ebp
movq 0x18(%rbx), %rax
movq (%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
incq %rbp
cmpq %rbp, %r13
jne 0x30490
leaq 0x30(%rbx), %rdi
movq %r12, %rsi
callq 0x30676
movw $0x0, 0xa(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30728
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::advanceImpl(int)
virtual void advanceImpl(int until) {
		lastRange_ = NULL;
		ASSERT_ONLY(uint16_t iminCost = this->minCost);
		const size_t actSz = active_.size();
		assert(sortedActives());
		if(delayedRange_ != NULL) {
			assert_eq(iminCost, delayedRange_->cost);
			lastRange_ = delayedRange_;
			delayedRange_ = NULL;
			this->foundRange = true;
			assert_eq(range().cost, iminCost);
			if(!active_.empty()) {
				assert_geq(active_[0]->minCost, this->minCost);
				this->minCost = max(active_[0]->minCost, this->minCost);
			} else {
				this->done = true;
			}
			return; // found a range
		}
		assert(delayedRange_ == NULL);
		if(mateEliminated() || actSz == 0) {
			// No more alternatoves; clear the active set and signal
			// we're done
			active_.clear();
			this->done = true;
			return;
		}
		// Advance lowest-cost RangeSourceDriver
		TRangeSrcDrPtr p = active_[0];
		uint16_t precost = p->minCost;
		assert(!p->done || p->foundRange);
		if(!p->foundRange) {
			p->advance(until);
		}
		bool needsSort = false;
		if(p->foundRange) {
			Range *r = &p->range();
			assert_eq(r->cost, iminCost);
			needsSort = foundFirstRange(r); // may set delayedRange_; re-sorts active_
			assert_eq(lastRange_->cost, iminCost);
			if(delayedRange_ != NULL) assert_eq(delayedRange_->cost, iminCost);
			p->foundRange = false;
		}
		if(p->done || (precost != p->minCost) || needsSort) {
			sortActives();
			if(mateEliminated() || active_.empty()) {
				active_.clear();
				this->done = (delayedRange_ == NULL);
			}
		}
		assert(sortedActives());
		assert(lastRange_ == NULL || lastRange_->cost == iminCost);
		assert(delayedRange_ == NULL || delayedRange_->cost == iminCost);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x70(%rdi)
movq 0x48(%rdi), %r14
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0x30547
movq %rax, 0x70(%rbx)
movq $0x0, 0x78(%rbx)
movb $0x1, 0x8(%rbx)
testq %r14, %r14
je 0x30565
movq 0x38(%rbx), %rax
movq (%rax), %rax
movzwl 0xa(%rax), %eax
movzwl 0xa(%rbx), %ecx
cmpw %cx, %ax
cmoval %eax, %ecx
movw %cx, 0xa(%rbx)
jmp 0x30569
movl %esi, %ebp
movq %rbx, %rdi
callq 0x308d0
xorb $0x1, %al
testq %r14, %r14
setne %cl
testb %al, %cl
jne 0x30574
movq $0x0, 0x48(%rbx)
movb $0x1, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rbx), %rax
movq (%rax), %r14
movzwl 0xa(%r14), %r15d
cmpb $0x0, 0x8(%r14)
jne 0x30592
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *0x20(%rax)
cmpb $0x1, 0x8(%r14)
jne 0x305b4
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3094a
movb $0x0, 0x8(%r14)
jmp 0x305b6
xorl %eax, %eax
cmpb $0x0, 0x9(%r14)
jne 0x305cb
cmpw 0xa(%r14), %r15w
sete %cl
notb %al
testb %cl, %al
jne 0x30569
movq %rbx, %rdi
callq 0x30728
movq %rbx, %rdi
callq 0x308d0
testb %al, %al
jne 0x305e6
cmpq $0x0, 0x48(%rbx)
jne 0x30569
movq $0x0, 0x48(%rbx)
cmpq $0x0, 0x78(%rbx)
sete 0x9(%rbx)
jmp 0x30569
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::removeMate(int)
virtual void removeMate(int m) {
		bool qmate1 = (m == 1);
		assert(paired_);
		for(size_t i = 0; i < active_.size(); i++) {
			if(active_[i]->mate1() == qmate1) {
				active_[i]->done = true;
			}
		}
		sortActives();
		assert(mateEliminated());
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x30663
movl %esi, %ebp
xorl %r14d, %r14d
cmpl $0x1, %ebp
setne %r15b
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpb %al, %r15b
je 0x3065a
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rax
movb $0x1, 0x9(%rax)
incq %r14
cmpq 0x48(%rbx), %r14
jb 0x30634
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30728
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::mateEliminated()
bool mateEliminated() {
		if(!paired_) return false;
		bool mate1sLeft = false;
		bool mate2sLeft = false;
		// If this RangeSourceDriver is done, shift everyone else
		// up and delete it
		const size_t rssSz = active_.size();
		for(size_t i = 0; i < rssSz; i++) {
			if(!active_[i]->done) {
				if(active_[i]->mate1()) mate1sLeft = true;
				else mate2sLeft = true;
			}
		}
		return !mate1sLeft || !mate2sLeft;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x50(%rdi)
jne 0x3092f
movq %rdi, %r14
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x30933
xorl %r12d, %r12d
movl $0x1, %r13d
xorl %ebp, %ebp
xorl %ebx, %ebx
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rdi
cmpb $0x0, 0x9(%rdi)
jne 0x3091f
movq (%rdi), %rax
callq *0x38(%rax)
movzbl %bl, %ebx
testb %al, %al
cmovnel %r13d, %ebx
movzbl %bpl, %ebp
cmovel %r13d, %ebp
incq %r12
cmpq %r12, %r15
jne 0x308fa
andb %bpl, %bl
xorb $0x1, %bl
jmp 0x30935
xorl %ebx, %ebx
jmp 0x30935
movb $0x1, %bl
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::clearSources()
void clearSources() {
		const size_t rssSz = rss_.size();
		for(size_t i = 0; i < rssSz; i++) {
			delete rss_[i];
		}
		rss_.clear();
		active_.clear();
		paired_ = false;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x30ae7
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x30adf
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
cmpq %r15, %r14
jne 0x30acc
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %rax, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSourceDriverFactory::create() const
EbwtRangeSourceDriver *create() const {
		return new EbwtRangeSourceDriver(
				params_, rs_->create(), fw_, seed_, maqPenalty_,
				qualOrder_, sink_, sinkPt_, seedLen_, nudgeLeft_,
				rev0Off_, rev1Off_, rev2Off_, rev3Off_, os_, verbose_,
				quiet_, mate1_, pool_, btCnt_);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r15
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x94b0
movq %rax, %rbx
movq (%r15), %rax
movq %rax, 0x90(%rsp)
movq 0x8(%r15), %rdi
callq 0x30c7e
movq %rax, 0x88(%rsp)
movzbl 0x10(%r15), %eax
movl %eax, 0x84(%rsp)
movzbl 0x11(%r15), %r8d
movzbl 0x12(%r15), %r9d
movzbl 0x13(%r15), %edx
movups 0x18(%r15), %xmm0
movl 0x28(%r15), %esi
movzbl 0x2c(%r15), %edi
movl 0x30(%r15), %r10d
movl 0x34(%r15), %r11d
movl 0x38(%r15), %ebp
movl 0x3c(%r15), %r12d
movq 0x40(%r15), %r13
movzbl 0x48(%r15), %r14d
movq %rbx, %rcx
movzbl 0x49(%r15), %ebx
movzbl 0x4a(%r15), %eax
movups 0x50(%r15), %xmm1
movups %xmm1, 0x68(%rsp)
movl %eax, 0x60(%rsp)
movl %ebx, 0x58(%rsp)
movq %rcx, %rbx
movl %r14d, 0x50(%rsp)
movq %r13, 0x48(%rsp)
movl %r12d, 0x40(%rsp)
movl %ebp, 0x38(%rsp)
movl %r11d, 0x30(%rsp)
movl %r10d, 0x28(%rsp)
movl %edi, 0x20(%rsp)
movl %esi, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movl %edx, (%rsp)
movq %rcx, %rdi
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movl 0x84(%rsp), %ecx
callq 0x29eb4
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x1e0, %esi            # imm = 0x1E0
movq %rbx, %rdi
callq 0x94c0
movq %r14, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::addSource(RangeSourceDriver<EbwtRangeSource>*, Range*)
void addSource(TRangeSrcDrPtr p, Range *r) {
		assert(!this->foundRange);
		this->lastRange_ = NULL;
		this->delayedRange_ = NULL;
		this->done = false;
		if(patsrc_ != NULL) {
			p->setQuery(patsrc_, r);
		}
		rss_.push_back(p);
		active_.push_back(p);
		calcPaired();
		this->minCost = 0;
		sortActives();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movb $0x0, 0x9(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x30c44
movq (%rsi), %rcx
movq %rsi, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x10(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x29fca
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x29fca
movq %rbx, %rdi
callq 0x30d06
movw $0x0, 0xa(%rbx)
movq %rbx, %rdi
callq 0x30728
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSourceFactory::create()
EbwtRangeSource *create() {
		return new EbwtRangeSource(ebwt_, fw_, qualThresh_,
		                           reportExacts_, verbose_, quiet_,
		                           halfAndHalf_, seeded_, maqPenalty_,
		                           qualOrder_, metrics_);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x188, %edi            # imm = 0x188
callq 0x94b0
movq %rax, %rbx
movq (%r14), %rsi
movzbl 0x8(%r14), %edx
movl 0xc(%r14), %ecx
movzbl 0x10(%r14), %r8d
movzbl 0x11(%r14), %r9d
movzbl 0x12(%r14), %eax
movzbl 0x13(%r14), %r10d
movzbl 0x14(%r14), %r11d
movzbl 0x15(%r14), %r15d
movzbl 0x16(%r14), %r12d
movq %rbx, %rdi
pushq 0x18(%r14)
pushq %r12
pushq %r15
pushq %r11
pushq %r10
pushq %rax
callq 0x29d28
addq $0x30, %rsp
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x188, %esi            # imm = 0x188
movq %rbx, %rdi
callq 0x94c0
movq %r14, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::calcPaired()
void calcPaired() {
		const size_t rssSz = rss_.size();
		bool saw1 = false;
		bool saw2 = false;
		for(size_t i = 0; i < rssSz; i++) {
			if(rss_[i]->mate1()) saw1 = true;
			else saw2 = true;
		}
		assert(saw1 || saw2);
		paired_ = saw1 && saw2;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x30d5c
xorl %r15d, %r15d
movl $0x1, %r13d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movzbl %bpl, %ebp
testb %al, %al
cmovnel %r13d, %ebp
movzbl %r12b, %r12d
cmovel %r13d, %r12d
incq %r15
cmpq %r15, %r14
jne 0x30d2b
andb %r12b, %bpl
andb $0x1, %bpl
jmp 0x30d5e
xorl %ebp, %ebp
movb %bpl, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./aligner.h
// Function: UnpairedAlignerV2<EbwtRangeSource>::~UnpairedAlignerV2()
virtual ~UnpairedAlignerV2() {
		delete driver_;  driver_  = NULL;
		delete params_;  params_  = NULL;
		delete rchase_;  rchase_  = NULL;
		delete[] btCnt_; btCnt_   = NULL;
		sinkPtFactory_.destroy(sinkPt_); sinkPt_ = NULL;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3948b(%rip), %rax     # 0x6a208
movq %rax, (%rdi)
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x30d92
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x80(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x30db0
movl $0x18, %esi
callq 0x94c0
movq $0x0, 0x70(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x30dcb
movl $0xc8, %esi
callq 0x94c0
movq $0x0, 0x78(%rbx)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x30de4
callq 0x95e0
movq $0x0, 0x98(%rbx)
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x68(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x1b23d
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./aligner.h
// Function: Aligner::setQuery(PatternSourcePerThread*)
virtual void setQuery(PatternSourcePerThread *patsrc) {
		assert(patsrc != NULL);
		patsrc_ = patsrc;
		bufa_ = &patsrc->bufa();
		assert(bufa_ != NULL);
		bufb_ = &patsrc->bufb();
		alen_ = bufa_->length();
		blen_ = (bufb_ != NULL) ? bufb_->length() : 0;
		rand_.init(bufa_->seed);
	}

// Assembly:
movq %rsi, 0x10(%rdi)
movq 0x18(%rsi), %rdx
imulq $0x268, 0x50(%rsi), %r8 # imm = 0x268
leaq (%rdx,%r8), %rax
movq %rax, 0x18(%rdi)
movq 0x38(%rsi), %r9
imulq $0x268, 0x50(%rsi), %rcx # imm = 0x268
addq %r9, %rcx
movq %rcx, 0x28(%rdi)
movl 0x20(%rdx,%r8), %edx
movl %edx, 0x20(%rdi)
testq %r9, %r9
je 0x31515
movl 0x20(%rcx), %ecx
jmp 0x31517
xorl %ecx, %ecx
movl %ecx, 0x30(%rdi)
movl 0x18c(%rax), %eax
movl %eax, 0x40(%rdi)
movb $0x1, 0x48(%rdi)
movl $0x1e, 0x44(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_chaser.h
// Function: RangeChaser::advance()
void advance() {
		assert(!done);
		assert(chaser_.prepped_ || chaser_.done);
		reset();
		if(chaser_.done) {
			// chaser finished with this row
			row_++;
			if(row_ == bot_) {
				row_ = top_;
			}
			if(row_ == irow_) {
				// Exhausted all possible rows
				done = true;
				assert_eq(OFF_MASK, off_.first);
				return;
			}
			setRow(row_);
			assert(chaser_.prepped_ || foundOff() || done);
		} else {
			chaser_.advance();
			assert(chaser_.prepped_ || chaser_.done);
			if(chaser_.done) {
				// We're done immediately
				off_ = chaser_.off();
				if(off_.first != OFF_MASK) {
					if(cached_) {
						// Install the result in the cache
						assert(cacheEnt_.valid());
						cacheEnt_.install(row_ - top_, chaser_.flatOff());
						//if(ebwt_->fw()) assert(cacheFw_->repOk());
						//else            assert(cacheBw_->repOk());
					}
					// Found a reference position
					tlen_ = chaser_.tlen();
					assert(foundOff());
				}
			}
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
cmpb $0x1, 0x38(%rdi)
jne 0x31564
movl 0x24(%rbx), %eax
incl %eax
movl %eax, 0x24(%rbx)
cmpl 0x1c(%rbx), %eax
jne 0x31557
movl 0x18(%rbx), %eax
movl %eax, 0x24(%rbx)
movl 0x24(%rbx), %esi
cmpl 0x20(%rbx), %esi
jne 0x315b3
movb $0x1, (%rbx)
jmp 0x315ab
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x31780
cmpb $0x1, (%r14)
jne 0x315ab
movq %r14, %rdi
callq 0x31840
movq %rax, 0x28(%rbx)
cmpl $-0x1, %eax
je 0x315ab
cmpb $0x1, 0xa8(%rbx)
jne 0x315a5
leaq 0x80(%rbx), %rdi
movl 0x24(%rbx), %esi
movl 0x70(%rbx), %edx
subl 0x18(%rbx), %esi
callq 0x31882
movl 0x74(%rbx), %eax
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x316a6
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_chaser.h
// Function: RangeChaser::setTopBot(unsigned int, unsigned int, unsigned int, RandomSource&, Ebwt const*)
void setTopBot(TIndexOffU top,
		       TIndexOffU bot,
		       TIndexOffU qlen,
	               RandomSource& rand,
	               const Ebwt* ebwt)
		{
			assert_neq(OFF_MASK, top);
			assert_neq(OFF_MASK, bot);
			assert_gt(bot, top);
			assert_gt(qlen, 0);
			assert(ebwt != NULL);
			ebwt_ = ebwt;
			qlen_ = qlen;
			top_ = top;
			bot_ = bot;
			TIndexOffU spread = bot - top;
			irow_ = top + (rand.nextU32() % spread); // initial row
			done = false;
			cached_ = false;
			reset();
			if(cacheFw_ != NULL || cacheBw_ != NULL) {
				if(spread > cacheThresh_) {
					bool ret = false;
					if(ebwt->fw() && cacheFw_ != NULL) {
						ret = cacheFw_->lookup(top, bot, cacheEnt_);
						if(ret) assert(cacheEnt_.ebwt()->fw());
					} else if(!ebwt->fw() && cacheBw_ != NULL) {
						ret = cacheBw_->lookup(top, bot, cacheEnt_);
						if(ret) assert(!cacheEnt_.ebwt()->fw());
					} else {
						cacheEnt_.reset();
					}
					assert_eq(cacheEnt_.valid(), ret);
					cached_ = ret;
				} else {
					cacheEnt_.reset();
				}
			}
			setRow(irow_);
			assert(chaser_.prepped_ || foundOff() || done);
		}

// Assembly:
pushq %rbx
movl %edx, %r10d
movq %rdi, %rbx
movq %r9, 0x8(%rdi)
movl %ecx, 0x10(%rdi)
movl %esi, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
movl %edx, %ecx
subl %esi, %ecx
movl (%r8), %edx
movl 0x4(%r8), %edi
movl 0x8(%r8), %eax
imull %edx, %eax
addl %edi, %eax
movl %eax, %r11d
shrl $0x10, %r11d
imull %edx, %eax
addl %edi, %eax
movl %eax, 0x8(%r8)
xorl %r11d, %eax
movl $0x0, 0xc(%r8)
xorl %edi, %edi
xorl %edx, %edx
divl %ecx
addl %esi, %edx
movl %edx, 0x20(%rbx)
movb %dil, (%rbx)
movb %dil, 0xa8(%rbx)
movl $0xffffffff, 0x28(%rbx) # imm = 0xFFFFFFFF
movq 0xb0(%rbx), %rax
movq 0xb8(%rbx), %rdi
movq %rax, %rdx
orq %rdi, %rdx
je 0x31699
cmpl 0x14(%rbx), %ecx
jbe 0x3166b
testq %rax, %rax
sete %dl
movb 0x10(%r9), %cl
movl %ecx, %r8d
xorb $0x1, %r8b
orb %dl, %r8b
je 0x31678
testq %rdi, %rdi
sete %al
orb %al, %cl
je 0x31684
movq $0x0, 0x90(%rbx)
xorl %eax, %eax
jmp 0x31693
movq $0x0, 0x90(%rbx)
jmp 0x31699
leaq 0x80(%rbx), %rcx
movq %rax, %rdi
jmp 0x3168b
leaq 0x80(%rbx), %rcx
movl %r10d, %edx
callq 0x3259a
movb %al, 0xa8(%rbx)
movl 0x20(%rbx), %esi
movq %rbx, %rdi
popq %rbx
jmp 0x316a6
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./row_chaser.h
// Function: RowChaser::advance()
void advance() {
		// Advance by 1
		assert(!done);
		while(!done) {
			assert(prepped_);
			prepped_ = false;
			if(metrics_ != NULL) metrics_->curBwtOps_++;
			uint64_t newrow = ebwt_->mapLF(sideloc_);
			ASSERT_ONLY(sideloc_.invalidate());
			jumps_++;
			assert_neq(newrow, row_);
			// Update row_ field
			row_ = newrow;
			if(row_ == ebwt_->_zOff) {
				// We arrived at the extreme left-hand end of the reference
				off_ = jumps_;
				done = true;
			} else if((row_ & eh_->_offMask) == row_) {
				// We arrived at a marked row
				off_ = ebwt_->_offs[row_ >> eh_->_offRate] + jumps_;
				done = true;
			}
			prep();
		}
	}

// Assembly:
cmpb $0x0, (%rdi)
jne 0x3183e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movb $0x0, 0x1(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x317a4
incl 0x4(%rax)
movq 0x8(%rbx), %rdi
movl 0x28(%rbx), %eax
addq 0xb8(%rdi), %rax
movswq 0x34(%rbx), %rcx
movzbl (%rcx,%rax), %edx
movb 0x36(%rbx), %cl
addb %cl, %cl
shrl %cl, %edx
andl $0x3, %edx
cmpb $0x1, 0x32(%rbx)
jne 0x317de
cmpb $0x0, 0x17d(%rdi)
je 0x317e8
movq %r14, %rsi
callq 0x1d6b6
jmp 0x317f0
movq %r14, %rsi
callq 0x1d872
jmp 0x317f0
movq %r14, %rsi
callq 0x1d4e6
movl 0x24(%rbx), %edx
incl %edx
movl %edx, 0x24(%rbx)
movl %eax, 0x20(%rbx)
movq 0x8(%rbx), %rsi
cmpl 0x68(%rsi), %eax
je 0x31820
movq 0x18(%rbx), %rcx
movl 0x20(%rcx), %edi
notl %edi
testl %edi, %eax
jne 0x31826
movb 0x1c(%rcx), %cl
shrl %cl, %eax
movq 0xa8(%rsi), %rcx
addl (%rcx,%rax,4), %edx
movl %edx, 0x38(%rbx)
movb $0x1, (%rbx)
movq %rbx, %rdi
callq 0x31ad6
cmpb $0x1, (%rbx)
jne 0x31794
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_cache.h
// Function: RangeCacheEntry::install(unsigned int, unsigned int)
void install(TIndexOffU elt, TIndexOffU val) {
		if(ents_ == NULL) {
			// This is not a valid cache entry; do nothing
			return;
		}
		assert(ents_ != NULL);
		assert(ebwt_ != NULL);
		assert_leq(jumps_, val);
		assert_neq(OFF_MASK, val);
		assert_leq(top_ + len_, ebwt_->_eh._len);
		if(elt < len_) {
			val -= jumps_;
			if(verbose_) cout << "Installed reference offset: " << (top_ + elt) << endl;
			ASSERT_ONLY(TIndexOffU sanity = RowChaser::toFlatRefOff(ebwt_, 1, top_ + elt));
			assert_eq(sanity, val);
#ifndef NDEBUG
			for(size_t i = 0; i < len_; i++) {
				if(i == elt) continue;
				assert_neq(val, ents_[i]);
			}
#endif
			ents_[elt] = val;
		} else {
			// ignore install request
			if(verbose_) cout << "Fell off end of cache entry for install: " << (top_ + elt) << endl;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
je 0x3196c
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, 0x8(%rdi)
jbe 0x31908
movl %edx, %ebp
subl 0x4(%r14), %ebp
cmpb $0x1, 0x20(%r14)
jne 0x318fd
movq 0x396fe(%rip), %r15     # 0x6afb0
leaq 0x2520c(%rip), %rsi     # 0x56ac5
movl $0x1c, %edx
movq %r15, %rdi
callq 0x9560
movl (%r14), %esi
addl %ebx, %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r15, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
movq 0x10(%r14), %rax
movl %ebx, %ecx
movl %ebp, (%rax,%rcx,4)
jmp 0x3196c
cmpb $0x1, 0x20(%r14)
jne 0x3196c
movq 0x3969a(%rip), %r15     # 0x6afb0
leaq 0x251c5(%rip), %rsi     # 0x56ae2
movl $0x29, %edx
movq %r15, %rdi
callq 0x9560
addl (%r14), %ebx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x92e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9050
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x92f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./range_cache.h
// Function: RangeCacheEntry::get(unsigned int) const
inline TIndexOffU get(TIndexOffU elt) const {
		if(ents_ == NULL) {
			// This is not a valid cache entry; do nothing
			return RANGE_NOT_SET;
		}
		assert(ents_ != NULL);
		assert(ebwt_ != NULL);
		assert_leq(top_ + len_, ebwt_->_eh._len);
		if(elt < len_ && ents_[elt] != RANGE_NOT_SET) {
			if(verbose_) cout << "Retrieved result from cache: " << (top_ + elt) << endl;
			TIndexOffU ret = ents_[elt] + jumps_;
			ASSERT_ONLY(TIndexOffU sanity = RowChaser::toFlatRefOff(ebwt_, 1, top_ + elt));
			assert_eq(sanity, ret);
			return ret;
		} else {
			if(verbose_) cout << "Cache entry not set: " << (top_ + elt) << endl;
			return RANGE_NOT_SET;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x31a66
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jbe 0x31a0d
movl %r14d, %r12d
cmpl $-0x1, (%rax,%r12,4)
je 0x31a0d
cmpb $0x1, 0x20(%rbx)
jne 0x31a00
movq 0x395fc(%rip), %r15     # 0x6afb0
leaq 0x250d6(%rip), %rsi     # 0x56a91
movl $0x1d, %edx
movq %r15, %rdi
callq 0x9560
addl (%rbx), %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x92e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
movq 0x10(%rbx), %rax
movl 0x4(%rbx), %ebp
addl (%rax,%r12,4), %ebp
jmp 0x31a66
cmpb $0x1, 0x20(%rbx)
jne 0x31a66
movq 0x39596(%rip), %r15     # 0x6afb0
leaq 0x2508e(%rip), %rsi     # 0x56aaf
movl $0x15, %edx
movq %r15, %rdi
callq 0x9560
addl (%rbx), %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x92e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./row_chaser.h
// Function: RowChaser::setRow(unsigned int, unsigned int, Ebwt const*)
void setRow(TIndexOffU row, TIndexOffU qlen, const Ebwt* ebwt) {
		assert_neq(OFF_MASK, row);
		assert_gt(qlen, 0);
		assert(ebwt != NULL);
		ebwt_ = ebwt;
		eh_ = &ebwt->_eh;
		row_ = row;
		qlen_ = qlen;
		ASSERT_ONLY(sideloc_.invalidate());
		if(row_ == ebwt_->_zOff) {
			// We arrived at the extreme left-hand end of the reference
			off_ = 0;
			done = true;
			return;
		} else if((row_ & eh_->_offMask) == row_) {
			// We arrived at a marked row
			off_ = ebwt_->_offs[row_ >> eh_->_offRate];
			done = true;
			return;
		}
		done = false;
		jumps_ = 0;
		off_ = OFF_MASK;
		prepped_ = false;
		prep();
	}

// Assembly:
movq %rcx, %rax
movq %rcx, 0x8(%rdi)
addq $0xf8, %rcx
movq %rcx, 0x18(%rdi)
movl %esi, 0x20(%rdi)
movl %edx, 0x10(%rdi)
cmpl %esi, 0x68(%rax)
jne 0x31a98
movl $0x0, 0x38(%rdi)
jmp 0x31ab9
movl 0x118(%rax), %ecx
notl %ecx
testl %ecx, %esi
jne 0x31abd
movb 0x114(%rax), %cl
shrl %cl, %esi
movq 0xa8(%rax), %rax
movl (%rax,%rsi,4), %eax
movl %eax, 0x38(%rdi)
movb $0x1, (%rdi)
retq
movw $0x0, (%rdi)
movl $0x0, 0x24(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
jmp 0x31ad6
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./row_chaser.h
// Function: RowChaser::prep()
void prep() {
		if(!done) {
			assert(!prepped_);
			assert(!sideloc_.valid());
			assert_leq(row_, eh_->_len);
			sideloc_.initFromRow(row_, *eh_, (const uint8_t*)ebwt_->_ebwt);
			assert(sideloc_.valid());
		}
		prepped_ = true;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x31afa
leaq 0x28(%rbx), %rdi
movl 0x20(%rbx), %esi
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdx
movq 0xb8(%rax), %rcx
callq 0x1b2d0
movb $0x1, 0x1(%rbx)
popq %rbx
retq