LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x28(%rcx), %eax
movl 0x24(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jbe 0x4814f
movq -0x20(%rbp), %r9
movl 0x24(%r9), %edi
movl 0x28(%r9), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %r9, %r8
addq $0x2c, %r8
addq $0x3c, %r9
callq 0x419e0
jmp 0x48185
movq -0x20(%rbp), %rcx
movl 0x28(%rcx), %eax
cmpl 0x24(%rcx), %eax
jbe 0x48183
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x2c, %rdi
movl 0x24(%rax), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x24f80
movq -0x20(%rbp), %rdi
addq $0x3c, %rdi
callq 0x41b30
jmp 0x48185
movq -0x20(%rbp), %rax
movb $0x1, 0x84(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::reset()
void reset() {
		pools_.clear();
		lastCurInPool_.clear();
		cur_ = 0;
		curPool_ = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x10, %rdi
callq 0x488f0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x401d0
movq -0x10(%rbp), %rax
movl $0x0, 0x5c(%rax)
movl $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, 0x9(%rax)
addq $0x40, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x499a0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x44ff0
movq -0x30(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x48b55
movq -0x10(%rbp), %rdi
callq 0x37f00
movq %rax, -0x40(%rbp)
jmp 0x48b62
movq -0x10(%rbp), %rdi
callq 0x38890
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x499c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x30(%rbp), %rcx
movb 0x28(%rcx), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x38(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x48bb6
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x48(%rbp)
jmp 0x48bc4
movq -0x20(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x30(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x48be1
jmp 0x48c66
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
testb $0x1, 0x8(%rax)
jne 0x48c01
movq -0x30(%rbp), %rsi
movq 0x30(%rsi), %rdi
addq $0x40, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x48c15
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x48c1c
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0x48c1c
movq -0x30(%rbp), %rsi
movl -0x4c(%rbp), %eax
movw %ax, -0x22(%rbp)
addq $0xc, %rsi
leaq -0x22(%rbp), %rdi
callq 0x499e0
movq -0x30(%rbp), %rdi
movw (%rax), %ax
movw %ax, 0xa(%rdi)
movq 0x30(%rdi), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movb %al, 0x9(%rdi)
movq 0x30(%rdi), %rax
movb 0x9(%rax), %al
andb $0x1, %al
movb %al, 0x8(%rdi)
addq $0x40, %rdi
callq 0x45050
testb $0x1, %al
jne 0x48c66
jmp 0x48c66
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./range_source.h
// Function: SingleRangeSourceDriver<EbwtRangeSource>::advanceImpl(int)
virtual void advanceImpl(int until) {
		if(this->done || pm_.empty()) {
			this->done = true;
			return;
		}
		assert(!pm_.empty());
		assert(!pm_.front()->curtailed_);
		assert(!pm_.front()->exhausted_);
		params_.setFw(fw_);
		// Advance the RangeSource for the forward-oriented read
		ASSERT_ONLY(uint16_t oldMinCost = this->minCost);
		ASSERT_ONLY(uint16_t oldPmMinCost = pm_.minCost);
		rs_->advanceBranch(until, this->minCost, pm_);
		this->done = pm_.empty();
		if(pm_.minCost != 0) {
			this->minCost = max(pm_.minCost, this->minCostAdjustment_);
		} else {
			// pm_.minCost is 0 because we reset it due to exceptional
			// circumstances
		}
#ifndef NDEBUG
		{
			bool error = false;
			if(pm_.minCost != 0 && pm_.minCost < oldPmMinCost) {
				cerr << "PathManager's cost went down" << endl;
				error = true;
			}
			if(this->minCost < oldMinCost) {
				cerr << "this->minCost cost went down" << endl;
				error = true;
			}
			if(error) {
				cerr << "pm.minCost went from " << oldPmMinCost
				     << " to " << pm_.minCost << endl;
				cerr << "this->minCost went from " << oldMinCost
				     << " to " << this->minCost << endl;
				cerr << "this->minCostAdjustment_ == "
				     << this->minCostAdjustment_ << endl;
			}
			assert(!error);
		}
#endif
		this->foundRange = rs_->foundRange;
#ifndef NDEBUG
		if(this->foundRange) {
			if(until >= ADV_COST_CHANGES) assert_eq(oldMinCost, range().cost);
			// Assert that we have not yet dished out a range with this
			// top offset
			assert_gt(range().bot, range().top);
			assert(range().ebwt != NULL);
			TIndexOff top = (TIndexOff)range().top;
			top++; // ensure it's not 0
			if(!range().ebwt->fw()) top = -top;
			assert(allTops_.find(top) == allTops_.end());
			allTops_.insert(top);
		}
		if(!pm_.empty()) {
			assert(!pm_.front()->curtailed_);
			assert(!pm_.front()->exhausted_);
		}
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x9(%rax)
jne 0x48cd0
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x45050
testb $0x1, %al
jne 0x48cd0
jmp 0x48cdd
movq -0x18(%rbp), %rax
movb $0x1, 0x9(%rax)
jmp 0x48d71
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movb 0x28(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x49a40
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rdi
movl -0xc(%rbp), %esi
movw 0xa(%rcx), %dx
addq $0x40, %rcx
movq (%rdi), %rax
movzwl %dx, %edx
callq *0x20(%rax)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x45050
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x9(%rax)
movzwl 0x198(%rax), %eax
cmpl $0x0, %eax
je 0x48d5e
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x158, %rdi            # imm = 0x158
addq $0xc, %rsi
callq 0x499e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movw (%rcx), %cx
movw %cx, 0xa(%rax)
jmp 0x48d60
jmp 0x48d60
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movb 0x9(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x497e0
movq -0x38(%rbp), %rdi
movl $0x0, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, -0x30(%rbp)
callq 0x31f40
jmp 0x495b2
movq -0x38(%rbp), %rax
movl $0x0, 0x5c(%rax)
movq -0x10(%rbp), %rdi
callq 0x49820
movl %eax, -0x44(%rbp)
jmp 0x495cb
movl -0x44(%rbp), %eax
movl %eax, %eax
movl $0x88, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl %ecx, 0x58(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4960d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x322a0
movq -0x40(%rbp), %rdi
callq 0x49840
movq -0x20(%rbp), %rdi
callq 0xab60
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpl $0x4, -0x14(%rbp)
jne 0x49a87
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x49af3
cmpl $0x3, -0x14(%rbp)
jne 0x49a95
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x49af3
cmpl $0x1, -0x14(%rbp)
jne 0x49aa4
movl $0x0, -0x4(%rbp)
jmp 0x49af3
cmpl $0x2, -0x14(%rbp)
jne 0x49ab2
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x49af3
movq 0x5e537(%rip), %rdi     # 0xa7ff0
leaq 0x432c9(%rip), %rsi     # 0x8cd89
callq 0xa5d0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0xab40
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x5e466(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::setOffs(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
void setOffs(uint32_t depth5,   // depth of far edge of hi-half
	             uint32_t depth3,   // depth of far edge of lo-half
	             uint32_t unrevOff, // depth above which we cannot backtrack
	             uint32_t revOff1,  // depth above which we may backtrack just once
	             uint32_t revOff2,  // depth above which we may backtrack just twice
	             uint32_t revOff3)  // depth above which we may backtrack just three times
	{
		depth5_   = depth5;
		depth3_   = depth3;
		assert_geq(depth3_, depth5_);
		offRev0_ = unrevOff;
		offRev1_  = revOff1;
		offRev2_  = revOff2;
		offRev3_  = revOff3;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x98(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x9c(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x74(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x78(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x7c(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x80(%rax)
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, 0x9(%rax)
movq 0xa8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rax
movq 0xa8(%rax), %rdi
addq $0xc, %rdi
movq 0xa8(%rax), %rsi
addq $0xa, %rsi
callq 0x499e0
movq -0x20(%rbp), %rdi
movw (%rax), %ax
movw %ax, 0xc(%rdi)
movw 0xc(%rdi), %ax
movw %ax, 0xa(%rdi)
addq $0x18, %rdi
callq 0x4b110
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x48ad0
movq -0x20(%rbp), %rax
movw 0xa(%rax), %cx
movw %cx, 0x22(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movb $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtSeededRangeSourceDriver::advance(int)
virtual void advance(int until) {
		assert(!this->foundRange);
		until = max<int>(until, ADV_COST_CHANGES);
		ASSERT_ONLY(uint16_t preCost = this->minCost);
		advanceImpl(until);
		if(this->foundRange) {
			assert_eq(range().cost, preCost);
		}
#ifndef NDEBUG
		if(this->foundRange) {
			// Assert that we have not yet dished out a range with this
			// top offset
			assert_gt(range().bot, range().top);
			assert(range().ebwt != NULL);
			TIndexOff top = (TIndexOff)range().top;
			top++; // ensure it's not 0
			if(!range().ebwt->fw()) top = -top;
			assert(allTops_.find(top) == allTops_.end());
			allTops_.insert(top);
		}
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2, -0x10(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x31970
movq -0x18(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x49fe9
jmp 0x49fe9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtSeededRangeSourceDriver::range()
virtual Range& range() {
		Range& r = rsFull_.range();
		r.fw = fw_;
		r.mate1 = mate1_;
		return r;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x4a830
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movb 0xbc(%rax), %dl
movq -0x10(%rbp), %rcx
andb $0x1, %dl
movb %dl, 0x14(%rcx)
movb 0xbd(%rax), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x15(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x5cddd(%rip), %rax     # 0xa71a8
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x4a490
movq %rax, -0x20(%rbp)
jmp 0x4a3dd
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4a439
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x4a4b0
movq %rax, -0x30(%rbp)
jmp 0x4a40e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4a429
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4a42b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4a3ed
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x4a4e0
jmp 0x4a448
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x4a4e0
jmp 0x4a457
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3e530
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x3e530
movq -0x28(%rbp), %rdi
callq 0x494e0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24d00
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, 0x9(%rax)
movb $0x0, 0x8(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x80(%rax)
addq $0x58, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37f00
movq -0x38(%rbp), %rdi
movl 0x18c(%rax), %esi
callq 0x403d0
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x4a490
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4a5a9
jmp 0x4a60e
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4a5eb
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rsi
callq 0x4a4b0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4a5b1
movq -0x30(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
addq $0x30, %rdi
callq 0x4a960
movq -0x30(%rbp), %rdi
movw $0x0, 0xa(%rdi)
callq 0x4aa40
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0xc(%rbp)
sete %al
andb $0x1, %al
movb %al, -0xd(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0x4a490
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4a950
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x4a4b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
andb $0x1, %al
movzbl %al, %eax
movb -0xd(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4a940
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x4a4b0
movq (%rax), %rax
movb $0x1, 0x9(%rax)
jmp 0x4a942
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4a8db
movq -0x20(%rbp), %rdi
callq 0x4aa40
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x50(%rax)
jne 0x4adf3
movb $0x0, -0x1(%rbp)
jmp 0x4ae8f
movq -0x30(%rbp), %rdi
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
addq $0x30, %rdi
callq 0x4a490
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4ae74
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
callq 0x4a4b0
movq (%rax), %rax
testb $0x1, 0x9(%rax)
jne 0x4ae64
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
callq 0x4a4b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x4ae58
jmp 0x4ae5e
movb $0x1, -0x11(%rbp)
jmp 0x4ae62
movb $0x1, -0x12(%rbp)
jmp 0x4ae64
jmp 0x4ae66
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4ae14
movb $0x1, %al
testb $0x1, -0x11(%rbp)
movb %al, -0x31(%rbp)
je 0x4ae87
movb -0x12(%rbp), %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
callq 0x4a490
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4b17b
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x4a4b0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4b16b
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4b16d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4b139
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x4a4e0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x4a4e0
movq -0x20(%rbp), %rax
movb $0x0, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x1e0, %edi            # imm = 0x1E0
callq 0xa5f0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rdi
callq 0x4b400
movq %rax, -0x48(%rbp)
jmp 0x4b1fb
movq -0x60(%rbp), %rax
movq 0x18(%rax), %r11
movq 0x20(%rax), %rbx
movl 0x28(%rax), %r14d
movl 0x30(%rax), %r12d
movl 0x34(%rax), %r13d
movl 0x38(%rax), %edx
movl 0x3c(%rax), %esi
movq 0x40(%rax), %rdi
movq 0x50(%rax), %rcx
movq %rcx, -0x78(%rbp)
movq 0x58(%rax), %rcx
movzbl 0x12(%rax), %r9d
movzbl 0x11(%rax), %r8d
movzbl 0x10(%rax), %r10d
movl %r10d, -0x64(%rbp)
movzbl 0x13(%rax), %r10d
movzbl 0x2c(%rax), %r15d
movzbl 0x48(%rax), %eax
movl %eax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x49(%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x4a(%rax), %eax
movl %eax, -0x70(%rbp)
movq %rsp, %rax
movq %rax, -0x80(%rbp)
movq %rcx, 0x70(%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x68(%rax)
movl -0x70(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, 0x60(%rax)
movl -0x6c(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, 0x58(%rax)
movl -0x68(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, 0x50(%rax)
movl -0x64(%rbp), %ecx
movq %rdi, 0x48(%rax)
movq -0x58(%rbp), %rdi
movl %esi, 0x40(%rax)
movq -0x50(%rbp), %rsi
movl %edx, 0x38(%rax)
movq -0x48(%rbp), %rdx
movl %r13d, 0x30(%rax)
movl %r12d, 0x28(%rax)
andl $0x1, %r15d
movl %r15d, 0x20(%rax)
movl %r14d, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %r11, 0x8(%rax)
andl $0x1, %r10d
movl %r10d, (%rax)
andl $0x1, %ecx
andl $0x1, %r8d
andl $0x1, %r9d
callq 0x3de00
jmp 0x4b2df
movq -0x58(%rbp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x1e0, %esi            # imm = 0x1E0
callq 0xa600
movq -0x38(%rbp), %rdi
callq 0xab60
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movb $0x0, 0x9(%rax)
cmpq $0x0, 0x80(%rax)
je 0x4b373
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x80(%rax), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x3dfd0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
leaq -0x10(%rbp), %rsi
callq 0x3dfd0
movq -0x20(%rbp), %rdi
callq 0x4b4e0
movq -0x20(%rbp), %rdi
movw $0x0, 0xa(%rdi)
callq 0x4aa40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x188, %edi            # imm = 0x188
callq 0xa5f0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rsi
movl 0xc(%rax), %ecx
movzbl 0x13(%rax), %r11d
andl $0x1, %r11d
movq 0x18(%rax), %r12
movzbl 0x11(%rax), %r9d
movzbl 0x10(%rax), %r8d
movzbl 0x8(%rax), %edx
movzbl 0x12(%rax), %r10d
movzbl 0x14(%rax), %ebx
movzbl 0x15(%rax), %r14d
movzbl 0x16(%rax), %r15d
movq %rsp, %rax
movq %r12, 0x28(%rax)
andl $0x1, %r15d
movl %r15d, 0x20(%rax)
andl $0x1, %r14d
movl %r14d, 0x18(%rax)
andl $0x1, %ebx
movl %ebx, 0x10(%rax)
movl %r11d, 0x8(%rax)
andl $0x1, %r10d
movl %r10d, (%rax)
andl $0x1, %edx
andl $0x1, %r8d
andl $0x1, %r9d
callq 0x3dc00
jmp 0x4b4a1
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x188, %esi            # imm = 0x188
callq 0xa600
movq -0x30(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
callq 0x4a490
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4b555
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0x4a4b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x4b53b
jmp 0x4b541
movb $0x1, -0x11(%rbp)
jmp 0x4b545
movb $0x1, -0x12(%rbp)
jmp 0x4b547
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4b511
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x29(%rbp)
je 0x4b566
movb -0x12(%rbp), %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movb -0x29(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x5ba85(%rip), %rcx     # 0xa7210
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4b7ad
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x80(%rax)
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4b7d8
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0xa600
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4b809
movq -0x28(%rbp), %rdi
callq 0x4bed0
movq -0x28(%rbp), %rdi
movl $0xc8, %esi
callq 0xa600
movq -0x18(%rbp), %rax
movq $0x0, 0x78(%rax)
movq 0x98(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4b82f
movq -0x30(%rbp), %rdi
callq 0xa7c0
movq -0x18(%rbp), %rax
movq $0x0, 0x98(%rax)
movq 0x60(%rax), %rdi
movq 0x68(%rax), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x4b851
movq -0x18(%rbp), %rdi
movq $0x0, 0x68(%rdi)
callq 0x4be00
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24d00
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x37f00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x38890
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rax), %rdi
callq 0x499c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
cmpq $0x0, 0x28(%rax)
je 0x4be95
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x499c0
movq %rax, -0x20(%rbp)
jmp 0x4be9d
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x4be9d
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %ecx, 0x30(%rax)
movq %rax, %rdi
addq $0x38, %rdi
movq 0x18(%rax), %rax
movl 0x18c(%rax), %esi
callq 0x403d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4c3a0
movq -0x18(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x4bf6b
movq -0x18(%rbp), %rcx
movl 0x24(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x24(%rcx)
movl 0x24(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x4bf42
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rcx
movl 0x24(%rcx), %eax
cmpl 0x20(%rcx), %eax
jne 0x4bf5a
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x4c00a
movq -0x18(%rbp), %rdi
movl 0x24(%rdi), %esi
callq 0x4c550
jmp 0x4c00a
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x4c6d0
movq -0x18(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x4c008
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x4c7c0
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x28, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4c820
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x28(%rax)
je 0x4c006
movq -0x18(%rbp), %rax
testb $0x1, 0xa8(%rax)
je 0x4bff0
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, -0x28(%rbp)
movl 0x24(%rdi), %eax
subl 0x18(%rdi), %eax
movl %eax, -0x1c(%rbp)
addq $0x38, %rdi
callq 0x4c930
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl %eax, %edx
callq 0x4c850
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x4c950
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
jmp 0x4c008
jmp 0x4c00a
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4c6f5
jmp 0x4c7af
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
cmpq $0x0, 0x40(%rax)
je 0x4c715
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x28, %rsi
callq 0x24e80
movq -0x18(%rbp), %rcx
movl %eax, %eax
movq %rax, -0x10(%rbp)
movl 0x24(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x24(%rcx)
movq -0x10(%rbp), %rax
movl %eax, 0x20(%rcx)
movl 0x20(%rcx), %eax
movq 0x8(%rcx), %rcx
cmpl 0x68(%rcx), %eax
jne 0x4c75b
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
movl %ecx, 0x38(%rax)
movb $0x1, (%rax)
jmp 0x4c7a1
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %eax
movq 0x18(%rcx), %rdx
andl 0x20(%rdx), %eax
cmpl 0x20(%rcx), %eax
jne 0x4c79f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0xa8(%rcx), %rcx
movq %rcx, -0x20(%rbp)
movl 0x20(%rax), %edx
movq 0x18(%rax), %rcx
movl 0x1c(%rcx), %ecx
shrl %cl, %edx
movq -0x20(%rbp), %rcx
movl %edx, %edx
movl (%rcx,%rdx,4), %ecx
addl 0x24(%rax), %ecx
movl %ecx, 0x38(%rax)
movb $0x1, (%rax)
jmp 0x4c7a1
movq -0x18(%rbp), %rdi
callq 0x4cb30
jmp 0x4c6e4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./row_chaser.h
// Function: RowChaser::off()
UPair off() {
		TIndexOffU off = flatOff();
		assert_neq(OFF_MASK, off);
		TIndexOffU tidx;
		TIndexOffU textoff = OFF_MASK;
		ebwt_->joinedToTextOff(qlen_, off, tidx, textoff, tlen_);
		// Note: tidx may be 0xffffffff, if alignment overlaps a
		// reference boundary
		return make_pair(tidx, textoff);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4c930
movq -0x28(%rbp), %r9
movl %eax, -0x14(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq 0x8(%r9), %rdi
movl 0x10(%r9), %esi
movl -0x14(%rbp), %edx
addq $0x3c, %r9
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
callq 0xd9d0
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x4cb80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x4c876
jmp 0x4c91c
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x4c8dd
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
movl -0x10(%rbp), %ecx
subl %edx, %ecx
movl %ecx, -0x10(%rbp)
testb $0x1, 0x20(%rax)
je 0x4c8ca
movq 0x5b71a(%rip), %rdi     # 0xa7fb8
leaq 0x40567(%rip), %rsi     # 0x8ce0c
callq 0xa5d0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl -0xc(%rbp), %esi
callq 0xa810
movq %rax, %rdi
movq 0x5b6a3(%rip), %rsi     # 0xa7f68
callq 0xa640
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %edx
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x4c91c
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4c91a
movq 0x5b6ca(%rip), %rdi     # 0xa7fb8
leaq 0x40534(%rip), %rsi     # 0x8ce29
callq 0xa5d0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl -0xc(%rbp), %esi
callq 0xa810
movq %rax, %rdi
movq 0x5b653(%rip), %rsi     # 0xa7f68
callq 0xa640
jmp 0x4c91c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x4c99a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ca54
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x4ca10
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x4ca10
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4c9f4
movq 0x5b5f0(%rip), %rdi     # 0xa7fb8
leaq 0x40409(%rip), %rsi     # 0x8cdd8
callq 0xa5d0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
addl -0x14(%rbp), %esi
callq 0xa810
movq %rax, %rdi
movq 0x5b579(%rip), %rsi     # 0xa7f68
callq 0xa640
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rax
movl -0x14(%rbp), %edx
movl (%rax,%rdx,4), %eax
addl 0x4(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4ca54
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4ca4d
movq 0x5b597(%rip), %rdi     # 0xa7fb8
leaq 0x403ce(%rip), %rsi     # 0x8cdf6
callq 0xa5d0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
addl -0x14(%rbp), %esi
callq 0xa810
movq %rax, %rdi
movq 0x5b520(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rcx)
movq -0x18(%rbp), %rax
addq $0xf8, %rax
movq %rax, 0x18(%rcx)
movl -0xc(%rbp), %eax
movl %eax, 0x20(%rcx)
movl -0x10(%rbp), %eax
movl %eax, 0x10(%rcx)
movl 0x20(%rcx), %eax
movq 0x8(%rcx), %rcx
cmpl 0x68(%rcx), %eax
jne 0x4cabc
movq -0x20(%rbp), %rax
movl $0x0, 0x38(%rax)
movb $0x1, (%rax)
jmp 0x4cb1f
movq -0x20(%rbp), %rcx
movl 0x20(%rcx), %eax
movq 0x18(%rcx), %rdx
andl 0x20(%rdx), %eax
cmpl 0x20(%rcx), %eax
jne 0x4caff
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0xa8(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movl 0x20(%rax), %edx
movq 0x18(%rax), %rcx
movl 0x1c(%rcx), %ecx
shrl %cl, %edx
movq -0x28(%rbp), %rcx
movl %edx, %edx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x38(%rax)
movb $0x1, (%rax)
jmp 0x4cb1f
jmp 0x4cb01
movq -0x20(%rbp), %rdi
movb $0x0, (%rdi)
movl $0x0, 0x24(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movb $0x0, 0x1(%rdi)
callq 0x4cb30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, (%rax)
jne 0x4cb6b
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movl 0x20(%rax), %esi
movq 0x18(%rax), %rdx
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rcx
callq 0x24f80
movq -0x10(%rbp), %rax
movb $0x1, 0x1(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
shrl $0x5, %eax
movl %eax, %eax
orl 0x8(%rcx,%rax,4), %edx
movl %edx, 0x8(%rcx,%rax,4)
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jb 0x4d6f0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x21, -0x1c(%rbp)
jae 0x4d78c
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
cmpl 0x8(%rcx,%rdx,4), %eax
je 0x4d77f
movb $0x1, -0x1(%rbp)
jmp 0x4d790
jmp 0x4d781
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4d75b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa820
movq -0x1a8(%rbp), %rdi
callq 0x4da80
movl %eax, -0x1a0(%rbp)
jmp 0x4d7ef
movl -0x1a0(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18c(%rbp)
cmpl $0x0, -0x18c(%rbp)
jl 0x4d899
movq -0x1a8(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x4daa0
movb %al, -0x1b9(%rbp)
jmp 0x4d825
movb -0x1b9(%rbp), %al
testb $0x1, %al
jne 0x4d831
jmp 0x4d841
leaq 0x3d33d(%rip), %rax     # 0x8ab75
movq %rax, -0x1c8(%rbp)
jmp 0x4d851
leaq 0x4103a(%rip), %rax     # 0x8e882
movq %rax, -0x1c8(%rbp)
jmp 0x4d851
movq -0x1c8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0xa5d0
jmp 0x4d866
jmp 0x4d868
movl -0x18c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18c(%rbp)
jmp 0x4d7fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa140
jmp 0x4d8ca
movq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa610
jmp 0x4d8ae
leaq -0x188(%rbp), %rdi
callq 0xa140
movq -0x1b0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset<1024>::test(unsigned int) const
bool test(TIndexOffU i) const {
		bool ret = false;
		assert_lt(i, LEN);
		ret = ((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) != 0;
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0xd(%rbp)
movl -0xc(%rbp), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl 0x8(%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
andl $0x1f, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)