LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BenLangmead[P]bowtie/./hit.h
// Function: HitSink::tallyAlignments(unsigned long, unsigned long, bool)
void tallyAlignments(size_t threadId, size_t numAl, bool paired) {
        assert(!paired || (numAl % 2) == 0);
        ptNumAligned_[threadId] ++;
		if(paired) {
			ptNumReportedPaired_[threadId] += numAl;
		} else {
			ptNumReported_[threadId] += numAl;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x1c8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
testb $0x1, -0x19(%rbp)
je 0x2ef6c
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x1d8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq %rsi, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2ef8a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq %rsi, %rdx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: OutFileBuf::flush()
void flush() {
		if(cur_ != fwrite((const void *)buf_, 1, cur_, out_)) {
			if (errno == EPIPE) {
				exit(EXIT_SUCCESS);
			}
			std::cerr << "Error while flushing and closing output" << std::endl;
			throw 1;
		}
		cur_ = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, %rdi
addq $0x18, %rdi
movq 0x10(%rax), %rdx
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0xac70
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
je 0x2f047
callq 0xa080
cmpl $0x20, (%rax)
jne 0x2f002
xorl %edi, %edi
callq 0xa740
movq 0x78fe7(%rip), %rdi     # 0xa7ff0
leaq 0x5d6f4(%rip), %rsi     # 0x8c704
callq 0xa5d0
movq %rax, %rdi
movq 0x78f49(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x78f12(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: HitSink::flush(unsigned long, bool)
void flush(size_t threadId, bool force) {
		if (reorder_) {
			reorder(threadId, force);
		} else {
			ThreadSafe _ts(&mutex_); // flush
			out_.writeString(ptBufs_[threadId]);
		}
		ptCounts_[threadId] = 0;
		ptBufs_[threadId].clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x78(%rax)
je 0x2f09c
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2f140
jmp 0x2f0f6
movq -0x38(%rbp), %rsi
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2f3b0
movq -0x38(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x2ed00
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2ed20
jmp 0x2f0d4
leaq -0x20(%rbp), %rdi
callq 0x2f3e0
jmp 0x2f0f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2f3e0
jmp 0x2f12d
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0x2a100
movq -0x38(%rbp), %rdi
movq $0x0, (%rax)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x2ed00
movq %rax, %rdi
callq 0x2ee80
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./bitset.h
// Function: Bitset::operator=(Bitset const&)
Bitset& operator=(const Bitset& o) {
		_errmsg = o._errmsg;
		_sz = o._sz;
		_cnt = o._cnt;
		if(_words != NULL) delete[] _words;
		_words = new TIndexOffU[(_sz+BITSET_MASK) / WORD_SIZE];
		for(size_t i = 0; i < (_sz+BITSET_MASK) / WORD_SIZE; i++) {
			_words[i] = o._words[i];
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
cmpq $0x0, 0x18(%rax)
je 0x2fa4a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2fa48
movq -0x28(%rbp), %rdi
callq 0xa7c0
jmp 0x2fa4a
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1f, %eax
shrl $0x5, %eax
movl %eax, %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xa040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x10(%rcx), %ecx
addl $0x1f, %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x2fad1
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2fa8d
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: OutFileBuf::close()
void close() {
		if(closed_) return;
		if(cur_ > 0) flush();
		closed_ = true;
		if(out_ != stdout) {
			fclose(out_);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x4018(%rax)
je 0x2fd6f
jmp 0x2fdab
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x2fd83
movq -0x10(%rbp), %rdi
callq 0x2efb0
movq -0x10(%rbp), %rax
movb $0x1, 0x4018(%rax)
movq 0x8(%rax), %rax
movq 0x781bf(%rip), %rcx     # 0xa7f58
cmpq (%rcx), %rax
je 0x2fdab
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa5e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::ChunkPool(unsigned int, unsigned int, bool)
ChunkPool(uint32_t chunkSz, uint32_t totSz, bool verbose_) :
		verbose(verbose_), patid(0), pool_(NULL), cur_(0),
		chunkSz_(chunkSz), totSz_(totSz), lim_(totSz/chunkSz),
		bits_(lim_), exhaustCrash_(false),
		lastSkippedRead_(0xffffffff), readName_(NULL)
	{
		assert_gt(lim_, 0);
		try {
			if((pool_ = new int8_t[totSz_]) == NULL) {
				throw std::bad_alloc();
			}
		} catch(std::bad_alloc& e) {
			ThreadSafe _ts(&gLock);
			std::cerr << "Error: Could not allocate ChunkPool of "
			          << totSz << " bytes" << std::endl;
			exhausted();
			throw 1; // Exit if we haven't already
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movl $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq %rdi, -0x50(%rbp)
movl 0x1c(%rax), %esi
callq 0x39960
movq -0x48(%rbp), %rax
movb $0x0, 0x38(%rax)
movl $0xffffffff, 0x3c(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x40(%rax)
movl 0x18(%rax), %eax
movl %eax, %edi
callq 0xa040
movq %rax, -0x40(%rbp)
jmp 0x32a78
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x32b7e
movl $0x8, %edi
callq 0xa290
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
callq 0x32260
movq -0x58(%rbp), %rdi
movq 0x75511(%rip), %rsi     # 0xa7fc0
movq 0x754d2(%rip), %rdx     # 0xa7f88
callq 0xab10
jmp 0x32bcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x32bb2
movq -0x20(%rbp), %rdi
callq 0xa200
movq %rax, -0x30(%rbp)
leaq 0x78868(%rip), %rsi     # 0xab358
leaq -0x38(%rbp), %rdi
callq 0x2f3b0
jmp 0x32afb
movq 0x754ee(%rip), %rdi     # 0xa7ff0
leaq 0x5a052(%rip), %rsi     # 0x8cb5b
callq 0xa5d0
movq %rax, -0x60(%rbp)
jmp 0x32b14
movq -0x60(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xa810
movq %rax, -0x68(%rbp)
jmp 0x32b26
movq -0x68(%rbp), %rdi
leaq 0x5a052(%rip), %rsi     # 0x8cb83
callq 0xa5d0
movq %rax, -0x70(%rbp)
jmp 0x32b3c
movq -0x70(%rbp), %rdi
movq 0x75421(%rip), %rsi     # 0xa7f68
callq 0xa640
jmp 0x32b4e
movq -0x48(%rbp), %rdi
callq 0x399e0
jmp 0x32b59
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x753dd(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
jmp 0x32bcc
jmp 0x32bac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x32ba3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2f3e0
callq 0xaa60
jmp 0x32baa
jmp 0x32bb2
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x39b00
movq -0x20(%rbp), %rdi
callq 0xab60
movq %rax, %rdi
callq 0x24d00
nopl (%rax)
// File: BenLangmead[P]bowtie/./aligner.h
// Function: MixedMultiAligner::MixedMultiAligner(unsigned int, unsigned int, AlignerFactory const&, AlignerFactory const&, PatternSourcePerThreadFactory const&)
MixedMultiAligner(
			uint32_t n,
			uint32_t qUpto,
			const AlignerFactory& alignSEFact,
			const AlignerFactory& alignPEFact,
			const PatternSourcePerThreadFactory& patsrcFact) :
			n_(n), qUpto_(qUpto),
			alignSEFact_(alignSEFact),
			alignPEFact_(alignPEFact),
			patsrcFact_(patsrcFact),
			alignersSE_(NULL),
			alignersPE_(NULL),
			seOrPe_(NULL),
			patsrcs_(NULL)
	{
		// Instantiate all single-end aligners
		alignersSE_ = alignSEFact_.create(n_);
		assert(alignersSE_ != NULL);
		// Instantiate all paired-end aligners
		alignersPE_ = alignPEFact_.create(n_);
		assert(alignersPE_ != NULL);
		// Allocate array of boolean flags indicating whether each of
		// the slots is currently using the single-end or paired-end
		// aligner
		seOrPe_ = new bool[n_];
		for(uint32_t i = 0; i < n_; i++) {
			seOrPe_[i] = true;
		}
		// Instantiate all read sources
		patsrcs_ = patsrcFact_.create(n_);
		assert(patsrcs_ != NULL);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x742e3(%rip), %rcx     # 0xa74e0
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq 0x10(%rax), %rdi
movl 0x8(%rax), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rax), %rdi
movl 0x8(%rax), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movl 0x8(%rax), %eax
movl %eax, %edi
callq 0xa040
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x332ba
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x2c(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x33294
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movl 0x8(%rax), %esi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./aligner.h
// Function: MixedMultiAligner::~MixedMultiAligner()
virtual ~MixedMultiAligner() {
		alignSEFact_.destroy(alignersSE_);
		alignPEFact_.destroy(alignersPE_);
		patsrcFact_.destroy(patsrcs_);
		delete[] seOrPe_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x73ec5(%rip), %rcx     # 0xa74f0
movq %rcx, (%rax)
movq 0x10(%rax), %rdi
movq 0x28(%rax), %rsi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x33641
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rax), %rsi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x33658
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x40(%rax), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x3366f
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3368a
movq -0x18(%rbp), %rdi
callq 0xa7c0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24d00
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: PatternSourcePerThreadFactory::create(unsigned int) const
virtual EList<PatternSourcePerThread*>* create(uint32_t n) const {
		EList<PatternSourcePerThread*>* v = new EList<PatternSourcePerThread*>;
		for(size_t i = 0; i < n; i++) {
			v->push_back(new PatternSourcePerThread(composer_, max_buf_, skip_, seed_));
			assert(v->back() != NULL);
		}
		return v;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x20, %edi
callq 0xa5f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x36660
jmp 0x34672
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x34722
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x80, %edi
callq 0xa5f0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rsi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
movl 0x18(%rax), %r8d
callq 0x34890
jmp 0x346c7
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x366a0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x34682
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0xa600
jmp 0x3472c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x80, %esi
callq 0xa600
jmp 0x3472c
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./pat.h
// Function: PatternSourcePerThreadFactory::destroy(EList<PatternSourcePerThread*, 128>*) const
virtual void destroy(EList<PatternSourcePerThread*>* composers) const {
		assert(composers != NULL);
		// Free all of the PatternSourcePerThreads
		for(size_t i = 0; i < composers->size(); i++) {
			if((*composers)[i] != NULL) {
				delete (*composers)[i];
				(*composers)[i] = NULL;
			}
		}
		// Free the vector
		delete composers;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36980
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x34820
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x369a0
cmpq $0x0, (%rax)
je 0x3480d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x369a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x347f9
movq -0x28(%rbp), %rdi
callq 0x36930
movq -0x28(%rbp), %rdi
movl $0x80, %esi
callq 0xa600
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x369a0
movq $0x0, (%rax)
jmp 0x3480f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x34798
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x34845
movq -0x30(%rbp), %rdi
callq 0x369d0
movq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0xa600
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: PerThreadReadBuf::reset()
void reset() {
		cur_buf_ = bufa_.size();
		for(size_t i = 0; i < max_buf_; i++) {
			bufa_[i].reset();
			bufb_[i].reset();
		}
		rdid_ = std::numeric_limits<TReadId>::max();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x36610
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
jae 0x34b0d
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x36630
movq %rax, %rdi
callq 0x350d0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x36630
movq %rax, %rdi
callq 0x350d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x34ac0
callq 0x27450
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./read.h
// Function: Read::reset()
void reset() {
		rdid = 0;
		patid = 0;
		trimmed5 = trimmed3 = 0;
		readOrigBuf.clear();
		patFw.clear();
		patRc.clear();
		qual.clear();
		patFwRev.clear();
		patRcRev.clear();
		qualRev.clear();
		name.clear();
		filter = '?';
		seed = 0;
		parsed = false;
		ns_ = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x180(%rdi)
movl $0x0, 0x1a4(%rdi)
movl $0x0, 0x1ac(%rdi)
movl $0x0, 0x1a8(%rdi)
addq $0x120, %rdi            # imm = 0x120
callq 0x359e0
movq -0x10(%rbp), %rdi
callq 0x2ee80
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2ee80
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x2ee80
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x2ee80
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x2ee80
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
callq 0x2ee80
movq -0x10(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
callq 0x2ee80
movq -0x10(%rbp), %rax
movb $0x3f, 0x1a0(%rax)
movl $0x0, 0x18c(%rax)
movb $0x0, 0x190(%rax)
movq $0x0, 0x198(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::install(char const*, unsigned long)
virtual void install(const char* b, size_t sz) {
		if(this->sz_ < sz) this->expandCopy((sz + S) * M);
		memcpy(this->cs_, b, sz);
#ifndef NDEBUG
		for(size_t i = 0; i < sz; i++) {
			assert_range(0, 4, (int)this->cs_[i]);
		}
#endif
		this->len_ = sz;
	}

// 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 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x3532a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x19, %rsi
shlq %rsi
callq 0x35620
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa4c0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::install(char const*, bool, bool)
virtual void install(
		const char* b,
		bool chars = false,
		bool colors = false)
	{
		if(chars) {
			if(colors) {
				installColors(b, strlen(b));
			} else {
				installChars(b, strlen(b));
			}
		} else {
			install(b, strlen(b));
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x3540b
testb $0x1, -0x12(%rbp)
je 0x353e7
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa230
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x30(%rax)
jmp 0x35409
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa230
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x3542d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa230
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::installChars(char const*, unsigned long)
virtual void installChars(const char* b, size_t sz) {
		if(this->sz_ < sz) this->expandCopy((sz + S) * M);
		for(size_t i = 0; i < sz; i++) {
			assert_in(toupper(b[i]), "ACGTN-");
			this->cs_[i] = asc2dna[(int)b[i]];
			assert_range(0, 4, (int)this->cs_[i]);
		}
		this->len_ = sz;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x3547a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x19, %rsi
shlq %rsi
callq 0x35620
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x354c2
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rdx
leaq 0x7520a(%rip), %rcx     # 0xaa6b0
movb (%rcx,%rdx), %dl
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x35482
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::installColors(char const*, unsigned long)
virtual void installColors(const char* b, size_t sz) {
		if(this->sz_ < sz) this->expandCopy((sz + S) * M);
		for(size_t i = 0; i < sz; i++) {
			assert_in(b[i], "0123.");
			this->cs_[i] = asc2col[(int)b[i]];
			assert_range(0, 4, (int)this->cs_[i]);
		}
		this->len_ = sz;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x3551a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x19, %rsi
shlq %rsi
callq 0x35620
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x35562
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rdx
leaq 0x7526a(%rip), %rcx     # 0xaa7b0
movb (%rcx,%rdx), %dl
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x35522
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::expandCopy(unsigned long)
void expandCopy(size_t sz) {
		if(sz_ >= sz) return; // done!
		T *tmp  = new T[sz + 1];
		char *ptmp = new char[sz + 1];
		if(cs_ != NULL) {
			memcpy(tmp, cs_, sizeof(T)*len_);
			delete[] cs_;
		}
		if(printcs_ != NULL) {
			memcpy(ptmp, printcs_, sizeof(char)*len_);
			delete[] printcs_;
		}
		cs_ = tmp;
		printcs_ = ptmp;
		sz_ = sz;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x28(%rax), %rax
cmpq -0x10(%rbp), %rax
jb 0x35647
jmp 0x3570a
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xa040
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xa040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x356ad
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rdx
shlq $0x0, %rdx
callq 0xa4c0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x356ab
movq -0x30(%rbp), %rdi
callq 0xa7c0
jmp 0x356ad
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x356ee
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x10(%rax), %rsi
movq 0x20(%rax), %rdx
shlq $0x0, %rdx
callq 0xa4c0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x356ec
movq -0x38(%rbp), %rdi
callq 0xa7c0
jmp 0x356ee
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::toZBufXForm(char const*) const
const char* toZBufXForm(const char *xform) const {
		ASSERT_ONLY(size_t xformElts = strlen(xform));
		if(empty()) {
			const_cast<char&>(zero_) = 0;
			return &zero_;
		}
		char* printcs = const_cast<char*>(printcs_);
		// Lazily allocate space for print buffer
		for(size_t i = 0; i < len_; i++) {
			assert_lt(cs_[i], (int)xformElts);
			printcs[i] = xform[(int)cs_[i]];
		}
		printcs[len_] = 0;
		return printcs_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2e700
testb $0x1, %al
jne 0x35733
jmp 0x35745
movq -0x30(%rbp), %rax
movb $0x0, 0x18(%rax)
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x357b2
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0x3579a
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x35759
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: NGoodHitSinkPerThread::reportHit(Hit const&, int)
virtual bool reportHit(const Hit& h, int stratum) {
		HitSinkPerThread::reportHit(h, stratum);
		hitsForThisRead_++;
		if(hitsForThisRead_ > _max) {
			return true; // done - report nothing
		}
		//if(hitsForThisRead_ <= _n) {
			// Only report hit if we haven't
			bufferHit(h, stratum);
		//}
		if(hitsForThisRead_ == _n &&
		   (_max == 0xffffffff || _max < _n))
		{
			return true; // already reported N good hits and max isn't set; stop!
		}
		return false; // not at N or max yet; keep going
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x37360
movq -0x28(%rbp), %rcx
movl 0x60(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x60(%rcx)
movl 0x60(%rcx), %eax
cmpl 0x64(%rcx), %eax
jbe 0x37162
movb $0x1, -0x1(%rbp)
jmp 0x3719f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x28(%rbp), %rcx
movl 0x60(%rcx), %eax
cmpl 0x68(%rcx), %eax
jne 0x3719b
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x64(%rax)
je 0x37195
movq -0x28(%rbp), %rcx
movl 0x64(%rcx), %eax
cmpl 0x68(%rcx), %eax
jae 0x3719b
movb $0x1, -0x1(%rbp)
jmp 0x3719f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: HitSinkPerThread::setHits(HitSet&)
virtual bool setHits(HitSet& hs) {
		if(!hs.empty()) {
			cerr << "Error: default setHits() called with non-empty HitSet" << endl;
			throw 1;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39210
testb $0x1, %al
jne 0x37212
movq 0x70e1c(%rip), %rdi     # 0xa7ff0
leaq 0x5594a(%rip), %rsi     # 0x8cb25
callq 0xa5d0
movq %rax, %rdi
movq 0x70d7e(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x70d47(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
xorl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: Hit::operator=(Hit const&)
Hit& operator = (const Hit &other) {
		this->h       = other.h;
		this->mh      = other.mh;
		this->patId   = other.patId;
		this->patName = other.patName;
		this->patSeq  = other.patSeq;
		this->quals   = other.quals;
		this->mms     = other.mms;
		this->refcs   = other.refcs;
		this->crefcs  = other.crefcs;
		this->oms     = other.oms;
		this->fw      = other.fw;
		this->mfw     = other.mfw;
		this->mlen    = other.mlen;
		this->stratum = other.stratum;
		this->cost    = other.cost;
		this->mate    = other.mate;
		this->seed    = other.seed;
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x36310
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x36310
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x10(%rdi)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x2e7e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x35e50
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
addq $0x78, %rdi
callq 0x2e7e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa8, %rsi
addq $0xa8, %rdi
movl $0x8c, %edx
callq 0xa4c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x138, %rsi            # imm = 0x138
addq $0x138, %rdi            # imm = 0x138
callq 0x38f50
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x158, %rsi            # imm = 0x158
addq $0x158, %rdi            # imm = 0x158
callq 0x38f50
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x178(%rcx), %ecx
movl %ecx, 0x178(%rax)
movq -0x10(%rbp), %rcx
movb 0x17c(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x17c(%rax)
movq -0x10(%rbp), %rcx
movb 0x17d(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x17d(%rax)
movq -0x10(%rbp), %rcx
movw 0x17e(%rcx), %cx
movw %cx, 0x17e(%rax)
movq -0x10(%rbp), %rcx
movb 0x180(%rcx), %cl
movb %cl, 0x180(%rax)
movq -0x10(%rbp), %rcx
movl 0x184(%rcx), %ecx
movl %ecx, 0x184(%rax)
movq -0x10(%rbp), %rcx
movb 0x188(%rcx), %cl
movb %cl, 0x188(%rax)
movq -0x10(%rbp), %rcx
movl 0x18c(%rcx), %ecx
movl %ecx, 0x18c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: AllHitSinkPerThread::reportHit(Hit const&, int)
virtual bool reportHit(const Hit& h, int stratum) {
		HitSinkPerThread::reportHit(h, stratum);
		hitsForThisRead_++;
		if(hitsForThisRead_ > _max) {
			return true; // done - report nothing
		}
		bufferHit(h, stratum);
		return false; // reporting all; always keep going
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x37360
movq -0x28(%rbp), %rcx
movl 0x60(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x60(%rcx)
movl 0x60(%rcx), %eax
cmpl 0x64(%rcx), %eax
jbe 0x394d2
movb $0x1, -0x1(%rbp)
jmp 0x394e7
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
callq *0x20(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: NBestFirstStratHitSinkPerThread::finishReadImpl()
virtual uint32_t finishReadImpl() {
		uint32_t ret = hitsForThisRead_;
		hitsForThisRead_ = 0;
		bestStratum_ = 999;
		const size_t sz = _bufferedHits.size();
		for(size_t i = 0; i < sz; i++) {
			// Set 'oms' according to the number of other alignments
			// at this stratum
			_bufferedHits[i].oms = ((uint32_t)sz / mult_) - 1;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl 0x60(%rdi), %eax
movl %eax, -0xc(%rbp)
movl $0x0, 0x60(%rdi)
movl $0x3e7, 0x78(%rdi)      # imm = 0x3E7
addq $0x40, %rdi
callq 0x37e60
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3982e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
xorl %edx, %edx
divl 0x7c(%rdi)
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
callq 0x2ecd0
movl -0x2c(%rbp), %ecx
movl %ecx, 0x178(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x397ed
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./hit.h
// Function: NBestFirstStratHitSinkPerThread::reportHit(Hit const&, int)
virtual bool reportHit(const Hit& h, int stratum) {
		HitSinkPerThread::reportHit(h, stratum);
		// This hit is within th best possible remaining stratum,
		// so it should definitely count
		hitsForThisRead_++;
		// It doesn't exceed the limit, so buffer it
		if(stratum < bestStratum_) {
			bestStratum_ = stratum;
		}
		if(hitsForThisRead_ > _max) {
			return true; // done - report nothing
		}
		//if(hitsForThisRead_ <= _n) {
			bufferHit(h, stratum);
		//}
		if(hitsForThisRead_ == _n &&
		   (_max == 0xffffffff || _max < _n))
		{
			return true; // already reported N good hits; stop!
		}
		return false; // not at N yet; keep going
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x37360
movq -0x28(%rbp), %rcx
movl 0x60(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x60(%rcx)
movl -0x1c(%rbp), %eax
cmpl 0x78(%rcx), %eax
jge 0x39886
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x78(%rax)
movq -0x28(%rbp), %rcx
movl 0x60(%rcx), %eax
cmpl 0x64(%rcx), %eax
jbe 0x39898
movb $0x1, -0x1(%rbp)
jmp 0x398d5
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x28(%rbp), %rcx
movl 0x60(%rcx), %eax
cmpl 0x68(%rcx), %eax
jne 0x398d1
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x64(%rax)
je 0x398cb
movq -0x28(%rbp), %rcx
movl 0x64(%rcx), %eax
cmpl 0x68(%rcx), %eax
jae 0x398d1
movb $0x1, -0x1(%rbp)
jmp 0x398d5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: BenLangmead[P]bowtie/./hit.h
// Function: NBestFirstStratHitSinkPerThread::irrelevantCost(unsigned short) const
virtual bool irrelevantCost(uint16_t cost) const {
		if(hitsForThisRead_) {
			// irrelevant iff at worse stratum
			return ((int)cost >> 14) > bestStratum_;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x60(%rax)
je 0x39915
movq -0x20(%rbp), %rcx
movzwl -0x12(%rbp), %eax
sarl $0xe, %eax
cmpl 0x78(%rcx), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x39919
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::exhausted()
void exhausted() {
		if(patid != lastSkippedRead_) {
			if(!exhaustCrash_ && !quiet) std::cerr << "Warning: ";
			if(!quiet) {
				std::cerr << "Exhausted best-first chunk memory for read "
				          << (*readName_) << " (patid " << patid
				          << "); skipping read" << std::endl;
			}
			if(exhaustCrash_) {
				if(!quiet) {
					std::cerr << "Please try specifying a larger --chunkmbs <int> (default is 32)" << std::endl;
				}
				throw 1;
			}
		}
		lastSkippedRead_ = patid;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x4(%rcx), %eax
cmpl 0x3c(%rcx), %eax
je 0x39ae8
movq -0x10(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0x39a26
testb $0x1, 0x717af(%rip)     # 0xab1c0
jne 0x39a26
movq 0x6e5d6(%rip), %rdi     # 0xa7ff0
leaq 0x53169(%rip), %rsi     # 0x8cb8a
callq 0xa5d0
testb $0x1, 0x71793(%rip)     # 0xab1c0
jne 0x39a8e
movq 0x6e5ba(%rip), %rdi     # 0xa7ff0
leaq 0x53157(%rip), %rsi     # 0x8cb94
callq 0xa5d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x2c0d0
movq %rax, %rdi
leaq 0x53164(%rip), %rsi     # 0x8cbc0
callq 0xa5d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xa810
movq %rax, %rdi
leaq 0x5314f(%rip), %rsi     # 0x8cbc9
callq 0xa5d0
movq %rax, %rdi
movq 0x6e4df(%rip), %rsi     # 0xa7f68
callq 0xa640
movq -0x10(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x39ae6
testb $0x1, 0x71721(%rip)     # 0xab1c0
jne 0x39ac3
movq 0x6e548(%rip), %rdi     # 0xa7ff0
leaq 0x5312b(%rip), %rsi     # 0x8cbda
callq 0xa5d0
movq %rax, %rdi
movq 0x6e4aa(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x6e473(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
jmp 0x39ae8
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movl %ecx, 0x3c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./aligner.h
// Function: AlignerFactory::create(unsigned int) const
virtual EList<Aligner*>* create(uint32_t n) const {
		EList<Aligner*>* v = new EList<Aligner*>;
		for(uint32_t i = 0; i < n; i++) {
			v->push_back(create());
			assert(v->back() != NULL);
		}
		return v;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x20, %edi
callq 0xa5f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x50030
jmp 0x3d9e2
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x3da43
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x50070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3d9f1
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0xa600
jmp 0x3da4d
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./aligner.h
// Function: AlignerFactory::destroy(EList<Aligner*, 128>*) const
virtual void destroy(EList<Aligner*>* als) const {
		assert(als != NULL);
		// Free all of the Aligners
		for(size_t i = 0; i < als->size(); i++) {
			if((*als)[i] != NULL) {
				delete (*als)[i];
				(*als)[i] = NULL;
			}
		}
		// Free the vector
		delete als;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50300
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3db20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x50320
cmpq $0x0, (%rax)
je 0x3db10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x50320
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3dafc
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x50320
movq $0x0, (%rax)
jmp 0x3db12
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3daa8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3db45
movq -0x30(%rbp), %rdi
callq 0x50350
movq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0xa600
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::CostAwareRangeSourceDriver(bool, EList<RangeSourceDriver<EbwtRangeSource>*, 128> const*, bool, bool, bool)
CostAwareRangeSourceDriver(
			bool strandFix,
			const TRangeSrcDrPtrVec* rss,
			bool verbose,
			bool quiet,
			bool mixesReads) :
		RangeSourceDriver<TRangeSource>(false),
		rss_(), active_(), strandFix_(strandFix),
		lastRange_(NULL), delayedRange_(NULL), patsrc_(NULL),
		verbose_(verbose), quiet_(quiet), mixesReads_(mixesReads)
	{
		if(rss != NULL) {
			rss_ = (*rss);
		}
		paired_ = false;
		this->foundRange = false;
		this->done = false;
		if(rss_.empty()) {
			return;
		}
		calcPaired();
		active_ = rss_;
		this->minCost = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %r8d, -0x58(%rbp)
movl %ecx, %eax
movl -0x58(%rbp), %ecx
movl %eax, -0x54(%rbp)
movq %rdx, %rax
movl -0x54(%rbp), %edx
movq %rax, -0x50(%rbp)
movl %esi, %eax
movq -0x50(%rbp), %rsi
movl %eax, -0x44(%rbp)
movq %rdi, %r8
movl -0x44(%rbp), %edi
movb %r9b, %al
movq %r8, -0x8(%rbp)
andb $0x1, %dil
movb %dil, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
andb $0x1, %cl
movb %cl, -0x1a(%rbp)
andb $0x1, %al
movb %al, -0x1b(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x492c0
movq -0x40(%rbp), %rdi
leaq 0x68dbb(%rip), %rax     # 0xa71a8
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3dbc0
jmp 0x3e3ff
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3dbc0
jmp 0x3e412
movq -0x40(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, 0x51(%rdi)
addq $0x58, %rdi
callq 0x3e790
jmp 0x3e429
movq -0x40(%rbp), %rax
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x88(%rax)
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x89(%rax)
movb -0x1b(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x8a(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x3e4be
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rdi
callq 0x4a960
jmp 0x3e486
jmp 0x3e4be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3e519
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3e510
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3e530
jmp 0x3e510
movq -0x40(%rbp), %rdi
movb $0x0, 0x50(%rdi)
movb $0x0, 0x8(%rdi)
movb $0x0, 0x9(%rdi)
addq $0x10, %rdi
callq 0x4adb0
testb $0x1, %al
jne 0x3e4dd
jmp 0x3e4df
jmp 0x3e50a
movq -0x40(%rbp), %rdi
callq 0x4b4e0
jmp 0x3e4ea
movq -0x40(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
addq $0x30, %rdi
callq 0x4a960
jmp 0x3e500
movq -0x40(%rbp), %rax
movw $0x0, 0xa(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3e530
movq -0x40(%rbp), %rdi
callq 0x494e0
movq -0x28(%rbp), %rdi
callq 0xab60
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./aligner.h
// Function: UnpairedAlignerV2<EbwtRangeSource>::UnpairedAlignerV2(EbwtSearchParams*, RangeSourceDriver<EbwtRangeSource>*, RangeChaser*, HitSink&, HitSinkPerThreadFactory const&, HitSinkPerThread*, EList<SString<char>, 128>&, BitPairReference*, bool, bool, bool, int, ChunkPool*, int*, AlignerMetrics*)
UnpairedAlignerV2(
		EbwtSearchParams* params,
		TDriver* driver,
		RangeChaser* rchase,
		HitSink& sink,
		const HitSinkPerThreadFactory& sinkPtFactory,
		HitSinkPerThread* sinkPt,
		EList<BTRefString >& os, // TODO: remove this, not used
		BitPairReference *refs,
		bool rangeMode,
		bool verbose,
		bool quiet,
		int maxBts,
		ChunkPool *pool,
		int *btCnt = NULL,
		AlignerMetrics *metrics = NULL) :
		Aligner(true, rangeMode),
		doneFirst_(true),
		firstIsFw_(true),
		chase_(false),
		sinkPtFactory_(sinkPtFactory),
		sinkPt_(sinkPt),
		refs_(refs),
		params_(params),
		rchase_(rchase),
		driver_(driver),
		verbose_(verbose),
		quiet_(quiet),
		maxBts_(maxBts),
		pool_(pool),
		btCnt_(btCnt),
		metrics_(metrics)
	{
		assert(pool_   != NULL);
		assert(sinkPt_ != NULL);
		assert(params_ != NULL);
		assert(driver_ != NULL);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rcx, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, %r10
movq -0x58(%rbp), %rsi
movq %rdi, %r11
movq -0x50(%rbp), %rdi
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movl 0x40(%rbp), %eax
movb 0x38(%rbp), %al
movb 0x30(%rbp), %cl
movb 0x28(%rbp), %dl
movq 0x20(%rbp), %rbx
movq 0x18(%rbp), %rbx
movq 0x10(%rbp), %rbx
movq %r11, -0x10(%rbp)
movq %r10, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
andb $0x1, %dl
movb %dl, -0x39(%rbp)
andb $0x1, %cl
movb %cl, -0x3a(%rbp)
andb $0x1, %al
movb %al, -0x3b(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb -0x39(%rbp), %al
movl $0x1, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x4b700
movq -0x48(%rbp), %rax
leaq 0x68b3f(%rip), %rcx     # 0xa7210
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
movb $0x1, 0x58(%rax)
movb $0x1, 0x59(%rax)
movb $0x0, 0x5a(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x80(%rax)
movb -0x3a(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x88(%rax)
movb -0x3b(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x89(%rax)
movl 0x40(%rbp), %ecx
movl %ecx, 0x8c(%rax)
movq 0x48(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq 0x50(%rbp), %rcx
movq %rcx, 0x98(%rax)
movq 0x58(%rbp), %rcx
movq %rcx, 0xa0(%rax)
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::calcFtabOff()
uint32_t calcFtabOff() {
		const Ebwt& ebwt = *ebwt_;
		int ftabChars = ebwt._eh._ftabChars;
		uint32_t ftabOff = (*qry_)[qlen_ - ftabChars];
		assert_lt(ftabOff, 4);
		assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		for(int i = ftabChars - 1; i > 0; i--) {
			ftabOff <<= 2;
			assert_lt((uint32_t)(*qry_)[qlen_-i], 4);
			ftabOff |= (uint32_t)(*qry_)[qlen_-i];
			assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		}
		assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		return ftabOff;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x68(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl 0x124(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq 0x18(%rax), %rdi
movq 0x50(%rax), %rsi
movslq -0x14(%rbp), %rax
subq %rax, %rsi
callq 0x403a0
movsbl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x409e7
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, -0x18(%rbp)
movq 0x18(%rax), %rdi
movq 0x50(%rax), %rsi
movslq -0x1c(%rbp), %rax
subq %rax, %rsi
callq 0x403a0
movsbl (%rax), %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x409ac
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::addPartialEdits()
void addPartialEdits() {
		// Lump in the edits from the partial alignment
		if(seedRange_.valid()) {
			const size_t srSz = seedRange_.mms.size();
			for(size_t i = 0; i < srSz; i++) {
				curRange_.mms.push_back((uint32_t)(qlen_ - seedRange_.mms[i] - 1));
				curRange_.refcs.push_back(seedRange_.refcs[i]);
			}
			curRange_.numMms += srSz;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x40360
testb $0x1, %al
jne 0x40ab9
jmp 0x40b95
movq -0x28(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
addq $0x18, %rdi
callq 0x24960
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x40b7e
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0xb8, %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq 0x50(%rdi), %rax
movq %rax, -0x38(%rbp)
addq $0x118, %rdi            # imm = 0x118
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x24930
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl (%rcx), %ecx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x32160
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0xb8, %rax
addq $0x38, %rax
movq %rax, -0x30(%rbp)
addq $0x118, %rdi            # imm = 0x118
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x40380
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x40fe0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x40ad9
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0xc8(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0xc8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)