LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x267bc
leaq 0x2c(%rbx), %r8
leaq 0x3c(%rbx), %r9
movl %eax, %edi
callq 0x238ee
jmp 0x267cf
cmpl %eax, %esi
jbe 0x267cf
leaq 0x2c(%rbx), %rdi
movl %eax, %esi
callq 0x15ee4
movb $-0x1, 0x4a(%rbx)
movb $0x1, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x250e8
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 0x26a14
movq 0x30(%rbx), %rdi
cmpb $0x0, 0x8(%rdi)
jne 0x269e9
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0x269f5
movzwl 0x8(%r14), %eax
jmp 0x269f7
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::AllocOnlyPool(ChunkPool*, char const*)
AllocOnlyPool(ChunkPool* pool, const char *name) :
		pool_(pool), name_(name), curPool_(0), cur_(0)
	{
		assert(pool != NULL);
		lim_ = pool->chunkSize() / sizeof(T);
		assert_gt(lim_, 0);
		assert_gt(lim_, 1024);
	}

// Assembly:
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movl $0x80, %ecx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
andl $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
andl $0x0, 0x5c(%rdi)
movl 0x14(%rsi), %eax
movl $0x88, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, 0x58(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSourceDriver::cextToDepth(SearchConstraintExtent, unsigned int, unsigned int, unsigned int)
inline uint32_t cextToDepth(SearchConstraintExtent cext,
	                            uint32_t sRight,
	                            uint32_t s,
	                            uint32_t len)
	{
		if(cext == PIN_TO_SEED_EDGE)    return s;
		if(cext == PIN_TO_HI_HALF_EDGE) return sRight;
		if(cext == PIN_TO_BEGINNING)    return 0;
		if(cext == PIN_TO_LEN)          return len;
		cerr << "Bad SearchConstraintExtent: " << cext;
		throw 1;
	}

// Assembly:
pushq %rbx
movl %esi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
ja 0x270da
leaq 0x20352(%rip), %rsi     # 0x47414
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
xorl %ecx, %ecx
jmp 0x270d6
movl %r8d, %ecx
jmp 0x270d6
movl %edx, %ecx
movl %ecx, %eax
popq %rbx
retq
movq 0x3af0f(%rip), %rdi     # 0x61ff0
leaq 0x239a5(%rip), %rsi     # 0x4aa8d
callq 0x94e0
movq %rax, %rdi
movl %ebx, %esi
callq 0x9930
pushq $0x4
popq %rdi
callq 0x9220
movl $0x1, (%rax)
movq 0x3ae4c(%rip), %rsi     # 0x61f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x9910
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39cbd(%rip), %rax     # 0x61190
movq %rax, (%rdi)
movq 0x28(%rdi), %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x274fa
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x274f5
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
jmp 0x274dd
leaq 0x10(%rbx), %r14
andq $0x0, 0x28(%rbx)
andq $0x0, 0x48(%rbx)
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x271de
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x271de
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andw $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 0x275d6
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x275af
movq 0x18(%rbx), %rax
movq (%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
incq %rbp
jmp 0x27591
leaq 0x30(%rbx), %rdi
movq %r12, %rsi
callq 0x27766
andw $0x0, 0xa(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x277d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x70(%rdi)
movq 0x48(%rdi), %r14
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0x27641
movq %rax, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
movb $0x1, 0x8(%rbx)
testq %r14, %r14
je 0x2765c
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 0x27660
movl %esi, %ebp
movq %rbx, %rdi
callq 0x2796a
xorb $0x1, %al
testq %r14, %r14
setne %cl
testb %al, %cl
jne 0x2766b
andq $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
movb 0x8(%r14), %al
testb %al, %al
jne 0x2768e
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *0x20(%rax)
movb 0x8(%r14), %al
testb $0x1, %al
je 0x276ad
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x279c6
movb $0x0, 0x8(%r14)
jmp 0x276af
xorl %eax, %eax
cmpb $0x0, 0x9(%r14)
jne 0x276c4
cmpw 0xa(%r14), %r15w
sete %cl
notb %al
testb %cl, %al
jne 0x27660
movq %rbx, %rdi
callq 0x277d6
movq %rbx, %rdi
callq 0x2796a
testb %al, %al
jne 0x276df
cmpq $0x0, 0x48(%rbx)
jne 0x27660
andq $0x0, 0x48(%rbx)
cmpq $0x0, 0x78(%rbx)
sete 0x9(%rbx)
jmp 0x27660
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x48(%rbx), %r14
jae 0x27754
cmpl $0x1, %ebp
setne %r15b
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpb %al, %r15b
je 0x2774f
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rax
movb $0x1, 0x9(%rax)
incq %r14
jmp 0x27723
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x277d6
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::sortActives()
void sortActives() {
		TRangeSrcDrPtrVec& vec = active_;
		size_t sz = vec.size();
		// Selection sort / removal outer loop
		for(size_t i = 0; i < sz;) {
			// Remove elements that we're done with
			if(vec[i]->done && !vec[i]->foundRange) {
				vec.erase(i);
				if(sz == 0) break;
				else sz--;
				continue;
			}
			uint16_t minCost = vec[i]->minCost;
			size_t minOff = i;
			// Selection sort inner loop
			for(size_t j = i+1; j < sz; j++) {
				if(vec[j]->done && !vec[j]->foundRange) {
					// We'll get rid of this guy later
					continue;
				}
				if(vec[j]->minCost < minCost) {
					minCost = vec[j]->minCost;
					minOff = j;
				} else if(vec[j]->minCost == minCost) {
					// Possibly randomly pick the other
					if(rand_.nextU32() & 0x1000) {
						minOff = j;
					}
				}
			}
			// Do the swap, if necessary
			if(i != minOff) {
				assert_leq(minCost, vec[i]->minCost);
				TRangeSrcDrPtr tmp = vec[i];
				vec[i] = vec[minOff];
				vec[minOff] = tmp;
			}
			i++;
		}
		if(delayedRange_ == NULL && sz > 0) {
			assert_geq(this->minCost, this->minCostAdjustment_);
			assert_geq(vec[0]->minCost, this->minCost);
			this->minCost = vec[0]->minCost;
		}
		assert(sortedActives());
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq 0x48(%rdi), %r14
leaq 0x58(%rdi), %rax
movq %rax, 0x10(%rsp)
movq $0x0, (%rsp)
movq %r15, 0x8(%rsp)
movq (%rsp), %rbp
movq %r14, %r13
cmpq %r13, %rbp
jae 0x278c5
movq 0x38(%rbx), %rax
movq (%rax,%rbp,8), %rax
cmpb $0x1, 0x9(%rax)
jne 0x27839
cmpb $0x0, 0x8(%rax)
jne 0x27839
movq %r15, %rdi
movq %rbp, %rsi
callq 0x27946
decq %r13
jmp 0x2780c
movzwl 0xa(%rax), %r14d
leaq 0x1(%rbp), %r15
movq %rbp, %r12
movq %r15, (%rsp)
cmpq %r13, %r15
jae 0x27894
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpb $0x1, 0x9(%rax)
jne 0x27862
cmpb $0x1, 0x8(%rax)
jne 0x27883
movzwl 0xa(%rax), %eax
movq %r15, %rcx
cmpw %r14w, %ax
jb 0x27889
jne 0x27883
movq 0x10(%rsp), %rdi
callq 0x264f6
btl $0xc, %eax
cmovbq %r15, %r12
movl %r14d, %eax
movq %r12, %rcx
incq %r15
movl %eax, %r14d
movq %rcx, %r12
jmp 0x27849
movq %r13, %r14
cmpq %r12, %rbp
movq 0x8(%rsp), %r15
je 0x27805
movq 0x38(%rbx), %rax
movq (%rax,%rbp,8), %rcx
movq (%rax,%r12,8), %rdx
movq %rdx, (%rax,%rbp,8)
movq 0x38(%rbx), %rax
movq %rcx, (%rax,%r12,8)
movq %r13, %r14
jmp 0x27805
cmpq %rbp, %r14
cmovbq %r14, %rbp
testq %rbp, %rbp
je 0x278e7
cmpq $0x0, 0x78(%rbx)
jne 0x278e7
movq 0x38(%rbx), %rax
movq (%rax), %rax
movzwl 0xa(%rax), %eax
movw %ax, 0xa(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x279ad
movq %rdi, %r14
movq 0x48(%rdi), %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x279b1
movq 0x38(%r14), %rax
movq (%rax,%r13,8), %rdi
cmpb $0x0, 0x9(%rdi)
jne 0x279a8
movq (%rdi), %rax
callq *0x38(%rax)
orb %al, %bl
xorb $0x1, %al
orb %al, %r12b
incq %r13
jmp 0x27988
xorl %ebx, %ebx
jmp 0x279b7
andb %r12b, %bl
xorb $0x1, %bl
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x27b1a
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x27b15
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
jmp 0x27afd
andq $0x0, 0x28(%rbx)
andq $0x0, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27c76
movq (%rsi), %rcx
movq %rsi, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x10(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x21d12
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x21d12
movq %rbx, %rdi
callq 0x27d36
andw $0x0, 0xa(%rbx)
movq %rbx, %rdi
callq 0x277d6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9500
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 0x21aee
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 0x9510
movq %r14, %rdi
callq 0x9950
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
xorl %r14d, %r14d
pushq $0x1
popq %r12
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x27d79
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
orb %al, %r14b
movzbl %bpl, %ebp
testb %al, %al
cmovel %r12d, %ebp
incq %r13
jmp 0x27d54
andb %bpl, %r14b
andb $0x1, %r14b
movb %r14b, 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_O2/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 0x3942d(%rip), %rax     # 0x61208
movq %rax, (%rdi)
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x27df0
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x80(%rbx)
movq 0x70(%rbx), %rdi
pushq $0x18
popq %rsi
callq 0x9510
andq $0x0, 0x70(%rbx)
movq 0x78(%rbx), %rdi
movl $0xc8, %esi
callq 0x9510
andq $0x0, 0x78(%rbx)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x27e2d
callq 0x9610
andq $0x0, 0x98(%rbx)
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
andq $0x0, 0x68(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x15e2d
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: UnpairedAlignerV2<EbwtRangeSource>::setQuery(PatternSourcePerThread*)
virtual void setQuery(PatternSourcePerThread* patsrc) {
		Aligner::setQuery(patsrc); // set fields & random seed
		if(metrics_ != NULL) {
			metrics_->nextRead(patsrc->bufa().patFw);
		}
		pool_->reset(&patsrc->bufa().name, (uint32_t)patsrc->rdid());
		if(patsrc->bufa().length() < 4) {
			if(!quiet_) {
				cerr << "Warning: Skipping read " << patsrc->bufa().name
				     << " because it is less than 4 characters long" << endl;
			}
			this->done = true;
			sinkPt_->finishRead(*patsrc_, true, true);
			return;
		}
		driver_->setQuery(patsrc, NULL);
		this->done = driver_->done;
		doneFirst_ = false;
		// Reset #-backtrack countdown
		if(btCnt_ != NULL) *btCnt_ = maxBts_;
		if(sinkPt_->setHits(patsrc->bufa().hitset)) {
			this->done = true;
			sinkPt_->finishRead(*patsrc_, true, true);
		}
		// Grab a bit from the pseudo-random seed to determine whether
		// to start with forward or reverse complement
		firstIsFw_ = ((patsrc->bufa().seed & 0x10) == 0);
		chase_ = false;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x28196
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x2804e
imulq $0x268, 0x50(%r14), %rsi # imm = 0x268
addq 0x18(%r14), %rsi
callq 0x2962c
movq 0x90(%rbx), %rdi
movq 0x18(%r14), %rax
movq 0x50(%r14), %rdx
imulq $0x268, %rdx, %rcx      # imm = 0x268
leaq (%rax,%rcx), %rsi
addq $0x150, %rsi            # imm = 0x150
addl 0x58(%r14), %edx
callq 0x296ac
movq 0x18(%r14), %rax
imulq $0x268, 0x50(%r14), %rcx # imm = 0x268
cmpq $0x3, 0x20(%rax,%rcx)
ja 0x280ff
cmpb $0x0, 0x89(%rbx)
jne 0x280de
movq 0x39f54(%rip), %rdi     # 0x61ff0
leaq 0x22b00(%rip), %rsi     # 0x4aba3
callq 0x94e0
movq 0x18(%r14), %rcx
imulq $0x268, 0x50(%r14), %rdx # imm = 0x268
leaq (%rcx,%rdx), %rsi
addq $0x150, %rsi            # imm = 0x150
movq %rax, %rdi
callq 0x1970d
leaq 0x22eb9(%rip), %rsi     # 0x4af87
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rsi
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
pushq $0x1
popq %rcx
movl %ecx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
xorl %edx, %edx
callq *0x10(%rax)
movq 0x80(%rbx), %rcx
movq 0x98(%rbx), %rax
movb 0x9(%rcx), %cl
movb %cl, 0x8(%rbx)
movb $0x0, 0x58(%rbx)
testq %rax, %rax
je 0x28136
movl 0x8c(%rbx), %ecx
movl %ecx, (%rax)
movq 0x68(%rbx), %rdi
movq 0x18(%r14), %rax
imulq $0x268, 0x50(%r14), %rcx # imm = 0x268
leaq (%rax,%rcx), %rsi
addq $0x1b0, %rsi            # imm = 0x1B0
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x28172
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rsi
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rcx
movl %ecx, %edx
callq *0x10(%rax)
movq 0x18(%r14), %rax
imulq $0x268, 0x50(%r14), %rcx # imm = 0x268
testb $0x10, 0x18c(%rax,%rcx)
sete 0x59(%rbx)
movb $0x0, 0x5a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x281d3
movl 0x20(%rcx), %ecx
jmp 0x281d5
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_O2/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
orl $-0x1, 0x28(%rdi)
cmpb $0x1, 0x38(%rdi)
jne 0x2821c
movl 0x24(%rbx), %esi
incl %esi
movl %esi, 0x24(%rbx)
cmpl 0x1c(%rbx), %esi
jne 0x28212
movl 0x18(%rbx), %esi
movl %esi, 0x24(%rbx)
cmpl 0x20(%rbx), %esi
jne 0x2826b
movb $0x1, (%rbx)
jmp 0x28263
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x28534
cmpb $0x1, (%r14)
jne 0x28263
movq %r14, %rdi
callq 0x285a8
movq %rax, 0x28(%rbx)
cmpl $-0x1, %eax
je 0x28263
cmpb $0x1, 0xa8(%rbx)
jne 0x2825d
leaq 0x80(%rbx), %rdi
movl 0x24(%rbx), %esi
movl 0x70(%rbx), %edx
subl 0x18(%rbx), %esi
callq 0x285e8
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 0x28452
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: UnpairedAlignerV2<EbwtRangeSource>::report(Range const&, unsigned int, unsigned int, unsigned int)
inline bool report(const Range& ra,
			TIndexOffU first,
			TIndexOffU second,
	                   uint32_t tlen)
	{
		bool ebwtFw = ra.ebwt->fw();
		params_->setFw(ra.fw);
		return params_->reportHit(
				ra.fw ? (ebwtFw? bufa_->patFw    : bufa_->patFwRev) :
				        (ebwtFw? bufa_->patRc    : bufa_->patRcRev),
				ra.fw ? (ebwtFw? &bufa_->qual    : &bufa_->qualRev) :
				        (ebwtFw? &bufa_->qualRev : &bufa_->qual),
				&bufa_->name,
				ebwtFw,
				ra.mms,                   // mismatch positions
				ra.refcs,                 // reference characters for mms
				ra.numMms,                // # mismatches
				make_pair(first, second), // position
				make_pair<TIndexOffU,TIndexOffU>(0, 0),          // (bogus) mate position
				true,                     // (bogus) mate orientation
				0,                        // (bogus) mate length
				make_pair(ra.top, ra.bot),// arrows
				tlen,                     // textlen
				alen_,                    // qlen
				ra.stratum,               // alignment stratum
				ra.cost,                  // cost, including qual penalty
				ra.bot - ra.top - 1,      // # other hits
				(uint32_t)patsrc_->rdid(),// pattern id
				bufa_->seed,              // pseudo-random seed
				0);                       // mate (0 = unpaired)
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movl %edx, %r11d
movq 0x58(%rsi), %rdx
movzbl 0x10(%rdx), %r8d
movq 0x70(%rdi), %rdx
movb 0x14(%rsi), %r9b
movb %r9b, 0x14(%rdx)
movq 0x70(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rdi), %r15
xorl %edx, %edx
testl %r8d, %r8d
movl $0x90, %r14d
cmovneq %rdx, %r14
pushq $0x30
popq %rdx
movl $0xc0, %r10d
cmovneq %rdx, %r10
movq 0x18(%rdi), %r12
testb %r9b, %r9b
cmovneq %r14, %r10
xorb %r8b, %r9b
addq %r12, %r10
leaq 0x60(%r12), %rdx
leaq 0xf0(%r12), %r14
testb %r9b, %r9b
cmovneq %r14, %rdx
leaq 0x18(%rsi), %r9
leaq 0x38(%rsi), %rax
movq %rax, 0x18(%rsp)
shlq $0x20, %rcx
movl %r11d, %r11d
orq %rcx, %r11
movl (%rsi), %ebp
movl 0x4(%rsi), %ecx
movq %rcx, %r13
shlq $0x20, %r13
orq %rbp, %r13
notl %ebp
addl %ecx, %ebp
movl 0x50(%r15), %eax
addl 0x58(%r15), %eax
movl 0x10(%rsi), %ecx
movq %rcx, 0x8(%rsp)
movl 0x20(%rdi), %r15d
movl 0xc(%rsi), %ebx
movzwl 0x8(%rsi), %r14d
leaq 0x150(%r12), %rcx
movl 0x18c(%r12), %r12d
subq $0x8, %rsp
movq 0x18(%rsp), %rdi
movq %r10, %rsi
pushq $0x0
pushq %r12
pushq %rax
pushq %rbp
pushq %r14
pushq %rbx
pushq %r15
pushq 0x60(%rsp)
pushq %r13
pushq $0x0
pushq $0x1
pushq $0x0
pushq %r11
pushq 0x78(%rsp)
pushq 0x90(%rsp)
callq 0x287a4
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r15
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq %r9, 0x8(%rdi)
movl %ecx, 0x10(%rdi)
movl %esi, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
movl %edx, %r12d
subl %esi, %r12d
movq %r8, %rdi
callq 0x264f6
xorl %ecx, %ecx
xorl %edx, %edx
divl %r12d
addl %r14d, %edx
movl %edx, 0x20(%rbx)
movb %cl, (%rbx)
movb %cl, 0xa8(%rbx)
orl $-0x1, 0x28(%rbx)
movq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rax
movq %rdi, %rcx
orq %rax, %rcx
je 0x28440
cmpl 0x14(%rbx), %r12d
jbe 0x28408
cmpb $0x1, 0x10(%r15)
jne 0x28412
testq %rdi, %rdi
je 0x2842d
leaq 0x80(%rbx), %rcx
jmp 0x28421
andq $0x0, 0x90(%rbx)
jmp 0x28440
testq %rax, %rax
je 0x2842d
leaq 0x80(%rbx), %rcx
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x28f2a
jmp 0x28437
andq $0x0, 0x90(%rbx)
xorl %eax, %eax
movb %al, 0xa8(%rbx)
movl 0x20(%rbx), %edx
movq %rbx, %rdi
movl %edx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x28452
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
cmpb $0x0, (%rbx)
jne 0x285a0
movb $0x0, 0x1(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x28554
incl 0x4(%rax)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x15eac
movl 0x24(%rbx), %edx
incl %edx
movl %edx, 0x24(%rbx)
movl %eax, 0x20(%rbx)
movq 0x8(%rbx), %rsi
cmpl 0x68(%rsi), %eax
je 0x28590
movq 0x18(%rbx), %rcx
movl 0x20(%rcx), %edi
notl %edi
testl %edi, %eax
jne 0x28596
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 0x2877a
jmp 0x2853f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x28673
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, 0x8(%rdi)
jbe 0x2863f
movl %edx, %ebp
subl 0x4(%r14), %ebp
cmpb $0x1, 0x20(%r14)
jne 0x28638
movq 0x3999d(%rip), %rdi     # 0x61fb0
leaq 0x224f6(%rip), %rsi     # 0x4ab10
callq 0x94e0
movl (%r14), %esi
addl %ebx, %esi
movq %rax, %rdi
callq 0x9310
movq %rax, %rdi
callq 0x9210
movq 0x10(%r14), %rax
movl %ebx, %ecx
movl %ebp, (%rax,%rcx,4)
jmp 0x28673
cmpb $0x1, 0x20(%r14)
jne 0x28673
movq 0x39963(%rip), %rdi     # 0x61fb0
leaq 0x224d9(%rip), %rsi     # 0x4ab2d
callq 0x94e0
addl (%r14), %ebx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9310
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9210
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq 0x10(%rdi), %rax
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0x28713
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jbe 0x286e4
movl %r14d, %r15d
movl (%rax,%r15,4), %eax
cmpl $-0x1, %eax
je 0x286e4
cmpb $0x1, 0x20(%rbx)
jne 0x286dd
movq 0x398fd(%rip), %rdi     # 0x61fb0
leaq 0x22422(%rip), %rsi     # 0x4aadc
callq 0x94e0
addl (%rbx), %r14d
movq %rax, %rdi
movq %r14, %rsi
callq 0x9310
movq %rax, %rdi
callq 0x9210
movq 0x10(%rbx), %rax
movl (%rax,%r15,4), %eax
addl 0x4(%rbx), %eax
movl %eax, %ebp
jmp 0x28713
cmpb $0x1, 0x20(%rbx)
jne 0x28713
movq 0x398bf(%rip), %rdi     # 0x61fb0
leaq 0x22402(%rip), %rsi     # 0x4aafa
callq 0x94e0
addl (%rbx), %r14d
movq %rax, %rdi
movq %r14, %rsi
callq 0x9310
movq %rax, %rdi
callq 0x9210
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28743
andl $0x0, 0x38(%rdi)
jmp 0x28764
movl 0x118(%rax), %ecx
notl %ecx
testl %ecx, %esi
jne 0x28768
movb 0x114(%rax), %cl
shrl %cl, %esi
movq 0xa8(%rax), %rax
movl (%rax,%rsi,4), %eax
movl %eax, 0x38(%rdi)
movb $0x1, (%rdi)
retq
andw $0x0, (%rdi)
andl $0x0, 0x24(%rdi)
orl $-0x1, 0x38(%rdi)
jmp 0x2877a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2879e
leaq 0x28(%rbx), %rdi
movl 0x20(%rbx), %esi
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdx
movq 0xb8(%rax), %rcx
callq 0x15ee4
movb $0x1, 0x1(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset<1024>::set(unsigned int)
void set(TIndexOffU i) {
		// Fast path
		assert_lt(i, LEN);
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 0);
		_words[i / WORD_SIZE] |= ((TIndexOffU)1 << (i & BITSET_MASK));
		_cnt++;
		if(i >= _size) {
			_size = i+1;
		}
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 1);
	}

// Assembly:
movl %esi, %ecx
pushq $0x1
popq %rax
shll %cl, %eax
movl %esi, %edx
shrl $0x5, %edx
orl %eax, 0x8(%rdi,%rdx,4)
incl (%rdi)
cmpl %esi, 0x4(%rdi)
ja 0x28de2
incl %ecx
movl %ecx, 0x4(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset<1024>::operator!=(FixedBitset<1024> const&) const
bool operator!= (const FixedBitset<LEN>& that) const {
		for(TIndexOffU i = 0; i < (LEN / WORD_SIZE)+1; i++) {
			if(_words[i] != that._words[i]) {
				return true;
			}
		}
		return false;
	}

// Assembly:
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x21, %rcx
je 0x28dfd
movl 0x8(%rdi,%rax,4), %edx
leaq 0x1(%rax), %rcx
cmpl 0x8(%rsi,%rax,4), %edx
je 0x28de6
cmpq $0x21, %rax
setb %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset<1024>::str[abi:cxx11]() const
std::string str() const {
		std::ostringstream oss;
		for(int i = (int)size()-1; i >= 0; i--) {
			oss << (test(i)? "1" : "0");
		}
		return oss.str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x9660
movl 0x4(%r14), %ebp
leaq 0x23729(%rip), %r12     # 0x4c55c
leaq 0x1fa33(%rip), %r13     # 0x4886d
testl %ebp, %ebp
jle 0x28e5f
decl %ebp
movl %ebp, %eax
shrl $0x5, %eax
movl 0x8(%r14,%rax,4), %eax
btl %ebp, %eax
movq %r12, %rsi
jae 0x28e55
movq %r13, %rsi
movq %r15, %rdi
callq 0x94e0
jmp 0x28e3a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x97f0
movq %rsp, %rdi
callq 0x9110
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28e8b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9110
movq %rbx, %rdi
callq 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_cache.h
// Function: RangeCache::lookup(unsigned int, unsigned int, RangeCacheEntry&)
bool lookup(TIndexOffU top, TIndexOffU bot, RangeCacheEntry& ent) {
		if(ebwt_ == NULL || lim_ == 0) return false;
		assert_gt(bot, top);
		ent.reset();
		TMapItr itr = map_.find(top);
		if(itr == map_.end()) {
			// No cache entry for the given 'top' offset
			if(closed_) {
				return false; // failed to get cache entry
			} else {
				if(pool_.closed()) {
					closed_ = true;
					return false; // failed to get cache entry
				}
			}
			// Use the tunnel
			bool ret = tunnel(top, bot, ent);
			return ret;
		} else {
			// There is a cache entry for the given 'top' offset
			TIndexOffU ret = itr->second;
			ent.init(pool_, top, ret, ebwt_);
			return true; // success
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x58(%rdi)
je 0x28fae
movq %rdi, %r14
cmpl $0x0, (%rdi)
je 0x28fae
movq %rcx, %rbx
movl %edx, %ebp
andq $0x0, 0x10(%rcx)
leaq 0x8(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2930c
leaq 0x10(%r14), %rcx
cmpq %rcx, %rax
je 0x28f86
movl 0x24(%rax), %ecx
movl 0xc(%rsp), %edx
movq 0x58(%r14), %r8
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x292ce
movb $0x1, %al
jmp 0x28fae
cmpb $0x0, 0x50(%r14)
jne 0x28f99
cmpb $0x1, 0x48(%r14)
jne 0x28f9d
movb $0x1, 0x50(%r14)
xorl %eax, %eax
jmp 0x28fae
movl 0xc(%rsp), %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x28fb8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner_metrics.h
// Function: AlignerMetrics::nextRead(SDnaStringExpandable<25, 2> const&)
void nextRead(const BTDnaString& read) {
		if(!first_) {
			finishRead();
		}
		first_ = false;
		float ent = entropyDna5(read);
		curIsLowEntropy_ = (ent < 0.75f);
		curIsHomoPoly_ = (ent < 0.001f);
		curHadRanges_ = false;
		curBwtOps_ = 0;
		curBacktracks_ = 0;
		// Count Ns
		curNumNs_ = 0;
		const size_t len = read.length();
		for(size_t i = 0; i < len; i++) {
			if((int)read[i] == 4) curNumNs_++;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x8(%rdi)
jne 0x29645
movq %r14, %rdi
callq 0x296c0
xorl %r15d, %r15d
movb %r15b, 0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29830
movss 0x1ddad(%rip), %xmm1    # 0x4740c
ucomiss %xmm0, %xmm1
seta 0x9(%r14)
movss 0x1dda1(%rip), %xmm1    # 0x47410
ucomiss %xmm0, %xmm1
seta 0xa(%r14)
movb %r15b, 0xb(%r14)
andq $0x0, (%r14)
andl $0x0, 0xc(%r14)
movq 0x20(%rbx), %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x296a5
movq 0x8(%rbx), %rdx
cmpb $0x4, (%rdx,%rcx)
jne 0x296a0
incl %r15d
movl %r15d, 0xc(%r14)
incq %rcx
jmp 0x2968a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner_metrics.h
// Function: AlignerMetrics::entropyDna5(SDnaStringExpandable<25, 2> const&)
inline float entropyDna5(const BTDnaString& read) {
		size_t cs[5] = {0, 0, 0, 0, 0};
		size_t readLen = read.length();
		for(size_t i = 0; i < readLen; i++) {
			int c = (int)read[i];
			assert_lt(c, 5);
			assert_geq(c, 0);
			cs[c]++;
		}
		if(cs[4] > 0) {
			// Charge the Ns to the non-N character with maximal count and
			// then exclude them from the entropy calculation (i.e.,
			// penalize Ns as much as possible)
			if(cs[0] >= cs[1] && cs[0] >= cs[2] && cs[0] >= cs[3]) {
				// Charge Ns to As
				cs[0] += cs[4];
			} else if(cs[1] >= cs[2] && cs[1] >= cs[3]) {
				// Charge Ns to Cs
				cs[1] += cs[4];
			} else if(cs[2] >= cs[3]) {
				// Charge Ns to Gs
				cs[2] += cs[4];
			} else {
				// Charge Ns to Ts
				cs[3] += cs[4];
			}
		}
		float ent = 0.0;
		for(int i = 0; i < 4; i++) {
			if(cs[i] > 0) {
				float frac = (float)cs[i] / (float)readLen;
				ent += (frac * log(frac));
			}
		}
		ent = -ent;
		assert_geq(ent, 0.0);
		return ent;
	}

// Assembly:
pushq %rbx
subq $0x50, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rsi), %rcx
movq 0x20(%rsi), %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x29866
movsbq (%rcx,%rdx), %rsi
incq 0x10(%rsp,%rsi,8)
incq %rdx
jmp 0x29852
movq 0x30(%rsp), %rcx
testq %rcx, %rcx
je 0x298df
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %rsi
cmpq %rsi, %r8
setb %dil
movq 0x20(%rsp), %rdx
cmpq %rdx, %r8
setb %r9b
orb %dil, %r9b
movq 0x28(%rsp), %rdi
cmpq %rdi, %r8
setb %r10b
orb %r9b, %r10b
je 0x298c3
cmpq %rdx, %rsi
setb %r8b
cmpq %rdi, %rsi
setb %r9b
orb %r8b, %r9b
je 0x298cd
cmpq %rdi, %rdx
jae 0x298d7
addq %rcx, %rdi
movq %rdi, 0x28(%rsp)
jmp 0x298df
addq %rcx, %r8
movq %r8, 0x10(%rsp)
jmp 0x298df
addq %rcx, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x298df
addq %rcx, %rdx
movq %rdx, 0x20(%rsp)
testq %rax, %rax
js 0x298eb
cvtsi2ss %rax, %xmm0
jmp 0x29900
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
xorl %ebx, %ebx
cmpq $0x4, %rbx
je 0x29966
movq 0x10(%rsp,%rbx,8), %rax
testq %rax, %rax
je 0x29961
movaps %xmm0, 0x40(%rsp)
js 0x29929
cvtsi2ss %rax, %xmm0
jmp 0x2993e
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
callq 0x99f0
mulss 0xc(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
incq %rbx
jmp 0x2990b
xorps 0x1da83(%rip), %xmm0    # 0x473f0
addq $0x50, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ref_aligner.h
// Function: RefAligner::find(unsigned int, unsigned long, BitPairReference const*, SDnaStringExpandable<25, 2> const&, SStringExpandable<char, 25, 2, 0> const&, unsigned int, unsigned int, EList<Range, 128>&, EList<unsigned int, 128>&, std::set<std::pair<unsigned long, unsigned long>, std::less<std::pair<unsigned long, unsigned long>>, std::allocator<std::pair<unsigned long, unsigned long>>>*, unsigned int, bool)
virtual void find(uint32_t numToFind,
	                  const size_t tidx,
	                  const BitPairReference *refs,
	                  const BTDnaString& qry,
	                  const BTString& quals,
	                  TIndexOffU begin,
	                  TIndexOffU end,
	                  TRangeVec& ranges,
	                  EList<TIndexOffU>& results,
	                  TSetPairs* pairs = NULL,
	                  TIndexOffU aoff = OFF_MASK,
	                  bool seedOnLeft = false)
		{
			assert_gt(numToFind, 0);
			assert_gt(end, begin);
			TIndexOffU spread = end - begin;
			TIndexOffU spreadPlus = spread + 12;
			// Make sure the buffer is large enough to accommodate the spread
			if(spreadPlus > this->refbufSz_) {
				this->newBuf(spreadPlus);
			}
			// Read in the relevant stretch of the reference string
			int offset = refs->getStretch(this->refbuf_, tidx, begin, spread);
			uint8_t *buf = ((uint8_t*)this->refbuf_) + offset;
			// Look for alignments
			ASSERT_ONLY(uint32_t irsz = (uint32_t)ranges.size());
			anchor64Find(numToFind, tidx, buf, qry, quals, begin,
				     end, ranges, results, pairs, aoff, seedOnLeft);
#ifndef NDEBUG
			for(size_t i = irsz; i < results.size(); i++) {
				assert_eq(ranges[i].numMms, ranges[i].mms.size());
				assert_eq(ranges[i].numMms, ranges[i].refcs.size());
			}
#endif
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl 0x58(%rsp), %ebx
movl 0x50(%rsp), %r14d
subl %r14d, %ebx
leal 0xc(%rbx), %esi
cmpl 0x20(%rdi), %esi
jbe 0x2dc25
movq %r12, %rdi
callq 0x2e612
movq 0x18(%r12), %rsi
movl %r14d, %ecx
movl %ebx, %r8d
movq %r13, %rdi
movq %r15, %rdx
callq 0x2e6d0
movslq %eax, %rcx
addq 0x18(%r12), %rcx
movq (%r12), %rax
movq 0x18(%rax), %rax
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop