LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BenLangmead[P]bowtie/./range_cache.h
// Function: RangeCache::lookup(unsigned int, unsigned int, RangeCacheEntry&)
bool lookup(TIndexOffU top, TIndexOffU bot, RangeCacheEntry& ent) {
		if(ebwt_ == NULL || lim_ == 0) return false;
		assert_gt(bot, top);
		ent.reset();
		TMapItr itr = map_.find(top);
		if(itr == map_.end()) {
			// No cache entry for the given 'top' offset
			if(closed_) {
				return false; // failed to get cache entry
			} else {
				if(pool_.closed()) {
					closed_ = true;
					return false; // failed to get cache entry
				}
			}
			// Use the tunnel
			bool ret = tunnel(top, bot, ent);
			return ret;
		} else {
			// There is a cache entry for the given 'top' offset
			TIndexOffU ret = itr->second;
			ent.init(pool_, top, ret, ebwt_);
			return true; // success
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x58(%rax)
je 0x4db6e
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4db77
movb $0x0, -0x1(%rbp)
jmp 0x4dc42
movq -0x20(%rbp), %rdi
callq 0x4dc50
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x4dc70
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x4dcd0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4dca0
testb $0x1, %al
jne 0x4dbb9
jmp 0x4dc0e
movq -0x40(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x4dbc9
movb $0x0, -0x1(%rbp)
jmp 0x4dc42
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
callq 0x4dd00
testb $0x1, %al
jne 0x4dbdc
jmp 0x4dbea
movq -0x40(%rbp), %rax
movb $0x1, 0x50(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x4dc42
jmp 0x4dbec
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x4dd20
andb $0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4dc42
leaq -0x28(%rbp), %rdi
callq 0x4e310
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl 0x4(%rcx), %ecx
movl %ecx, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x38, %rsi
movl -0x14(%rbp), %edx
movl -0x38(%rbp), %ecx
movq 0x58(%rax), %r8
callq 0x4e330
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./range_cache.h
// Function: RangeCacheEntry::init(RangeCacheMemPool&, unsigned int, unsigned int, Ebwt*)
void init(RangeCacheMemPool& pool, TIndexOffU top, TIndexOffU ent, Ebwt* ebwt) {
		assert(ebwt != NULL);
		top_ = top;
		ebwt_ = ebwt;
		TIndexOffU *ents = pool.get(ent);
		assert_neq(CACHE_WRAPPER_BIT, ents[0]);
		// Is hi bit set?
		if((ents[0] & CACHE_WRAPPER_BIT) != 0) {
			// If so, the target is a wrapper and the non-hi bits
			// contain the # jumps
			jumps_ = (ents[0] & ~CACHE_WRAPPER_BIT);
			assert_gt(jumps_, 0);
			assert_leq(jumps_, ebwt_->_eh._len);
			// Get the target entry
			TIndexOffU *dest = pool.get(ents[1]);
			// Get the length from the target entry
			len_ = dest[0];
			assert_leq(top_ + len_, ebwt_->_eh._len);
			assert_gt(len_, 0);
			assert_leq(len_, ebwt_->_eh._len);
			// Get the pointer to the entries themselves
			ents_ = dest + 1;
		} else {
			// Not a wrapper, so there are no jumps
			jumps_ = 0;
			// Get the length from the target entry
			len_  = ents[0];
			assert_leq(top_ + len_, ebwt_->_eh._len);
			assert_gt(len_, 0);
			assert_leq(len_, ebwt_->_eh._len);
			// Get the pointer to the entries themselves
			ents_ = ents + 1;
		}
		if (sanity_)
			assert(sanityCheckEnts());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4e750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x4e3c4
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x4e750
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
jmp 0x4e3e4
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
testb $0x1, 0x21(%rax)
je 0x4e3f0
jmp 0x4e3f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./range_cache.h
// Function: RangeCacheMemPool::alloc(unsigned int)
TIndexOffU alloc(TIndexOffU numElts) {
		assert_gt(numElts, 0);
		assert_leq(occ_, lim_);
		if(occ_ + numElts > lim_ || numElts >= CACHE_WRAPPER_BIT) {
			return RANGE_CACHE_BAD_ALLOC;
		}
		assert_gt(lim_, 0);
		TIndexOffU ret = occ_;
		assert(allocs_.find(ret) == allocs_.end());
		ASSERT_ONLY(allocs_.insert(ret));
		// Clear the first elt so that we don't think there's already
		// something there
#ifndef NDEBUG
		for(TIndexOffU i = 0; i < numElts; i++) {
			assert_eq(OFF_MASK, buf_[occ_ + i]);
		}
#endif
		buf_[occ_] = 0;
		occ_ += numElts;
		assert_leq(occ_, lim_);
		if(lim_ - occ_ < 10) {
			// No more room - don't try anymore
			closed_ = true;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x4(%rcx), %eax
addl -0x14(%rbp), %eax
cmpl (%rcx), %eax
ja 0x4e7a6
cmpl $0x80000000, -0x14(%rbp) # imm = 0x80000000
jb 0x4e7af
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e7e8
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %eax
movl %eax, -0x18(%rbp)
movq 0x8(%rcx), %rax
movl 0x4(%rcx), %edx
movl $0x0, (%rax,%rdx,4)
movl -0x14(%rbp), %eax
addl 0x4(%rcx), %eax
movl %eax, 0x4(%rcx)
movl (%rcx), %eax
subl 0x4(%rcx), %eax
cmpl $0xa, %eax
jae 0x4e7e2
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./range_cache.h
// Function: RangeCacheEntry::init(RangeCacheMemPool&, unsigned int, unsigned int, unsigned int, Ebwt*)
void init(RangeCacheMemPool& pool, TIndexOffU top, TIndexOffU jumps,
			TIndexOffU ent, Ebwt* ebwt)
	{
		assert(ebwt != NULL);
		ebwt_ = ebwt;
		top_ = top;
		jumps_ = jumps;
		TIndexOffU *ents = pool.get(ent);
		// Must not be a wrapper
		assert_eq(0, ents[0] & CACHE_WRAPPER_BIT);
		// Get the length from the target entry
		len_ = ents[0];
		assert_gt(len_, 0);
		assert_leq(len_, ebwt_->_eh._len);
		// Get the pointer to the entries themselves
		ents_ = ents + 1;
		assert_leq(top_ + len_, ebwt_->_eh._len);
		if (sanity_)
			assert(sanityCheckEnts());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x4e750
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
testb $0x1, 0x21(%rax)
je 0x4e93d
jmp 0x4e93d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./aligner_metrics.h
// Function: AlignerMetrics::nextRead(SDnaStringExpandable<25, 2> const&)
void nextRead(const BTDnaString& read) {
		if(!first_) {
			finishRead();
		}
		first_ = false;
		float ent = entropyDna5(read);
		curIsLowEntropy_ = (ent < 0.75f);
		curIsHomoPoly_ = (ent < 0.001f);
		curHadRanges_ = false;
		curBwtOps_ = 0;
		curBacktracks_ = 0;
		// Count Ns
		curNumNs_ = 0;
		const size_t len = read.length();
		for(size_t i = 0; i < len; i++) {
			if((int)read[i] == 4) curNumNs_++;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x8(%rax)
jne 0x4f877
movq -0x30(%rbp), %rdi
callq 0x4f970
movq -0x30(%rbp), %rdi
movb $0x0, 0x8(%rdi)
movq -0x10(%rbp), %rsi
callq 0x4fc80
movq -0x30(%rbp), %rax
movss %xmm0, -0x14(%rbp)
movss 0x39e83(%rip), %xmm0    # 0x8971c
ucomiss -0x14(%rbp), %xmm0
seta %cl
andb $0x1, %cl
movb %cl, 0x9(%rax)
movss 0x39e6a(%rip), %xmm0    # 0x89718
ucomiss -0x14(%rbp), %xmm0
seta %cl
andb $0x1, %cl
movb %cl, 0xa(%rax)
movb $0x0, 0xb(%rax)
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x2ef90
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4f924
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4fea0
movsbl (%rax), %eax
cmpl $0x4, %eax
jne 0x4f914
movq -0x30(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x4f916
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4f8e8
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::reset(SStringExpandable<char, 25, 2, 0>*, unsigned int)
void reset(BTString* name, uint32_t patid_) {
		patid = patid_;
		readName_ = name;
		cur_ = 0;
		bits_.clear();
		assert_eq(0, bits_.test(0));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x40(%rdi)
movl $0x0, 0x10(%rdi)
addq $0x20, %rdi
callq 0x4ffe0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./aligner_metrics.h
// Function: RunningStat::push(float)
void push(float x) {
		m_n++;
		m_tot += x;
		// See Knuth TAOCP vol 2, 3rd edition, page 232
		if (m_n == 1) {
			m_oldM = m_newM = x;
			m_oldS = 0.0;
		} else {
			m_newM = m_oldM + (x - m_oldM)/m_n;
			m_newS = m_oldS + (x - m_oldM)*(x - m_newM);
			// set up for next iteration
			m_oldM = m_newM;
			m_oldS = m_newS;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
cmpl $0x1, (%rax)
jne 0x4ff25
movq -0x18(%rbp), %rax
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
jmp 0x4ff8f
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
subsd 0x10(%rax), %xmm1
cvtsi2sdl (%rax), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x20(%rax), %xmm1
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
subsd 0x10(%rax), %xmm0
movss -0xc(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
subsd 0x18(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./ref_aligner.h
// Function: RefAligner::newBuf(unsigned int)
void newBuf(uint32_t newsz) {
		if(freeRefbuf_) {
			delete[] refbuf_;
		}
		try {
			refbuf_ = new uint32_t[(newsz + 3) / 4];
			if(refbuf_ == NULL) throw std::bad_alloc();
		} catch(std::bad_alloc& e) {
			cerr << "Error: Could not allocate reference-space alignment buffer of " << newsz << "B" << endl;
			throw 1;
		}
		refbufSz_ = newsz;
		freeRefbuf_ = true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x4024(%rax)
je 0x5968d
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5968b
movq -0x38(%rbp), %rdi
callq 0xa7c0
jmp 0x5968d
movl -0xc(%rbp), %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, %edi
callq 0xa040
movq %rax, -0x40(%rbp)
jmp 0x596a3
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x5978d
movl $0x8, %edi
callq 0xa290
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x32260
movq -0x48(%rbp), %rdi
movq 0x4e8e5(%rip), %rsi     # 0xa7fc0
movq 0x4e8a6(%rip), %rdx     # 0xa7f88
callq 0xab10
jmp 0x597cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x597bb
movq -0x18(%rbp), %rdi
callq 0xa200
movq %rax, -0x28(%rbp)
movq 0x4e8d4(%rip), %rdi     # 0xa7ff0
leaq 0x33794(%rip), %rsi     # 0x8ceb7
callq 0xa5d0
movq %rax, -0x50(%rbp)
jmp 0x5972e
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xa810
movq %rax, -0x58(%rbp)
jmp 0x59740
movq -0x58(%rbp), %rdi
leaq 0x337ab(%rip), %rsi     # 0x8cef6
callq 0xa5d0
movq %rax, -0x60(%rbp)
jmp 0x59756
movq -0x60(%rbp), %rdi
movq 0x4e807(%rip), %rsi     # 0xa7f68
callq 0xa640
jmp 0x59768
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x4e7ce(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
jmp 0x597cc
jmp 0x597a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xaa60
jmp 0x597a2
jmp 0x597bb
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
movb $0x1, 0x4024(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xab60
movq %rax, %rdi
callq 0x24d00
nopl (%rax)
// File: BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV2<EbwtRangeSource>::~PairedBWAlignerV2()
virtual ~PairedBWAlignerV2() {
		delete driver_; driver_ = NULL;
		delete params_; params_ = NULL;
		if(paramsSe1_ != NULL) {
			delete paramsSe1_; paramsSe1_ = NULL;
			delete paramsSe2_; paramsSe2_ = NULL;
		}
		delete rchase_; rchase_ = NULL;
		delete[] btCnt_; btCnt_ = NULL;
		delete refAligner_; refAligner_ = NULL;
		sinkPtFactory_.destroy(sinkPt_); sinkPt_ = NULL;
		if(sinkPtSe1_ != NULL) {
			sinkPtFactory_.destroy(sinkPtSe1_); sinkPtSe1_ = NULL;
			sinkPtFactory_.destroy(sinkPtSe2_); sinkPtSe2_ = NULL;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x4426d(%rip), %rcx     # 0xa7498
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xd0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x6324d
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6327b
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0xa600
movq -0x18(%rbp), %rax
movq $0x0, 0x98(%rax)
cmpq $0x0, 0xa0(%rax)
je 0x632f4
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x632b7
movq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0xa600
movq -0x18(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq 0xa8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x632e5
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0xa600
movq -0x18(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x63320
movq -0x38(%rbp), %rdi
callq 0x4bed0
movq -0x38(%rbp), %rdi
movl $0xc8, %esi
callq 0xa600
movq -0x18(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq 0xe8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x63349
movq -0x40(%rbp), %rdi
callq 0xa7c0
movq -0x18(%rbp), %rax
movq $0x0, 0xe8(%rax)
movq 0x70(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x63370
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq 0x78(%rax), %rdi
movq 0x80(%rax), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x63392
movq -0x18(%rbp), %rax
movq $0x0, 0x80(%rax)
cmpq $0x0, 0x88(%rax)
je 0x633f9
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
movq 0x88(%rax), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x633c5
movq -0x18(%rbp), %rax
movq $0x0, 0x88(%rax)
movq 0x78(%rax), %rdi
movq 0x90(%rax), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x633ea
movq -0x18(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x18(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x60ab0
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
callq 0x60ab0
movq -0x18(%rbp), %rdi
callq 0x4be00
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24d00
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::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
	{
		_5depth   = depth5;
		_3depth   = depth3;
		assert_geq(depth3, depth5);
		_unrevOff = unrevOff;
		_1revOff  = revOff1;
		_2revOff  = revOff2;
		_3revOff  = 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, 0xc4(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x30(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x34(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x3c(%rax)
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_util.h
// Function: PartialAlignmentManager::getPartialsUnsync(unsigned int, EList<PartialAlignment, 128>&)
void getPartialsUnsync(uint32_t patid, EList<PartialAlignment>& ps) {
		assert_eq(0, ps.size());
		if(_partialsMap.find(patid) == _partialsMap.end()) {
			return;
		}
		PartialAlignment al;
		al.u64.u64 = _partialsMap[patid].u64.u64;
		uint32_t type = al.unk.type;
		if(type == 0) {
			// singleton
			ps.push_back(al);
		} else {
			// list
			assert_eq(1, type);
			uint32_t off = (uint32_t)al.off.off;
			do {
				assert_lt(off, _partialsList.size());
				ASSERT_ONLY(type = _partialsList[off].entry.type);
				assert(type == 2 || type == 3);
#ifndef NDEBUG
				// Make sure this entry isn't equal to any other entry
				for(size_t i = 0; i < ps.size(); i++) {
					assert(validPartialAlignment(ps[i]));
					assert(!samePartialAlignment(ps[i], _partialsList[off]));
				}
#endif
				assert(validPartialAlignment(_partialsList[off]));
				ps.push_back(_partialsList[off]);
				ASSERT_ONLY(uint32_t pos0 = ps.back().entry.pos0);
				ASSERT_ONLY(uint32_t pos1 = ps.back().entry.pos1);
				ASSERT_ONLY(uint32_t pos2 = ps.back().entry.pos2);
				assert(pos1 == 0xffff || pos0 != pos1);
				assert(pos2 == 0xffff || pos0 != pos2);
				assert(pos2 == 0xffff || pos1 != pos2);
			} while(_partialsList[off++].entry.type == 2);
			assert_eq(3, _partialsList[off-1].entry.type);
		}
		assert_gt(ps.size(), 0);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x6ba50
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x6ad10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6ace0
testb $0x1, %al
jne 0x664b8
jmp 0x664bd
jmp 0x66552
movq -0x40(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6ab70
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
shrq $0x3e, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x664f1
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x698e0
jmp 0x66552
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
andq -0x30(%rbp), %rax
movl %eax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x30, %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0x668a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x698e0
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x38(%rbp)
movl %eax, %eax
movl %eax, %esi
callq 0x668a0
movq (%rax), %rax
shrq $0x3e, %rax
cmpl $0x2, %eax
je 0x66502
jmp 0x66552
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::setMuts(EList<QueryMutation, 128>*)
void setMuts(EList<QueryMutation>* muts) {
		if(_muts != NULL) {
			// Undo previous mutations
			assert_gt(_muts->size(), 0);
			undoPartialMutations();
		}
		_muts = muts;
		if(_muts != NULL) {
			assert_gt(_muts->size(), 0);
			applyPartialMutations();
		}
	}

// 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)
cmpq $0x0, 0xb0(%rax)
je 0x668fb
movq -0x18(%rbp), %rdi
callq 0x69a70
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xb0(%rax)
cmpq $0x0, 0xb0(%rax)
je 0x6691d
movq -0x18(%rbp), %rdi
callq 0x69e60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::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 0x20(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl 0x124(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq (%rax), %rdi
movq 0x8(%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 0x67325
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, -0x18(%rbp)
movq (%rax), %rdi
movq 0x8(%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 0x672eb
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::backtrack(unsigned int, unsigned int, unsigned int, unsigned int, bool)
bool backtrack(uint32_t depth,
	               TIndexOffU top,
	               TIndexOffU bot,
	               uint32_t iham = 0,
	               bool disableFtab = false)
	{
		HitSinkPerThread& sink = _params.sink();
		_ihits = sink.retainedHits().size();

		// Initiate the recursive, randomized quality-aware backtracker
		// with a stack depth of 0 (no backtracks so far)
		_bailedOnBacktracks = false;
		bool done = backtrack(0, depth, _unrevOff, _1revOff, _2revOff, _3revOff,
		                      top, bot, iham, iham, _pairs, _elims, disableFtab);

		_totNumBts += _numBts;
		_numBts = 0;
		_precalcedSideLocus = false;
		_bailedOnBacktracks = false;
		return done;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movb %r9b, %al
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movl %r8d, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x41(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x28(%rax), %rdi
callq 0x4d8e0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x67610
movq %rax, %rdi
callq 0x37e60
movq -0x60(%rbp), %rdi
movq %rax, 0x150(%rdi)
movb $0x0, 0x130(%rdi)
movl -0x34(%rbp), %edx
movl 0x30(%rdi), %ecx
movl 0x34(%rdi), %r8d
movl 0x38(%rdi), %r9d
movl 0x3c(%rdi), %r13d
movl -0x38(%rbp), %r12d
movl -0x3c(%rbp), %r15d
movl -0x40(%rbp), %r14d
movl -0x40(%rbp), %ebx
movq 0x48(%rdi), %r11
movq 0x50(%rdi), %r10
movb -0x41(%rbp), %al
xorl %esi, %esi
andb $0x1, %al
movl %r13d, (%rsp)
movl %r12d, 0x8(%rsp)
movl %r15d, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movl %ebx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movzbl %al, %eax
movl %eax, 0x38(%rsp)
callq 0x67630
movb %al, %cl
movq -0x60(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x51(%rbp)
movl 0x100(%rax), %ecx
addl 0x104(%rax), %ecx
movl %ecx, 0x104(%rax)
movl $0x0, 0x100(%rax)
movb $0x0, 0x10c(%rax)
movb $0x0, 0x130(%rax)
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::finalize()
bool finalize() {
		bool ret = false;
		if(_reportPartials > 0) {
			// We're in partial alignment mode; take elements of the
			// _partialBuf and install them in the _partials database
			assert(_partials != NULL);
			if(_partialsBuf.size() > 0) {
#ifndef NDEBUG
				for(size_t i = 0; i < _partialsBuf.size(); i++) {
					assert(_partialsBuf[i].repOk(_qualThresh, (uint32_t)_qlen, (*_qual), _maqPenalty));
				}
#endif
				_partials->addPartials(_params.patId(), _partialsBuf);
				_partialsBuf.clear();
				ret = true;
			} else {
				assert(!ret);
			}
		}
		assert_eq(0, _partialsBuf.size());
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
cmpl $0x0, 0xa0(%rax)
jbe 0x675ff
movq -0x18(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x665a0
cmpq $0x0, %rax
jbe 0x675fb
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x28(%rax), %rdi
callq 0x6ab20
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl %eax, %esi
addq $0x158, %rdx            # imm = 0x158
callq 0x6a870
movq -0x18(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x66430
movb $0x1, -0x9(%rbp)
jmp 0x675fd
jmp 0x675fd
jmp 0x675ff
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::eliminate(unsigned char*, unsigned int, int)
void eliminate(uint8_t *elims, uint32_t d, int c) {
		if(c < 4) {
			elims[d] = (1 << c);
			assert_gt(elims[d], 0);
			assert_lt(elims[d], 16);
		} else {
			elims[d] = 0;
		}
		assert_lt(elims[d], 16);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x69590
movl -0x18(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
jmp 0x6959b
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::calcStratum(EList<unsigned int, 128> const&, unsigned int)
int calcStratum(const EList<TIndexOffU>& mms, uint32_t stackDepth) {
		int stratum = 0;
		for(size_t i = 0; i < stackDepth; i++) {
			if(mms[i] >= (_qlen - _3revOff)) {
				// This mismatch falls within the seed; count it
				// toward the stratum to report
				stratum++;
				// Don't currently support more than 3
				// mismatches in the seed
				assert_leq(stratum, 3);
			}
		}
		return stratum;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x69a61
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d670
movq -0x28(%rbp), %rdx
movl (%rax), %eax
movq 0x8(%rdx), %rcx
movl 0x3c(%rdx), %edx
subq %rdx, %rcx
cmpq %rcx, %rax
jb 0x69a51
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x69a53
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x69a1a
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::undoPartialMutations()
void undoPartialMutations() {
		if(_muts == NULL) {
			// No mutations to undo
			return;
		}
		for(size_t i = 0; i < _muts->size(); i++) {
			const QueryMutation& m = (*_muts)[i];
			assert_lt(m.pos, _qlen);
			assert_leq(m.oldBase, 4);
			assert_lt(m.newBase, 4);
			assert_neq(m.oldBase, m.newBase);
			assert_eq((uint32_t)((*_qry)[m.pos]), (uint32_t)m.newBase);
			(*_qry)[m.pos] = (char)m.oldBase; // undo it
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0xb0(%rax)
jne 0x69a90
jmp 0x69b09
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0xb0(%rax), %rdi
callq 0x69ca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x69b09
movq -0x20(%rbp), %rax
movq 0xb0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x69f00
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movb 0x2(%rcx), %cl
movb %cl, -0x29(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %esi
callq 0x403a0
movb -0x29(%rbp), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x69a98
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::applyPartialMutations()
void applyPartialMutations() {
		if(_muts == NULL) {
			// No mutations to apply
			return;
		}
		for(size_t i = 0; i < _muts->size(); i++) {
			const QueryMutation& m = (*_muts)[i];
			assert_lt(m.pos, _qlen);
			assert_leq(m.oldBase, 4);
			assert_lt(m.newBase, 4);
			assert_neq(m.oldBase, m.newBase);
			assert_eq((uint32_t)((*_qry)[m.pos]), (uint32_t)m.oldBase);
			(*_qry)[m.pos] = (char)m.newBase; // apply it
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0xb0(%rax)
jne 0x69e80
jmp 0x69ef9
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0xb0(%rax), %rdi
callq 0x69ca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x69ef9
movq -0x20(%rbp), %rax
movq 0xb0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x69f00
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movb 0x3(%rcx), %cl
movb %cl, -0x29(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %esi
callq 0x403a0
movb -0x29(%rbp), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x69e88
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/pat.cpp
// Function: PatternSourcePerThread::finalize(Read&)
void PatternSourcePerThread::finalize(Read& ra) {
	ra.mate = 0;
	ra.constructRevComps();
	ra.constructReverses();
	ra.seed = genRandSeed(ra.patFw, ra.qual, ra.name, 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), %rax
movl $0x0, 0x188(%rax)
movq -0x10(%rbp), %rdi
callq 0x827e0
movq -0x10(%rbp), %rdi
callq 0x82810
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
movq -0x10(%rbp), %rdx
addq $0x150, %rdx            # imm = 0x150
movl 0x74(%rax), %ecx
callq 0x7e700
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/pat.cpp
// Function: genRandSeed(SDnaStringExpandable<25, 2> const&, SStringExpandable<char, 25, 2, 0> const&, SStringExpandable<char, 25, 2, 0> const&, unsigned int)
static uint32_t genRandSeed(
	const BTDnaString& qry,
	const BTString& qual,
	const BTString& name,
	uint32_t seed)
{
	// Calculate a per-read random seed based on a combination of
	// the read data (incl. sequence, name, quals) and the global
	// seed
	uint32_t rseed = (seed + 101) * 59 * 61 * 67 * 71 * 73 * 79 * 83;
	size_t qlen = qry.length();
	// Throw all the characters of the read into the random seed
	for(size_t i = 0; i < qlen; i++) {
		int p = (int)qry[i];
		assert_leq(p, 4);
		size_t off = ((i & 15) << 1);
		rseed ^= (p << off);
	}
	// Throw all the quality values for the read into the random
	// seed
	for(size_t i = 0; i < qlen; i++) {
		int p = (int)qual[i];
		assert_leq(p, 255);
		size_t off = ((i & 3) << 3);
		rseed ^= (p << off);
	}
	// Throw all the characters in the read name into the random
	// seed
	size_t namelen = name.length();
	for(size_t i = 0; i < namelen; i++) {
		int p = (int)name[i];
		assert_leq(p, 255);
		size_t off = ((i & 3) << 3);
		rseed ^= (p << off);
	}
	return rseed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x65, %eax
imull $0x3b, %eax, %eax
imull $0x3d, %eax, %eax
imull $0x43, %eax, %eax
imull $0x47, %eax, %eax
imull $0x49, %eax, %eax
imull $0x4f, %eax, %eax
imull $0x53, %eax, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ef90
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7e796
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4fea0
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
andq $0xf, %rax
shlq %rax
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %eax
movq -0x40(%rbp), %rcx
shll %cl, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7e74d
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7e7e8
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x49b90
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
andq $0x3, %rax
shlq $0x3, %rax
movq %rax, -0x58(%rbp)
movl -0x4c(%rbp), %eax
movq -0x58(%rbp), %rcx
shll %cl, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x7e79e
movq -0x18(%rbp), %rdi
callq 0x2ef90
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x7e847
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x49b90
movsbl (%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rax
andq $0x3, %rax
shlq $0x3, %rax
movq %rax, -0x78(%rbp)
movl -0x6c(%rbp), %eax
movq -0x78(%rbp), %rcx
shll %cl, %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x7e7fd
movl -0x20(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/pat.cpp
// Function: PatternSourcePerThread::finalizePair(Read&, Read&)
void PatternSourcePerThread::finalizePair(Read& ra, Read& rb) {
	ra.mate = 1;
	ra.constructRevComps();
	ra.constructReverses();
	ra.fixMateName(1);
	ra.seed = genRandSeed(ra.patFw, ra.qual, ra.name, seed_);

	rb.mate = 2;
	rb.constructRevComps();
	rb.constructReverses();
	rb.fixMateName(2);
	rb.seed = genRandSeed(rb.patFw, rb.qual, rb.name, seed_);
}

// 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 -0x10(%rbp), %rax
movl $0x1, 0x188(%rax)
movq -0x10(%rbp), %rdi
callq 0x827e0
movq -0x10(%rbp), %rdi
callq 0x82810
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x82870
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
movq -0x10(%rbp), %rdx
addq $0x150, %rdx            # imm = 0x150
movl 0x74(%rax), %ecx
callq 0x7e700
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18c(%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x188(%rax)
movq -0x18(%rbp), %rdi
callq 0x827e0
movq -0x18(%rbp), %rdi
callq 0x82810
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x82870
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
movq -0x18(%rbp), %rdx
addq $0x150, %rdx            # imm = 0x150
movl 0x74(%rax), %ecx
callq 0x7e700
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/pat.cpp
// Function: SoloPatternComposer::nextBatch(PerThreadReadBuf&)
pair<bool, int> SoloPatternComposer::nextBatch(PerThreadReadBuf& pt) {
	uint32_t cur = cur_;
	while(cur < src_.size()) {
		// Patterns from srca_[cur_] are unpaired
		pair<bool, int> res;
		do {
			res = src_[cur]->nextBatch(
				pt,
				true,  // batch A (or pairs)
				true); // grab lock below
		} while(!res.first && res.second == 0);
		if(res.second == 0) {
			ThreadSafe ts(&mutex_m);
			if(cur + 1 > cur_) {
				cur_++;
			}
			cur = cur_;
			continue; // on to next pair of PatternSources
		}
		return res;
	}
	assert_leq(cur, src_.size());
	return make_pair(true, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
callq 0x29fa0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x7ec0d
leaq -0x8(%rbp), %rdi
callq 0x82ad0
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x29fc0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movl $0x1, %ecx
movl %ecx, %edx
callq *0x10(%rax)
movq %rax, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x82af0
xorl %eax, %eax
testb $0x1, -0x8(%rbp)
movb %al, -0x49(%rbp)
jne 0x7ebb7
cmpl $0x0, -0x4(%rbp)
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x7eb6b
cmpl $0x0, -0x4(%rbp)
jne 0x7ec0b
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x2f3b0
movq -0x40(%rbp), %rcx
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jbe 0x7ebf3
movq -0x40(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2f3e0
jmp 0x7eb3e
jmp 0x7ec29
movb $0x1, -0x31(%rbp)
movl $0x0, -0x38(%rbp)
leaq -0x31(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x82b20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/pat.cpp
// Function: CFilePatternSource::nextBatchImpl(PerThreadReadBuf&, bool)
pair<bool, int> CFilePatternSource::nextBatchImpl(
	PerThreadReadBuf& pt,
	bool batch_a)
{
	bool done = false;
	size_t nread = 0;
	pt.setReadId(readCnt_);
	while(true) { // loop that moves on to next file when needed
		do {
			pair<bool, int> ret = nextBatchFromFile(pt, batch_a, nread);
			done = ret.first;
			nread = ret.second;
		} while(!done && nread == 0); // not sure why this would happen
		if(done && filecur_ < infiles_.size()) { // finished with this file
			open();
			resetForNextFile(); // reset state to handle a fresh file
			filecur_++;
			if(nread == 0 || nread < pt.max_buf_) {
				continue;
			}
			done = false;
		}
		break;
	}
	assert_geq(nread, 0);
	readCnt_ += nread;
	return make_pair(done, nread);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x1a(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x82b80
jmp 0x7efda
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %dl
movq -0x28(%rbp), %rcx
movq (%rdi), %rax
andb $0x1, %dl
movzbl %dl, %edx
callq *0x30(%rax)
movq %rax, -0x30(%rbp)
movb -0x30(%rbp), %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
testb $0x1, -0x1a(%rbp)
movb %al, -0x49(%rbp)
jne 0x7f01f
cmpq $0x0, -0x28(%rbp)
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x7efda
testb $0x1, -0x1a(%rbp)
je 0x7f096
movq -0x48(%rbp), %rdi
movq 0x80(%rdi), %rax
movq %rax, -0x58(%rbp)
addq $0x20, %rdi
callq 0x26400
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x7f096
movq -0x48(%rbp), %rdi
callq 0x7f0e0
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x48(%rbp), %rax
movq 0x80(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x80(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x7f08d
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x7f092
jmp 0x7efd8
movb $0x0, -0x1a(%rbp)
jmp 0x7f098
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rdx
movq 0x8(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
leaq -0x1a(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x82ba0
movb %al, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x82bd0
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/pat.cpp
// Function: CFilePatternSource::nextBatch(PerThreadReadBuf&, bool, bool)
pair<bool, int> CFilePatternSource::nextBatch(
	PerThreadReadBuf& pt,
	bool batch_a,
	bool lock)
{
	if(lock) {
		// synchronization at this level because both reading and manipulation of
		// current file pointer have to be protected
		ThreadSafe ts(&mutex);
		return nextBatchImpl(pt, batch_a);
	} else {
		return nextBatchImpl(pt, batch_a);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, -0x1a(%rbp)
je 0x7f652
movq -0x40(%rbp), %rsi
addq $0x10, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2f3b0
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
callq 0x7efa0
movq %rax, -0x48(%rbp)
jmp 0x7f628
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f3e0
jmp 0x7f66b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f3e0
jmp 0x7f675
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x7efa0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xab60
nop
// File: BenLangmead[P]bowtie/pat.cpp
// Function: VectorPatternSource::nextBatchImpl(PerThreadReadBuf&, bool)
pair<bool, int> VectorPatternSource::nextBatchImpl(
	PerThreadReadBuf& pt,
	bool batch_a)
{
	pt.setReadId(cur_);
	EList<Read>& readbuf = batch_a ? pt.bufa_ : pt.bufb_;
	size_t readi = 0;

	for(; readi < pt.max_buf_ && cur_ < bufs_.size(); readi++, cur_++) {
		readbuf[readi].readOrigBuf.append(bufs_[cur_].c_str());
	}
	readCnt_ += readi;
	return make_pair(cur_ == bufs_.size(), readi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq 0x20(%rax), %rsi
callq 0x82b80
testb $0x1, -0x19(%rbp)
je 0x7fc33
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
jmp 0x7fc3f
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x59(%rbp)
jae 0x7fc86
movq -0x50(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x68(%rbp)
addq $0x50, %rdi
callq 0x26400
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x7fc8f
jmp 0x7fcf3
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x36630
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq $0x120, %rcx            # imm = 0x120
movq %rcx, -0x70(%rbp)
movq %rax, %rdi
addq $0x50, %rdi
movq 0x20(%rax), %rsi
callq 0x27460
movq %rax, %rdi
callq 0xa210
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x82f40
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x7fc4f
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq 0x8(%rdi), %rax
addq %rcx, %rax
movq %rax, 0x8(%rdi)
movq 0x20(%rdi), %rax
movq %rax, -0x78(%rbp)
addq $0x50, %rdi
callq 0x26400
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x41(%rbp)
leaq -0x41(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x82f80
movb %al, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x82bd0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/pat.cpp
// Function: VectorPatternSource::nextBatch(PerThreadReadBuf&, bool, bool)
pair<bool, int> VectorPatternSource::nextBatch(
	PerThreadReadBuf& pt,
	bool batch_a,
	bool lock)
{
	if(lock) {
		ThreadSafe ts(&mutex);
		return nextBatchImpl(pt, batch_a);
	} else {
		return nextBatchImpl(pt, batch_a);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, -0x1a(%rbp)
je 0x7fde2
movq -0x40(%rbp), %rsi
addq $0x10, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2f3b0
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
callq 0x7fbf0
movq %rax, -0x48(%rbp)
jmp 0x7fdb8
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f3e0
jmp 0x7fdfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f3e0
jmp 0x7fe05
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x7fbf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xab60
nop
// File: BenLangmead[P]bowtie/pat.cpp
// Function: wrongQualityFormat(SStringExpandable<char, 25, 2, 0> const&)
void wrongQualityFormat(const BTString& read_name) {
	cerr << "Encountered a space parsing the quality string for read " << read_name << endl
	     << "If this is a FASTQ file with integer (non-ASCII-encoded) qualities, please" << endl
	     << "re-run Bowtie with the --integer-quals option." << endl;
	throw 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x27d8d(%rip), %rdi     # 0xa7ff0
leaq 0xe132(%rip), %rsi      # 0x8e39c
callq 0xa5d0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2c0d0
movq %rax, %rdi
movq 0x27ce3(%rip), %rsi     # 0xa7f68
callq 0xa640
movq %rax, %rdi
leaq 0xe141(%rip), %rsi      # 0x8e3d5
callq 0xa5d0
movq %rax, %rdi
movq 0x27cc5(%rip), %rsi     # 0xa7f68
callq 0xa640
movq %rax, %rdi
leaq 0xe16e(%rip), %rsi      # 0x8e420
callq 0xa5d0
movq %rax, %rdi
movq 0x27ca7(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x27c70(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
nopl (%rax)