LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset<1024>::str[abi:cxx11]() const
std::string str() const {
		std::ostringstream oss;
		for(int i = (int)size()-1; i >= 0; i--) {
			oss << (test(i)? "1" : "0");
		}
		return oss.str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x9620
movl 0x4(%r14), %ebp
leaq 0x260ad(%rip), %r12     # 0x5853c
leaq 0x2238c(%rip), %r13     # 0x54822
testl %ebp, %ebp
jle 0x324c0
decl %ebp
movl %ebp, %eax
shrl $0x5, %eax
movl 0x8(%r14,%rax,4), %eax
btl %ebp, %eax
movq %r12, %rsi
jae 0x324b1
movq %r13, %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x9560
jmp 0x32496
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x97e0
movq 0x38ac4(%rip), %rsi     # 0x6af98
movq %rsp, %rdi
callq 0x9220
leaq 0x70(%rsp), %rdi
callq 0x9180
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x324fd
movq %rax, %rbx
movq 0x38a91(%rip), %rsi     # 0x6af98
movq %rsp, %rdi
callq 0x9220
leaq 0x70(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
cmpq $0x0, 0x58(%rdi)
je 0x32640
cmpl $0x0, (%rdi)
je 0x32640
movq $0x0, 0x10(%rcx)
movq 0x18(%rdi), %r9
leaq 0x10(%rdi), %rax
movq %rax, %r8
testq %r9, %r9
je 0x325e4
movq %rax, %r8
xorl %r10d, %r10d
cmpl %esi, 0x20(%r9)
setb %r10b
cmovaeq %r9, %r8
movq 0x10(%r9,%r10,8), %r9
testq %r9, %r9
jne 0x325cb
movq %rax, %r9
cmpq %rax, %r8
je 0x325f7
cmpl %esi, 0x20(%r8)
cmovaq %rax, %r8
movq %r8, %r9
cmpq %rax, %r9
je 0x3262a
movl 0x24(%r9), %eax
movq 0x58(%rdi), %rdx
movl %esi, (%rcx)
movq %rdx, 0x18(%rcx)
movq 0x40(%rdi), %rdx
leaq (%rdx,%rax,4), %rax
movl (%rax), %edx
testl %edx, %edx
js 0x32641
movl $0x0, 0x4(%rcx)
movl (%rax), %edx
movl %edx, 0x8(%rcx)
addq $0x4, %rax
jmp 0x3265f
cmpb $0x0, 0x50(%rdi)
jne 0x3263e
cmpb $0x1, 0x48(%rdi)
jne 0x32666
movb $0x1, 0x50(%rdi)
xorl %eax, %eax
retq
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl %edx, 0x4(%rcx)
movl 0x4(%rax), %eax
movq 0x40(%rdi), %rdx
leaq (%rdx,%rax,4), %rax
addq $0x4, %rax
movl -0x4(%rax), %edx
movl %edx, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./aligner_metrics.h
// Function: AlignerMetrics::nextRead(SDnaStringExpandable<25, 2> const&)
void nextRead(const BTDnaString& read) {
		if(!first_) {
			finishRead();
		}
		first_ = false;
		float ent = entropyDna5(read);
		curIsLowEntropy_ = (ent < 0.75f);
		curIsHomoPoly_ = (ent < 0.001f);
		curHadRanges_ = false;
		curBwtOps_ = 0;
		curBacktracks_ = 0;
		// Count Ns
		curNumNs_ = 0;
		const size_t len = read.length();
		for(size_t i = 0; i < len; i++) {
			if((int)read[i] == 4) curNumNs_++;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x8(%rdi)
jne 0x32d5d
movq %r14, %rdi
callq 0x32f04
movb $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x32d99
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movsbq (%rcx,%rdx), %rsi
incq 0x10(%rsp,%rsi,8)
incq %rdx
cmpq %rdx, %rax
jne 0x32d87
movq 0x30(%rsp), %rcx
testq %rcx, %rcx
je 0x32e12
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %rsi
cmpq %rsi, %r8
setb %dil
movq 0x20(%rsp), %rdx
cmpq %rdx, %r8
setb %r9b
orb %dil, %r9b
movq 0x28(%rsp), %rdi
cmpq %rdi, %r8
setb %r10b
orb %r9b, %r10b
je 0x32df6
cmpq %rdx, %rsi
setb %r8b
cmpq %rdi, %rsi
setb %r9b
orb %r8b, %r9b
je 0x32e00
cmpq %rdi, %rdx
jae 0x32e0a
addq %rcx, %rdi
movq %rdi, 0x28(%rsp)
jmp 0x32e12
addq %rcx, %r8
movq %r8, 0x10(%rsp)
jmp 0x32e12
addq %rcx, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x32e12
addq %rcx, %rdx
movq %rdx, 0x20(%rsp)
testq %rax, %rax
js 0x32e21
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x32e39
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
xorps %xmm0, %xmm0
xorl %r15d, %r15d
movq 0x10(%rsp,%r15,8), %rax
testq %rax, %rax
je 0x32e9d
movss %xmm0, 0xc(%rsp)
js 0x32e61
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x32e79
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x4(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
callq 0x99d0
mulss 0x8(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
incq %r15
cmpq $0x4, %r15
jne 0x32e45
ucomiss 0x204f7(%rip), %xmm0    # 0x533a4
seta 0x9(%r14)
ucomiss 0x204ef(%rip), %xmm0    # 0x533a8
seta 0xa(%r14)
movb $0x0, 0xb(%r14)
movq $0x0, (%r14)
movl $0x0, 0xc(%r14)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x32ef9
movl 0xc(%r14), %ecx
xorl %edx, %edx
movq 0x8(%rbx), %rsi
cmpb $0x4, (%rsi,%rdx)
jne 0x32ef1
incl %ecx
movl %ecx, 0xc(%r14)
incq %rdx
cmpq %rdx, %rax
jne 0x32ee1
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%rdi)
cvtss2sd %xmm0, %xmm0
movsd 0x8(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
testl %ecx, %ecx
je 0x330e8
movsd 0x10(%rdi), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
cvtsi2sd %eax, %xmm3
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, 0x18(%rdi)
subsd %xmm4, %xmm0
mulsd %xmm2, %xmm0
addsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd %xmm4, 0x10(%rdi)
movsd %xmm0, 0x20(%rdi)
retq
movsd %xmm0, 0x18(%rdi)
movsd %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ref_aligner.h
// Function: RefAligner::find(unsigned int, unsigned long, BitPairReference const*, SDnaStringExpandable<25, 2> const&, SStringExpandable<char, 25, 2, 0> const&, unsigned int, unsigned int, EList<Range, 128>&, EList<unsigned int, 128>&, std::set<std::pair<unsigned long, unsigned long>, std::less<std::pair<unsigned long, unsigned long>>, std::allocator<std::pair<unsigned long, unsigned long>>>*, unsigned int, bool)
virtual void find(uint32_t numToFind,
	                  const size_t tidx,
	                  const BitPairReference *refs,
	                  const BTDnaString& qry,
	                  const BTString& quals,
	                  TIndexOffU begin,
	                  TIndexOffU end,
	                  TRangeVec& ranges,
	                  EList<TIndexOffU>& results,
	                  TSetPairs* pairs = NULL,
	                  TIndexOffU aoff = OFF_MASK,
	                  bool seedOnLeft = false)
		{
			assert_gt(numToFind, 0);
			assert_gt(end, begin);
			TIndexOffU spread = end - begin;
			TIndexOffU spreadPlus = spread + 12;
			// Make sure the buffer is large enough to accommodate the spread
			if(spreadPlus > this->refbufSz_) {
				this->newBuf(spreadPlus);
			}
			// Read in the relevant stretch of the reference string
			int offset = refs->getStretch(this->refbuf_, tidx, begin, spread);
			uint8_t *buf = ((uint8_t*)this->refbuf_) + offset;
			// Look for alignments
			ASSERT_ONLY(uint32_t irsz = (uint32_t)ranges.size());
			anchor64Find(numToFind, tidx, buf, qry, quals, begin,
				     end, ranges, results, pairs, aoff, seedOnLeft);
#ifndef NDEBUG
			for(size_t i = irsz; i < results.size(); i++) {
				assert_eq(ranges[i].numMms, ranges[i].mms.size());
				assert_eq(ranges[i].numMms, ranges[i].refcs.size());
			}
#endif
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl 0x58(%rsp), %ebx
movl 0x50(%rsp), %r14d
subl %r14d, %ebx
leal 0xc(%rbx), %esi
cmpl 0x20(%rdi), %esi
jbe 0x3726b
movq %r12, %rdi
callq 0x37e84
movq 0x18(%r12), %rsi
movl %r14d, %ecx
movl %ebx, %r8d
movq %r13, %rdi
movq %r15, %rdx
callq 0x37f56
movslq %eax, %rcx
addq 0x18(%r12), %rcx
movq (%r12), %rax
movq 0x18(%rax), %rax
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x1, 0x4024(%rdi)
jne 0x37ea4
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x37ea4
callq 0x95e0
leal 0x3(%rbx), %edi
andl $-0x4, %edi
callq 0x9030
movq %rax, 0x18(%r14)
movl %ebx, 0x20(%r14)
movb $0x1, 0x4024(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x37f45
movq %r14, %rdi
callq 0x91a0
movq 0x33112(%rip), %rdi     # 0x6aff0
leaq 0x1ec8b(%rip), %rsi     # 0x56b70
movl $0x3e, %edx
callq 0x9560
movl %ebx, %esi
movq 0x330f8(%rip), %rdi     # 0x6aff0
callq 0x92e0
movq %rax, %rbx
leaq 0x1eca8(%rip), %rsi     # 0x56baf
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %rbx, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x33005(%rip), %rsi     # 0x6af38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
movq %rax, %r14
callq 0x9840
movq %r14, %rdi
callq 0x9930
movq %rax, %rdi
callq 0x1b23d
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV1<EbwtRangeSource>::advance()
virtual bool advance() {
		assert(!this->done);
		if(doneFw_ && doneFwFirst_) {
			if(verbose2_) cout << "--" << endl;
			chaseL_        = &chaseL_rc_;
			chaseR_        = &chaseR_rc_;
			delayedchaseL_ = &delayedchaseL_rc_;
			delayedchaseR_ = &delayedchaseR_rc_;
			drL_           = &drL_rc_;
			drR_           = &drR_rc_;
			offsLarr_      = offsLarr_rc_;
			offsRarr_      = offsRarr_rc_;
			rangesLarr_    = rangesLarr_rc_;
			rangesRarr_    = rangesRarr_rc_;
			offsLsz_       = &offsLsz_rc_;
			offsRsz_       = &offsRsz_rc_;
			donePair_      = &this->done;
			fwL_           = !fw2_;
			fwR_           = !fw1_;
			doneFwFirst_   = false;
			mixedAttempts_ = 0;
		}
		bool chasing = *chaseL_ || *chaseR_;
		if(chasing && !rchase_->foundOff() && !rchase_->done) {
			rchase_->advance();
			return false;
		}
		advanceOrientation(!doneFw_);
		if(this->done) {
			if(verbose2_) cout << "----" << endl;
			sinkPt_->finishRead(*patsrc_, true, true);
		}
		return this->done;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x68(%rdi)
jne 0x3c434
cmpb $0x1, 0x69(%rbx)
jne 0x3c434
cmpb $0x1, 0x22a8(%rbx)
jne 0x3c39c
movq 0x2ec4f(%rip), %r14     # 0x6afb0
leaq 0x1a873(%rip), %rsi     # 0x56bdb
movl $0x2, %edx
movq %r14, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
movq 0x2178(%rbx), %rax
movq %rax, 0x21d8(%rbx)
movups 0x2180(%rbx), %xmm0
movups %xmm0, 0x21e0(%rbx)
movups 0x2190(%rbx), %xmm0
movups %xmm0, 0x21f0(%rbx)
movups 0x21a0(%rbx), %xmm0
movups %xmm0, 0x2200(%rbx)
movups 0x21b0(%rbx), %xmm0
movups %xmm0, 0x2210(%rbx)
movups 0x21c0(%rbx), %xmm0
movups %xmm0, 0x2220(%rbx)
movq 0x21d0(%rbx), %rax
movq %rax, 0x2230(%rbx)
leaq 0x8(%rbx), %rax
movq %rax, 0x2238(%rbx)
movb 0xb4(%rbx), %al
movb 0xb5(%rbx), %cl
xorb $0x1, %cl
movb %cl, 0x2240(%rbx)
xorb $0x1, %al
movb %al, 0x2241(%rbx)
movb $0x0, 0x69(%rbx)
movl $0x0, 0xb0(%rbx)
movq 0x21d8(%rbx), %rax
cmpb $0x0, (%rax)
jne 0x3c44c
movq 0x21e0(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x3c462
movq 0xb8(%rbx), %rdi
cmpl $-0x1, 0x28(%rdi)
jne 0x3c462
cmpb $0x0, (%rdi)
je 0x3c4e8
movzbl 0x68(%rbx), %esi
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x3c81a
cmpb $0x1, 0x8(%rbx)
jne 0x3c4dd
cmpb $0x1, 0x22a8(%rbx)
jne 0x3c4c2
movq 0x2eb29(%rip), %r14     # 0x6afb0
leaq 0x1a74b(%rip), %rsi     # 0x56bd9
movl $0x4, %edx
movq %r14, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
movq 0x58(%rbx), %rsi
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %edx
movl $0x1, %ecx
callq *0x10(%rax)
movb 0x8(%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x31530
xorl %eax, %eax
jmp 0x3c4e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x2cbb7(%rip), %rax     # 0x6a490
movq %rax, (%rdi)
movq 0xd0(%rdi), %rdi
testq %rdi, %rdi
je 0x3d8ee
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0xd0(%rbx)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x3d90f
movl $0x18, %esi
callq 0x94c0
movq $0x0, 0x98(%rbx)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x3d95c
movl $0x18, %esi
callq 0x94c0
movq $0x0, 0xa0(%rbx)
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d951
movl $0x18, %esi
callq 0x94c0
movq $0x0, 0xa8(%rbx)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d972
movl $0xc8, %esi
callq 0x94c0
movq $0x0, 0xc8(%rbx)
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d98e
callq 0x95e0
movq $0x0, 0xe8(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x3d9a8
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x70(%rbx)
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x80(%rbx)
movq 0x88(%rbx), %rsi
testq %rsi, %rsi
je 0x3da09
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x88(%rbx)
movq 0x78(%rbx), %rdi
movq 0x90(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x90(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x3c7ca
addq $0xf0, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3c7ca
movq %rax, %rdi
callq 0x1b23d
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV2<EbwtRangeSource>::resolveOutstanding(std::pair<unsigned int, unsigned int> const&, unsigned int, Range const&)
void resolveOutstanding(const UPair& off,
	                        const TIndexOffU tlen,
	                        const Range& range)
	{
		assert(!this->done);
		if(!donePe_) {
			bool ret = resolveOutstandingInRef(off, tlen, range);
			if(++mixedAttempts_ > mixedAttemptLim_ || ret) {
				// Give up on this pair
				donePe_ = true;
				if(sinkPtSe1_ != NULL) {
					if(doneSe1_) driver_->removeMate(1);
					if(doneSe2_) driver_->removeMate(2);
				}
			}
			this->done = (donePe_ && (!sinkPt_->empty() || sinkPtSe1_ == NULL || (doneSe1_ && doneSe2_)));
		}
		if(!this->done && sinkPtSe1_ != NULL) {
			bool doneSe = (range.mate1 ? doneSe1_ : doneSe2_);
			if(!doneSe) {
				// Hold onto this single-end alignment in case we don't
				// find any paired alignments
				reportSe(range, off, tlen);
			}
			this->done = doneSe1_ && doneSe2_ && donePe_;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x0, 0x69(%rdi)
jne 0x3df83
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x3dfd6
movl 0xb8(%rbx), %ecx
movl 0xbc(%rbx), %edx
incl %edx
movl %edx, 0xbc(%rbx)
testb %al, %al
jne 0x3df15
cmpl %ecx, %edx
jbe 0x3df53
movb $0x1, 0x69(%rbx)
cmpq $0x0, 0x88(%rbx)
je 0x3df53
cmpb $0x1, 0x6a(%rbx)
jne 0x3df3b
movq 0xd0(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x48(%rax)
cmpb $0x1, 0x6b(%rbx)
jne 0x3df53
movq 0xd0(%rbx), %rdi
movq (%rdi), %rax
movl $0x2, %esi
callq *0x48(%rax)
cmpb $0x1, 0x69(%rbx)
jne 0x3df7e
movq 0x80(%rbx), %rax
cmpq $0x0, 0x58(%rax)
movb $0x1, %al
jne 0x3df80
cmpq $0x0, 0x88(%rbx)
je 0x3df80
cmpb $0x1, 0x6a(%rbx)
jne 0x3df7e
movb 0x6b(%rbx), %al
jmp 0x3df80
xorl %eax, %eax
movb %al, 0x8(%rbx)
cmpb $0x0, 0x8(%rbx)
jne 0x3dfcc
cmpq $0x0, 0x88(%rbx)
je 0x3dfcc
xorl %r12d, %r12d
cmpb $0x1, 0x15(%r14)
movl $0x0, %eax
adcq $0x6a, %rax
testb $0x1, (%rbx,%rax)
jne 0x3dfba
movq (%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x3e40e
movb 0x6b(%rbx), %al
testb %al, 0x6a(%rbx)
movzbl 0x69(%rbx), %eax
cmovnel %eax, %r12d
movb %r12b, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x3ed27
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x3ed10
movq %rax, %rdx
cmpq %rax, %rcx
je 0x3ed39
cmpl %esi, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x3ed96
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x41b32
movq (%rax), %r15
movq %r15, 0x10(%rsp)
movq %r15, %rax
shrq $0x3e, %rax
jne 0x3ed6b
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x40eea
jmp 0x3ed96
movl %r15d, %r12d
leaq (,%r12,8), %rsi
addq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x40eea
incl %r15d
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rax
shrq $0x3e, %rax
cmpl $0x2, %eax
je 0x3ed6b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0xb0(%rdi)
je 0x3ef78
movq %rbx, %rdi
callq 0x40f72
movq %r14, 0xb0(%rbx)
testq %r14, %r14
je 0x3ef93
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41200
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::tallyNs(int&, int&)
bool tallyNs(int& nsInSeed, int& nsInFtab) {
		const Ebwt& ebwt = *_ebwt;
		int ftabChars = ebwt._eh._ftabChars;
		// Count Ns in the seed region of the read and short-circuit if
		// the configuration of Ns guarantees that there will be no
		// valid alignments given the backtracking constraints.
		for(size_t i = 0; i < _3revOff; i++) {
			if((int)(*_qry)[_qlen-i-1] == 4) {
				nsInSeed++;
				if(nsInSeed == 1) {
					if(i < _unrevOff) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else if(nsInSeed == 2) {
					if(i < _1revOff) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else if(nsInSeed == 3) {
					if(i < _2revOff) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else {
					assert_gt(nsInSeed, 3);
					return false;     // Exceeded mm budget on Ns alone
				}
			}
		}
		// Calculate the number of Ns there are in the region that
		// would get jumped over if the ftab were used.
		for(size_t i = 0; i < (size_t)ftabChars && i < _qlen; i++) {
			if((int)(*_qry)[_qlen-i-1] == 4) nsInFtab++;
		}
		return true;
	}

// Assembly:
movq 0x20(%rdi), %rax
movslq 0x124(%rax), %rcx
cmpl $0x0, 0x3c(%rdi)
sete %al
je 0x3f22d
movq $-0x1, %r8
xorl %r9d, %r9d
movq (%rdi), %r10
movq 0x8(%r10), %r10
addq 0x8(%rdi), %r10
cmpb $0x4, (%r8,%r10)
jne 0x3f21c
movl (%rsi), %r10d
leal 0x1(%r10), %r11d
movl %r11d, (%rsi)
cmpl $0x2, %r10d
je 0x3f213
cmpl $0x1, %r10d
je 0x3f20d
testl %r10d, %r10d
jne 0x3f25f
movl 0x30(%rdi), %r10d
jmp 0x3f217
movl 0x34(%rdi), %r10d
jmp 0x3f217
movl 0x38(%rdi), %r10d
cmpq %r10, %r9
jb 0x3f25f
incq %r9
movl 0x3c(%rdi), %eax
decq %r8
cmpq %rax, %r9
setae %al
jb 0x3f1da
testl %ecx, %ecx
je 0x3f25f
movq $-0x1, %rsi
xorl %r8d, %r8d
movq 0x8(%rdi), %r9
cmpq %r9, %r8
jae 0x3f25f
movq (%rdi), %r10
addq 0x8(%r10), %r9
cmpb $0x4, (%rsi,%r9)
jne 0x3f254
incl (%rdx)
incq %r8
decq %rsi
cmpq %r8, %rcx
jne 0x3f23b
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %eax
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq (%rsi), %rsi
movq 0x38(%rsi), %rsi
movq %rsi, 0x150(%rdi)
xorl %r14d, %r14d
movb %r14b, 0x130(%rdi)
movl 0x30(%rdi), %r10d
movl 0x34(%rdi), %r11d
movl 0x38(%rdi), %ebp
movl 0x3c(%rdi), %esi
movups 0x48(%rdi), %xmm0
movl %r9d, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movl %r8d, 0x20(%rsp)
movl %r8d, 0x18(%rsp)
movl %ecx, 0x10(%rsp)
movl %edx, 0x8(%rsp)
movl %esi, (%rsp)
xorl %esi, %esi
movl %eax, %edx
movl %r10d, %ecx
movl %r11d, %r8d
movl %ebp, %r9d
callq 0x3f442
movl 0x100(%rbx), %ecx
addl %ecx, 0x104(%rbx)
movl $0x0, 0x100(%rbx)
movb %r14b, 0x10c(%rbx)
movb %r14b, 0x130(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, 0xb0(%rdi)
je 0x40fb2
movq 0xb0(%rdi), %rcx
cmpq $0x0, 0x18(%rcx)
je 0x40fb2
xorl %eax, %eax
movq 0x8(%rcx), %rcx
movb 0x2(%rcx,%rax,4), %dl
movq (%rdi), %rsi
movzwl (%rcx,%rax,4), %ecx
movq 0x8(%rsi), %rsi
movb %dl, (%rsi,%rcx)
incq %rax
movq 0xb0(%rdi), %rcx
cmpq 0x18(%rcx), %rax
jb 0x40f8c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::promotePartialMutations(int)
void promotePartialMutations(int stackDepth) {
		if(_muts == NULL) {
			// No mutations to undo
			return;
		}
		size_t numMuts = _muts->size();
		assert_leq(numMuts, _qlen);
		for(size_t i = 0; i < numMuts; i++) {
			// Entries in _mms[] are in terms of offset into
			// _qry - not in terms of offset from 3' or 5' end
			assert_lt(stackDepth + i, _qlen);
			// All partial-alignment mutations should fall
			// within bounds
			assert_lt((*_muts)[i].pos, _qlen);
			// All partial-alignment mutations should fall
			// within unrevisitable region
			assert_lt(_qlen - (*_muts)[i].pos - 1, _unrevOff);
#ifndef NDEBUG
			// Shouldn't be any overlap between mismatched positions
			// and positions that mismatched in the partial alignment.
			for(size_t j = 0; j < stackDepth + i; j++) {
				assert_neq(_mms[j], (uint32_t)(*_muts)[i].pos);
			}
#endif
			if(_mms.size() <= stackDepth + i) {
				assert_eq(_mms.size(), stackDepth + i);
				_mms.push_back((*_muts)[i].pos);
			} else {
				_mms[stackDepth + i] = (*_muts)[i].pos;
			}
			if(_refcs.size() <= stackDepth + i) {
				assert_eq(_refcs.size(), stackDepth + i);
				_refcs.push_back("ACGT"[(*_muts)[i].newBase]);
			} else {
				_refcs[stackDepth + i] = "ACGT"[(*_muts)[i].newBase];
			}
		}
	}

// Assembly:
movq 0xb0(%rdi), %rax
testq %rax, %rax
je 0x410ae
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rax), %rbp
testq %rbp, %rbp
je 0x410a0
movq %rdi, %rbx
movslq %esi, %r12
leaq 0x58(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%rdi), %r15
xorl %r13d, %r13d
leaq 0x12479(%rip), %r14     # 0x53475
cmpq %r12, 0x70(%rbx)
jbe 0x4101c
movq 0x60(%rbx), %rax
movq 0xb0(%rbx), %rcx
movq 0x8(%rcx), %rcx
movzwl (%rcx,%r13), %ecx
movl %ecx, (%rax,%r12,4)
jmp 0x4103f
movq 0xb0(%rbx), %rax
movq 0x8(%rax), %rax
movzwl (%rax,%r13), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x22e84
cmpq %r12, 0x90(%rbx)
jbe 0x4106a
movq 0x80(%rbx), %rax
movq 0xb0(%rbx), %rcx
movq 0x8(%rcx), %rcx
movzbl 0x3(%rcx,%r13), %ecx
movb (%rcx,%r14), %cl
movb %cl, (%rax,%r12)
jmp 0x41090
movq 0xb0(%rbx), %rax
movq 0x8(%rax), %rax
movzbl 0x3(%rax,%r13), %eax
movb (%rax,%r14), %al
movb %al, 0xb(%rsp)
movq %r15, %rdi
leaq 0xb(%rsp), %rsi
callq 0x2b9ac
incq %r12
addq $0x4, %r13
decq %rbp
jne 0x40ffc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./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:
cmpq $0x0, 0xb0(%rdi)
je 0x41240
movq 0xb0(%rdi), %rcx
cmpq $0x0, 0x18(%rcx)
je 0x41240
xorl %eax, %eax
movq 0x8(%rcx), %rcx
movb 0x3(%rcx,%rax,4), %dl
movq (%rdi), %rsi
movzwl (%rcx,%rax,4), %ecx
movq 0x8(%rsi), %rsi
movb %dl, (%rsi,%rcx)
incq %rax
movq 0xb0(%rdi), %rcx
cmpq 0x18(%rcx), %rax
jb 0x4121a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x188(%rsi)
leaq 0x30(%rsi), %rdi
callq 0x4f886
movq %rbx, %rdi
callq 0x4ee24
leaq 0x60(%rbx), %rsi
leaq 0x150(%rbx), %rdx
movl 0x74(%r14), %ecx
movq %rbx, %rdi
callq 0x4c102
movl %eax, 0x18c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
imull $0x568fae7, %ecx, %eax  # imm = 0x568FAE7
addl $0x226afd23, %eax       # imm = 0x226AFD23
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0x4c13d
movq 0x8(%rdi), %rdi
xorl %r9d, %r9d
xorl %r10d, %r10d
movsbl (%rdi,%r10), %r11d
movl %r9d, %ecx
andb $0x1e, %cl
shll %cl, %r11d
xorl %r11d, %eax
incq %r10
addl $0x2, %r9d
cmpq %r10, %r8
jne 0x4c120
testq %r8, %r8
je 0x4c166
movq 0x8(%rsi), %rsi
xorl %edi, %edi
xorl %r9d, %r9d
movsbl (%rsi,%r9), %r10d
movl %edi, %ecx
andb $0x18, %cl
shll %cl, %r10d
xorl %r10d, %eax
incq %r9
addl $0x8, %edi
cmpq %r9, %r8
jne 0x4c14b
movq 0x20(%rdx), %rsi
testq %rsi, %rsi
je 0x4c193
movq 0x8(%rdx), %rdx
xorl %edi, %edi
xorl %r8d, %r8d
movsbl (%rdx,%r8), %r9d
movl %edi, %ecx
andb $0x18, %cl
shll %cl, %r9d
xorl %r9d, %eax
incq %r8
addl $0x8, %edi
cmpq %r8, %rsi
jne 0x4c178
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, 0x188(%rsi)
leaq 0x30(%rsi), %rdi
callq 0x4f886
movq %r12, %rdi
callq 0x4ee24
movq %r12, %rdi
movl $0x1, %esi
callq 0x4ee5c
leaq 0x60(%r12), %rsi
movl $0x150, %r15d           # imm = 0x150
leaq (%r12,%r15), %rdx
movl 0x74(%r14), %ecx
movq %r12, %rdi
callq 0x4c102
movl %eax, 0x18c(%r12)
movl $0x2, 0x188(%rbx)
leaq 0x30(%rbx), %rdi
movq %rbx, %rsi
callq 0x4f886
movq %rbx, %rdi
callq 0x4ee24
movq %rbx, %rdi
movl $0x2, %esi
callq 0x4ee5c
leaq 0x60(%rbx), %rsi
addq %rbx, %r15
movl 0x74(%r14), %ecx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4c102
movl %eax, 0x18c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/pat.cpp
// Function: PatternSourcePerThread::nextReadPair()
pair<bool, bool> PatternSourcePerThread::nextReadPair() {
	// Prepare batch
	if(buf_.exhausted()) {
		pair<bool, int> res = nextBatch();
		if(res.first && res.second == 0) {
			return make_pair(false, true);
		}
		last_batch_ = res.first;
		last_batch_size_ = res.second;
		assert_eq(0, buf_.cur_buf_);
	} else {
		buf_.next(); // advance cursor
		assert_gt(buf_.cur_buf_, 0);
	}
	bool this_is_last = buf_.cur_buf_ == last_batch_size_-1;
	if(buf_.rdid() < skip_) {
		return make_pair(false, this_is_last ? last_batch_ : false);
	}
	// Parse read/pair
	assert(!buf_.read_a().readOrigBuf.empty());
	assert(buf_.read_a().empty());
	if(!parse(buf_.read_a(), buf_.read_b())) {
		return make_pair(false, false);
	}
	// Finalize read/pair
	if(paired()) {
		finalizePair(buf_.read_a(), buf_.read_b());
	} else {
		finalize(buf_.read_a());
	}
	return make_pair(true, this_is_last ? last_batch_ : false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rcx
movq 0x50(%rdi), %rax
decq %rcx
cmpq %rcx, %rax
jae 0x4c265
incq %rax
movq %rax, 0x50(%rbx)
jmp 0x4c2bb
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x24ee6
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
movq %rax, %rcx
movq $0x0, 0x50(%rbx)
movq 0x58(%rbx), %rax
xorl %edx, %edx
divq 0x8(%rbx)
movq %rax, 0x78(%rbx)
movq %rcx, %rax
shrq $0x20, %rax
sete %dl
movw $0x100, %ax             # imm = 0x100
testb %cl, %dl
jne 0x4c352
movl %ecx, %eax
andb $0x1, %al
movb %al, 0x60(%rbx)
sarq $0x20, %rcx
movq %rcx, 0x68(%rbx)
movq 0x50(%rbx), %r14
movq 0x68(%rbx), %r15
decq %r15
movq 0x58(%rbx), %rax
addq %r14, %rax
movl 0x70(%rbx), %ecx
cmpq %rcx, %rax
jae 0x4c2e2
movl 0x60(%rbx), %ecx
shll $0x8, %ecx
xorl %eax, %eax
cmpq %r15, %r14
jmp 0x4c34f
imulq $0x268, %r14, %rdx      # imm = 0x268
movq 0x18(%rbx), %rsi
addq %rdx, %rsi
addq 0x38(%rbx), %rdx
movq (%rbx), %rdi
movq 0x58(%rbx), %rcx
addq %r14, %rcx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x4c333
movq 0x38(%rbx), %rax
imulq $0x268, 0x50(%rbx), %rdx # imm = 0x268
movq 0x18(%rbx), %rsi
addq %rdx, %rsi
cmpb $0x1, 0x190(%rax,%rdx)
jne 0x4c337
addq 0x38(%rbx), %rdx
movq %rbx, %rdi
callq 0x4c194
jmp 0x4c33f
xorl %eax, %eax
jmp 0x4c352
movq %rbx, %rdi
callq 0x4c0b8
movl 0x60(%rbx), %ecx
shll $0x8, %ecx
incl %ecx
cmpq %r15, %r14
movl $0x1, %eax
cmovel %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %ebp
leaq 0x8(%rdi), %r15
movl %ebp, %r12d
cmpq %r12, 0x28(%r14)
jbe 0x4c3c6
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq *0x10(%rax)
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x4c39e
testb $0x1, %al
je 0x4c376
testq %rcx, %rcx
jne 0x4c3cd
movq %r15, %rdi
callq 0x4bff0
incl %r12d
cmpl 0xc(%r14), %r12d
jbe 0x4c3b8
incl 0xc(%r14)
movl 0xc(%r14), %ebp
movq %r15, %rdi
callq 0x4c02c
jmp 0x4c36d
movl $0x1, %eax
jmp 0x4c3da
movabsq $-0xffffff01, %rcx      # imm = 0xFFFFFFFF000000FF
andq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x1b23d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rax, 0x50(%rsi)
movzbl %dl, %ebp
xorl %r13d, %r13d
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r13, %rcx
callq *0x30(%rax)
movq %rax, %r14
movq %rax, %r13
sarq $0x20, %r13
xorb $0x1, %al
movq %r14, %r15
shrq $0x20, %r15
sete %cl
testb %al, %cl
jne 0x4c613
testb $0x1, %r14b
je 0x4c678
movq 0x80(%rbx), %rax
cmpq 0x38(%rbx), %rax
jae 0x4c678
movq %rbx, %rdi
callq 0x4c6a4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
incq 0x80(%rbx)
testq %r15, %r15
je 0x4c613
cmpq (%r12), %r13
jb 0x4c613
xorl %ecx, %ecx
jmp 0x4c67e
movl %r14d, %ecx
andl $0x1, %ecx
addq %r13, 0x8(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r14
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
je 0x4ca77
leaq 0x10(%r15), %rbx
movq %rbx, %rdi
callq 0x4bff0
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c5f4
movq %rax, %r14
movq %rbx, %rdi
callq 0x4c02c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c5f4
jmp 0x4caa5
movq %rax, %r14
movq %rbx, %rdi
callq 0x4c02c
movq %r14, %rdi
callq 0x9930
movq %rax, %rdi
callq 0x1b23d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rax, 0x50(%rsi)
cmpq $0x0, (%rsi)
je 0x4cf21
movq %rsi, %r14
xorb $0x1, %dl
movzbl %dl, %eax
shll $0x5, %eax
orq $0x8, %rax
movq %rax, (%rsp)
movl $0x120, %ebp            # imm = 0x120
xorl %r13d, %r13d
movq 0x20(%rbx), %rax
cmpq 0x68(%rbx), %rax
jae 0x4cf24
movq (%rsp), %rcx
movq 0x8(%r14,%rcx), %r15
addq %rbp, %r15
movq 0x58(%rbx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %r12
movq %r12, %rdi
callq 0x91b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4f95a
incq 0x20(%rbx)
incq %r13
addq $0x268, %rbp            # imm = 0x268
cmpq (%r14), %r13
jb 0x4ced4
jmp 0x4cf24
xorl %r13d, %r13d
addq %r13, 0x8(%rbx)
movq 0x20(%rbx), %rcx
xorl %eax, %eax
cmpq 0x68(%rbx), %rcx
sete %al
shlq $0x20, %r13
orq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
je 0x4cf93
leaq 0x10(%r15), %rbx
movq %rbx, %rdi
callq 0x4bff0
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ce9c
movq %rax, %r14
movq %rbx, %rdi
callq 0x4c02c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edx
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4ce9c
jmp 0x4cfc1
movq %rax, %r14
movq %rbx, %rdi
callq 0x4c02c
movq %r14, %rdi
callq 0x9930
movq %rax, %rdi
callq 0x1b23d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x1dcfd(%rip), %rdi     # 0x6aff0
leaq 0xad5c(%rip), %rsi      # 0x58056
callq 0x9490
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1fe01
movq %rax, %rdi
callq 0x91f0
leaq 0xad76(%rip), %rsi      # 0x5808f
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xadaa(%rip), %rsi      # 0x580da
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1dbe1(%rip), %rsi     # 0x6af38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./qual.h
// Function: charToPhred33(char, bool, bool)
inline static char charToPhred33(char c, bool solQuals, bool phred64Quals) {
	if(c == ' ') {
		cerr << "Saw a space but expected an ASCII-encoded quality value." << endl
		     << "Are quality values formatted as integers?  If so, try --integer-quals." << endl;
		throw 1;
	}
	if (solQuals) {
		// Convert solexa-scaled chars to phred
		// http://maq.sourceforge.net/fastq.shtml
		char cc = solexaToPhred((int)c - 64) + 33;
		if (cc < 33) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 64-based Solexa qual (converts to " << (int)cc << ")." << endl
			     << "Try not specifying --solexa-quals." << endl;
			throw 1;
		}
		c = cc;
	}
	else if(phred64Quals) {
		if (c < 64) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 64-based Phred qual." << endl
			     << "Try not specifying --solexa1.3-quals/--phred64-quals." << endl;
			throw 1;
		}
		// Convert to 33-based phred
		c -= (64-33);
	}
	else {
		// Keep the phred quality
		if (c < 33) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 33-based Phred qual." << endl;
			throw 1;
		}
	}
	return c;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpb $0x20, %bl
je 0x4d3b7
testb %sil, %sil
je 0x4d379
cmpb $0x36, %bl
jge 0x4d38b
xorl %eax, %eax
jmp 0x4d39a
testb %dl, %dl
je 0x4d3a5
cmpb $0x3f, %bl
jle 0x4d437
addl $-0x1f, %ebx
jmp 0x4d3ae
movl %ebx, %eax
addl $-0x36, %eax
leaq 0x20869(%rip), %rcx     # 0x6dc00
movb (%rcx,%rax), %al
leal 0x21(%rax), %ecx
cmpb $0x5f, %al
jae 0x4d3de
movl %ecx, %ebx
jmp 0x4d3ae
cmpb $0x20, %bl
jle 0x4d474
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x1dc32(%rip), %rdi     # 0x6aff0
leaq 0xaeb2(%rip), %rsi      # 0x58277
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xaed7(%rip), %rsi      # 0x582b0
jmp 0x4d498
movsbl %cl, %ebp
movq 0x1dc08(%rip), %rdi     # 0x6aff0
leaq 0xaf08(%rip), %rsi      # 0x582f7
callq 0x9490
movq %rax, %rdi
movl %ebx, %esi
callq 0x9910
leaq 0xaf07(%rip), %rsi      # 0x5830c
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
movl %ebp, %esi
callq 0x9910
leaq 0xa16f(%rip), %rsi      # 0x5758d
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xaf08(%rip), %rsi      # 0x5833d
jmp 0x4d498
movq 0x1dbb2(%rip), %rdi     # 0x6aff0
leaq 0xaeb2(%rip), %rsi      # 0x582f7
callq 0x9490
movq %rax, %rdi
movl %ebx, %esi
callq 0x9910
leaq 0xaf05(%rip), %rsi      # 0x58360
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
leaq 0xaf11(%rip), %rsi      # 0x58383
jmp 0x4d498
movq 0x1db75(%rip), %rdi     # 0x6aff0
leaq 0xae75(%rip), %rsi      # 0x582f7
callq 0x9490
movq %rax, %rdi
movl %ebx, %esi
callq 0x9910
leaq 0xaf21(%rip), %rsi      # 0x583b9
movq %rax, %rdi
callq 0x9490
movq %rax, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x1da79(%rip), %rsi     # 0x6af38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0