LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./hit.h
// Function: NBestFirstStratHitSinkPerThread::reportHit(Hit const&, int)
virtual bool reportHit(const Hit& h, int stratum) {
		HitSinkPerThread::reportHit(h, stratum);
		// This hit is within th best possible remaining stratum,
		// so it should definitely count
		hitsForThisRead_++;
		// It doesn't exceed the limit, so buffer it
		if(stratum < bestStratum_) {
			bestStratum_ = stratum;
		}
		if(hitsForThisRead_ > _max) {
			return true; // done - report nothing
		}
		//if(hitsForThisRead_ <= _n) {
			bufferHit(h, stratum);
		//}
		if(hitsForThisRead_ == _n &&
		   (_max == 0xffffffff || _max < _n))
		{
			return true; // already reported N good hits; stop!
		}
		return false; // not at N yet; keep going
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
incq 0x18(%rdi)
movl 0x60(%rdi), %eax
movl 0x78(%rdi), %ecx
incl %eax
movl %eax, 0x60(%rdi)
cmpl %edx, %ecx
jle 0x1f86a
movl %edx, 0x78(%r14)
movb $0x1, %bl
cmpl 0x64(%r14), %eax
ja 0x1f89a
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movl 0x60(%r14), %eax
cmpl 0x68(%r14), %eax
jne 0x1f898
movl 0x64(%r14), %ecx
cmpl $-0x1, %ecx
sete %dl
cmpl %eax, %ecx
setb %al
orb %dl, %al
jne 0x1f89a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::exhausted()
void exhausted() {
		if(patid != lastSkippedRead_) {
			if(!exhaustCrash_ && !quiet) std::cerr << "Warning: ";
			if(!quiet) {
				std::cerr << "Exhausted best-first chunk memory for read "
				          << (*readName_) << " (patid " << patid
				          << "); skipping read" << std::endl;
			}
			if(exhaustCrash_) {
				if(!quiet) {
					std::cerr << "Please try specifying a larger --chunkmbs <int> (default is 32)" << std::endl;
				}
				throw 1;
			}
		}
		lastSkippedRead_ = patid;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl 0x3c(%rdi), %eax
je 0x1f99a
movb 0x45756(%rip), %al      # 0x65070
cmpb $0x0, 0x38(%rbx)
jne 0x1f93d
testb $0x1, %al
jne 0x1f93d
movq 0x426c5(%rip), %rdi     # 0x61ff0
leaq 0x2af7a(%rip), %rsi     # 0x4a8ac
callq 0x94e0
movb 0x45733(%rip), %al      # 0x65070
testb $0x1, %al
jne 0x1f991
movq 0x426a8(%rip), %rdi     # 0x61ff0
leaq 0x2af67(%rip), %rsi     # 0x4a8b6
callq 0x94e0
movq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x1970d
leaq 0x2af7b(%rip), %rsi     # 0x4a8e2
movq %rax, %rdi
callq 0x94e0
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x2af6a(%rip), %rsi     # 0x4a8eb
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
cmpb $0x0, 0x38(%rbx)
jne 0x1f99f
movl 0x4(%rbx), %eax
movl %eax, 0x3c(%rbx)
popq %rbx
retq
cmpb $0x0, 0x456ca(%rip)     # 0x65070
jne 0x1f9c3
movq 0x42641(%rip), %rdi     # 0x61ff0
leaq 0x2af46(%rip), %rsi     # 0x4a8fc
callq 0x94e0
movq %rax, %rdi
callq 0x9210
pushq $0x4
popq %rdi
callq 0x9220
movl $0x1, (%rax)
movq 0x42580(%rip), %rsi     # 0x61f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x9910
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: AlignerFactory::create(unsigned int) const
virtual EList<Aligner*>* create(uint32_t n) const {
		EList<Aligner*>* v = new EList<Aligner*>;
		for(uint32_t i = 0; i < n; i++) {
			v->push_back(create());
			assert(v->back() != NULL);
		}
		return v;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x9500
movq %rax, %r15
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, (%r15)
andq $0x0, 0x8(%r15)
movq $0x80, 0x10(%r15)
andq $0x0, 0x18(%r15)
movq %rsp, %r12
subl $0x1, %ebx
jb 0x21a83
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x29a04
jmp 0x21a64
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: AlignerFactory::destroy(EList<Aligner*, 128>*) const
virtual void destroy(EList<Aligner*>* als) const {
		assert(als != NULL);
		// Free all of the Aligners
		for(size_t i = 0; i < als->size(); i++) {
			if((*als)[i] != NULL) {
				delete (*als)[i];
				(*als)[i] = NULL;
			}
		}
		// Free the vector
		delete als;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r14d, %r14d
cmpq 0x18(%rbx), %r14
jae 0x21ad3
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x21ace
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
jmp 0x21aac
movq %rbx, %rdi
callq 0x29b1a
pushq $0x20
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9510
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::CostAwareRangeSourceDriver(bool, EList<RangeSourceDriver<EbwtRangeSource>*, 128> const*, bool, bool, bool)
CostAwareRangeSourceDriver(
			bool strandFix,
			const TRangeSrcDrPtrVec* rss,
			bool verbose,
			bool quiet,
			bool mixesReads) :
		RangeSourceDriver<TRangeSource>(false),
		rss_(), active_(), strandFix_(strandFix),
		lastRange_(NULL), delayedRange_(NULL), patsrc_(NULL),
		verbose_(verbose), quiet_(quiet), mixesReads_(mixesReads)
	{
		if(rss != NULL) {
			rss_ = (*rss);
		}
		paired_ = false;
		this->foundRange = false;
		this->done = false;
		if(rss_.empty()) {
			return;
		}
		calcPaired();
		active_ = rss_;
		this->minCost = 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andw $0x0, 0xc(%rdi)
andl $0x0, 0x8(%rdi)
leaq 0x3f394(%rip), %rax     # 0x61190
movq %rax, (%rdi)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movl $0x80, %edi
movq %rdi, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
movq %rax, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
movq %rdi, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
movb %sil, 0x51(%rbx)
movabsq $0x3c6ef35f0019660d, %rax # imm = 0x3C6EF35F0019660D
movq %rax, 0x58(%rbx)
movb $0x0, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
andq $0x0, 0x80(%rbx)
movb %cl, 0x88(%rbx)
movb %r8b, 0x89(%rbx)
movb %r9b, 0x8a(%rbx)
testq %rdx, %rdx
je 0x21ead
leaq 0x10(%rbx), %r14
leaq 0x30(%rbx), %r15
movq %r14, %rdi
movq %rdx, %rsi
callq 0x27766
andw $0x0, 0x8(%rbx)
cmpq $0x0, 0x28(%rbx)
movb $0x0, 0x50(%rbx)
je 0x21eb6
movq %rbx, %rdi
callq 0x27d36
movq %r15, %rdi
movq %r14, %rsi
callq 0x27766
andw $0x0, 0xa(%rbx)
jmp 0x21eb6
movb $0x0, 0x50(%rbx)
andw $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x271de
movq %r14, %rdi
callq 0x271de
movq %rbx, %rdi
callq 0x9950
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: UnpairedAlignerV2<EbwtRangeSource>::UnpairedAlignerV2(EbwtSearchParams*, RangeSourceDriver<EbwtRangeSource>*, RangeChaser*, HitSink&, HitSinkPerThreadFactory const&, HitSinkPerThread*, EList<SString<char>, 128>&, BitPairReference*, bool, bool, bool, int, ChunkPool*, int*, AlignerMetrics*)
UnpairedAlignerV2(
		EbwtSearchParams* params,
		TDriver* driver,
		RangeChaser* rchase,
		HitSink& sink,
		const HitSinkPerThreadFactory& sinkPtFactory,
		HitSinkPerThread* sinkPt,
		EList<BTRefString >& os, // TODO: remove this, not used
		BitPairReference *refs,
		bool rangeMode,
		bool verbose,
		bool quiet,
		int maxBts,
		ChunkPool *pool,
		int *btCnt = NULL,
		AlignerMetrics *metrics = NULL) :
		Aligner(true, rangeMode),
		doneFirst_(true),
		firstIsFw_(true),
		chase_(false),
		sinkPtFactory_(sinkPtFactory),
		sinkPt_(sinkPt),
		refs_(refs),
		params_(params),
		rchase_(rchase),
		driver_(driver),
		verbose_(verbose),
		quiet_(quiet),
		maxBts_(maxBts),
		pool_(pool),
		btCnt_(btCnt),
		metrics_(metrics)
	{
		assert(pool_   != NULL);
		assert(sinkPt_ != NULL);
		assert(params_ != NULL);
		assert(driver_ != NULL);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x70(%rsp), %rax
movups 0x60(%rsp), %xmm0
movl 0x58(%rsp), %r8d
movb 0x50(%rsp), %r10b
movb 0x48(%rsp), %r11b
movq 0x28(%rsp), %rbx
movb $0x1, 0x8(%rdi)
andq $0x0, 0x28(%rdi)
movq 0x38(%rsp), %r14
movb 0x40(%rsp), %bpl
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movb %bpl, 0x34(%rdi)
movabsq $0x3c6ef35f0019660d, %r15 # imm = 0x3C6EF35F0019660D
movq %r15, 0x38(%rdi)
xorl %ebp, %ebp
movb %bpl, 0x48(%rdi)
leaq 0x3f243(%rip), %r15     # 0x61208
movq %r15, (%rdi)
movq %r14, 0x50(%rdi)
movw $0x101, 0x58(%rdi)      # imm = 0x101
movb %bpl, 0x5a(%rdi)
movq %r9, 0x60(%rdi)
movq %rbx, 0x68(%rdi)
movq %rsi, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
movq %rdx, 0x80(%rdi)
movb %r11b, 0x88(%rdi)
movb %r10b, 0x89(%rdi)
movl %r8d, 0x8c(%rdi)
movups %xmm0, 0x90(%rdi)
movq %rax, 0xa0(%rdi)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::setQuery(Read&, Range*)
virtual void setQuery(Read& r, Range *seedRange) {
		const bool ebwtFw = ebwt_->fw();
		if(ebwtFw) {
			qry_  = fw_ ? &r.patFw : &r.patRc;
			qual_ = fw_ ? &r.qual  : &r.qualRev;
		} else {
			qry_  = fw_ ? &r.patFwRev : &r.patRcRev;
			qual_ = fw_ ? &r.qualRev  : &r.qual;
		}
		name_ = &r.name;
		if(seedRange != NULL) seedRange_ = *seedRange;
		else                  seedRange_.invalidate();
		qlen_ = qry_->length();
		skippingThisRead_ = false;
		// Apply edits from the partial alignment to the query pattern
		if(seedRange_.valid()) {
			qryBuf_ = *qry_;
			const size_t srSz = seedRange_.mms.size();
			assert_gt(srSz, 0);
			assert_eq(srSz, seedRange_.refcs.size());
			for(size_t i = 0; i < srSz; i++) {
				assert_lt(seedRange_.mms[i], qlen_);
				char rc = (char)seedRange_.refcs[i];
				assert(rc == 'A' || rc == 'C' || rc == 'G' || rc == 'T');
				ASSERT_ONLY(char oc = (char)qryBuf_[qlen_ - seedRange_.mms[i] - 1]);
				assert_neq(rc, oc);
				qryBuf_[qlen_ - seedRange_.mms[i] - 1] = asc2dna[(int)rc];
				assert_neq(rc, (*qry_)[qlen_ - seedRange_.mms[i] - 1]);
			}
			qry_ = &qryBuf_;
		}
		// Make sure every qual is a valid qual ASCII character (>= 33)
		for(size_t i = 0; i < qual_->length(); i++) {
			assert_geq((*qual_)[i], 33);
		}
		assert_geq(qual_->length(), qlen_);
		this->done = false;
		this->foundRange = false;
		rand_.init(r.seed);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0x70(%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
pushq $0x30
popq %rsi
cmovneq %rax, %rsi
movl $0x90, %edi
movl $0xc0, %eax
cmovneq %rdi, %rax
movq 0x68(%rbx), %rdi
movb 0x10(%rdi), %dil
testb %dil, %dil
cmovneq %rsi, %rax
xorb %dil, %cl
leaq 0x60(%r14), %rsi
leaq 0xf0(%r14), %rdi
testb %cl, %cl
cmovneq %rdi, %rsi
addq %r14, %rax
movq %rax, 0x18(%rbx)
movq %rsi, 0x58(%rbx)
leaq 0x150(%r14), %rcx
movq %rcx, 0x60(%rbx)
testq %rdx, %rdx
je 0x221c2
leaq 0x118(%rbx), %rdi
movq %rdx, %rsi
callq 0x22e2c
cmpl $-0x1, 0x118(%rbx)
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movb $0x0, 0x178(%rbx)
je 0x221d8
leaq 0x20(%rbx), %r15
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rdx
movq 0x20(%rbx), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x148(%rbx), %rax
xorl %ecx, %ecx
leaq 0x423d8(%rip), %rdx     # 0x64560
cmpq %rcx, %rax
je 0x221bc
movq 0x158(%rbx), %rsi
movsbq (%rsi,%rcx), %rsi
movb (%rdx,%rsi), %sil
movq 0x28(%rbx), %rdi
movq 0x138(%rbx), %r8
movl (%r8,%rcx,4), %r8d
notq %r8
addq 0x50(%rbx), %rdi
movb %sil, (%r8,%rdi)
incq %rcx
jmp 0x22188
movq %r15, 0x18(%rbx)
jmp 0x221d8
orl $-0x1, 0x118(%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x50(%rbx)
movb $0x0, 0x178(%rbx)
andw $0x0, 0x8(%rbx)
movl 0x18c(%r14), %eax
movl %eax, 0xa8(%rbx)
movb $0x1, 0xb0(%rbx)
movl $0x1e, 0xac(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::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 < offRev3_; i++) {
			if((int)(*qry_)[qlen_-i-1] == 4) {
				nsInSeed++;
				if(nsInSeed == 1) {
					if(i < offRev0_) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else if(nsInSeed == 2) {
					if(i < offRev1_) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else if(nsInSeed == 3) {
					if(i < offRev2_) {
						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 0x68(%rdi), %rax
movslq 0x124(%rax), %rax
pushq $-0x1
popq %r9
xorl %ecx, %ecx
movl 0x80(%rdi), %r8d
cmpq %r8, %rcx
jae 0x2307e
movq 0x18(%rdi), %r10
movq 0x8(%r10), %r10
addq 0x50(%rdi), %r10
cmpb $0x4, (%r9,%r10)
jne 0x23076
movl (%rsi), %r10d
leal 0x1(%r10), %r11d
movl %r11d, (%rsi)
cmpl $0x2, %r10d
je 0x2306d
cmpl $0x1, %r10d
je 0x23067
testl %r10d, %r10d
jne 0x230ab
movl 0x74(%rdi), %r10d
jmp 0x23071
movl 0x78(%rdi), %r10d
jmp 0x23071
movl 0x7c(%rdi), %r10d
cmpq %r10, %rcx
jb 0x230ab
incq %rcx
decq %r9
jmp 0x23027
pushq $-0x1
popq %rsi
xorl %r9d, %r9d
cmpq %r9, %rax
je 0x230ab
movq 0x50(%rdi), %r10
cmpq %r10, %r9
jae 0x230ab
movq 0x18(%rdi), %r11
addq 0x8(%r11), %r10
cmpb $0x4, (%rsi,%r10)
jne 0x230a3
incl (%rdx)
incq %r9
decq %rsi
jmp 0x23084
cmpq %r8, %rcx
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::calcFtabOff()
uint32_t calcFtabOff() {
		const Ebwt& ebwt = *ebwt_;
		int ftabChars = ebwt._eh._ftabChars;
		uint32_t ftabOff = (*qry_)[qlen_ - ftabChars];
		assert_lt(ftabOff, 4);
		assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		for(int i = ftabChars - 1; i > 0; i--) {
			ftabOff <<= 2;
			assert_lt((uint32_t)(*qry_)[qlen_-i], 4);
			ftabOff |= (uint32_t)(*qry_)[qlen_-i];
			assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		}
		assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		return ftabOff;
	}

// Assembly:
movq 0x68(%rdi), %rax
movl 0x124(%rax), %ecx
movq 0x18(%rdi), %rax
movq 0x50(%rdi), %rdx
movslq %ecx, %rsi
movq %rdx, %rdi
subq %rsi, %rdi
movq 0x8(%rax), %rsi
movsbl (%rsi,%rdi), %eax
subq %rcx, %rdx
addq %rsi, %rdx
incq %rdx
cmpl $0x1, %ecx
jle 0x230f2
shll $0x2, %eax
movsbl (%rdx), %esi
orl %esi, %eax
decl %ecx
incq %rdx
jmp 0x230de
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::alloc()
T* alloc() {
		if(!lazyInit()) return NULL;
		if(cur_ + 1 >= lim_) {
			if(!allocNextPool()) return NULL;
		}
		cur_ ++;
		return &pools_[curPool_][cur_ - 1];
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x234a6
testb %al, %al
je 0x23203
movl 0x5c(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl 0x58(%rbx), %ecx
jb 0x231ea
movq %rbx, %rdi
callq 0x2357a
testb %al, %al
je 0x23203
movl 0x5c(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x5c(%rbx)
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
movl %eax, %eax
imulq $0x88, %rax, %rax
addq (%rdx,%rcx,8), %rax
jmp 0x23205
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::lazyInit()
bool lazyInit() {
		if(cur_ == 0 && pools_.empty()) {
			T *pool;
			try {
				if((pool = (T*)pool_->alloc()) == NULL) {
					throw std::bad_alloc();
				}
			} catch(std::bad_alloc& e) {
				ThreadSafe _ts(&gLock);
				pool_->exhausted();
				return false;
			}
			pools_.push_back(pool);
			assert_eq(1, pools_.size());
		}
		assert(!pools_.empty());
		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb $0x1, %bpl
cmpl $0x0, 0x5c(%rdi)
jne 0x234e4
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0x234e4
movq (%rbx), %rdi
callq 0x23652
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x234ef
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23746
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x9220
movq 0x3ea9a(%rip), %rcx     # 0x61f98
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3eaac(%rip), %rsi     # 0x61fb8
movq 0x3ea6d(%rip), %rdx     # 0x61f80
movq %rax, %rdi
callq 0x9910
movq %rax, %r14
cmpl $0x1, %edx
jne 0x23569
movq %r14, %rdi
callq 0x91a0
leaq 0x41cd6(%rip), %rdi     # 0x65208
movq %rdi, (%rsp)
callq 0x40dda
movq (%rbx), %rdi
callq 0x1f904
movq %rsp, %rdi
callq 0x1a9ee
callq 0x9860
xorl %ebp, %ebp
jmp 0x234e4
movq %rax, %r14
movq %rsp, %rdi
callq 0x1a9ee
jmp 0x23564
movq %rax, %r14
callq 0x9860
movq %r14, %rdi
callq 0x9950
movq %rax, %rdi
callq 0x15e2d
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::allocNextPool()
bool allocNextPool() {
		assert_eq(curPool_+1, pools_.size());
		T *pool;
		try {
			if((pool = (T*)pool_->alloc()) == NULL) {
				throw std::bad_alloc();
			}
		} catch(std::bad_alloc& e) {
			ThreadSafe _ts(&gLock);
			pool_->exhausted();
			return false;
		}
		pools_.push_back(pool);
		lastCurInPool_.push_back(cur_);
		curPool_++;
		cur_ = 0;
		return true;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x23652
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x235c2
leaq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x23746
leaq 0x38(%rbx), %rdi
leaq 0x5c(%rbx), %rsi
callq 0x1bf46
incl 0x30(%rbx)
andl $0x0, 0x5c(%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x9220
movq 0x3e9c7(%rip), %rcx     # 0x61f98
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3e9d9(%rip), %rsi     # 0x61fb8
movq 0x3e99a(%rip), %rdx     # 0x61f80
movq %rax, %rdi
callq 0x9910
movq %rax, %r14
cmpl $0x1, %edx
jne 0x23641
movq %r14, %rdi
callq 0x91a0
leaq 0x41c03(%rip), %rdi     # 0x65208
movq %rdi, 0x8(%rsp)
callq 0x40dda
movq (%rbx), %rdi
callq 0x1f904
leaq 0x8(%rsp), %rdi
callq 0x1a9ee
callq 0x9860
xorl %eax, %eax
jmp 0x235ba
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1a9ee
jmp 0x2363c
movq %rax, %r14
callq 0x9860
movq %r14, %rdi
callq 0x9950
movq %rax, %rdi
callq 0x15e2d
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::alloc()
void* alloc() {
		assert_lt(cur_, lim_);
		uint32_t cur = cur_;
		while(bits_.test(cur)) {
			cur++;
			if(cur >= lim_) {
				cur = 0;
			}
			if(cur == cur_) {
				// Wrapped all the way around without finding a free
				// chunk
				return NULL;
			}
		}
		void * ptr = (void *)(&pool_[cur * chunkSz_]);
		assert(!bits_.test(cur));
		bits_.set(cur);
		assert(bits_.test(cur));
		if(verbose) {
			stringstream ss;
			ss << patid << ": Allocating chunk with offset: " << cur;
			glog.msg(ss.str());
		}
		cur_ = cur;
		return ptr;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %r14
movl 0x10(%rdi), %eax
movl 0x1c(%rdi), %ecx
movq 0x30(%rdi), %rdx
xorl %ebx, %ebx
movl %eax, %ebp
movl %ebp, %esi
shrl $0x5, %esi
movl (%rdx,%rsi,4), %esi
btl %ebp, %esi
jae 0x2368b
incl %ebp
cmpl %ecx, %ebp
cmovael %ebx, %ebp
cmpl %eax, %ebp
jne 0x2366e
jmp 0x23710
leaq 0x20(%r14), %rdi
movl 0x14(%r14), %ebx
imull %ebp, %ebx
addq 0x8(%r14), %rbx
movl %ebp, %esi
callq 0x23794
cmpb $0x1, (%r14)
jne 0x2370c
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0x38(%rsp), %rdi
movl 0x4(%r14), %esi
callq 0x9310
leaq 0x272b4(%rip), %rsi     # 0x4a97a
movq %rax, %rdi
callq 0x94e0
movl %ebp, %esi
movq %rax, %rdi
callq 0x9310
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97f0
leaq 0x41f43(%rip), %rdi     # 0x65631
leaq 0x8(%rsp), %rsi
callq 0x237b4
leaq 0x8(%rsp), %rdi
callq 0x9a68
leaq 0x28(%rsp), %rdi
callq 0x9390
movl %ebp, 0x10(%r14)
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9a68
jmp 0x23733
jmp 0x23730
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset2::set(unsigned int)
void set(TIndexOffU i) {
		// Fast path
		assert_lt(i, len_);
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 0);
		_words[i / WORD_SIZE] |= ((TIndexOffU)1 << (i & BITSET_MASK));
		_cnt++;
		if(i >= _size) {
			_size = i+1;
		}
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 1);
	}

// Assembly:
movl %esi, %ecx
pushq $0x1
popq %rax
shll %cl, %eax
movq 0x10(%rdi), %rdx
shrl $0x5, %esi
orl %eax, (%rdx,%rsi,4)
incl 0x4(%rdi)
cmpl %ecx, 0x8(%rdi)
ja 0x237b2
incl %ecx
movl %ecx, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: SideLocus::initFromTopBot(unsigned int, unsigned int, EbwtParams const&, unsigned char const*, SideLocus&, SideLocus&)
static void initFromTopBot(TIndexOffU top,
	                           TIndexOffU bot,
	                           const EbwtParams& ep,
	                           const uint8_t* ebwt,
	                           SideLocus& ltop,
	                           SideLocus& lbot)
	{
		const TIndexOffU sideBwtLen = ep._sideBwtLen;
		const uint32_t sideBwtSz  = ep._sideBwtSz;
		assert_gt(bot, top);
		ltop.initFromRow(top, ep, ebwt);
		TIndexOffU spread = bot - top;
		if(ltop._charOff + spread < sideBwtLen) {
			lbot._charOff = (uint32_t)(ltop._charOff + spread);
			lbot._sideNum = ltop._sideNum;
			lbot._sideByteOff = ltop._sideByteOff;
			lbot._fw = ep._isBt2Index ? true : ltop._fw;
			lbot._by = lbot._charOff >> 2;
			assert_lt(lbot._by, (int)sideBwtSz);
			if(!lbot._fw) lbot._by = sideBwtSz - lbot._by - 1;
			lbot._bp = lbot._charOff & 3;
			if(!lbot._fw) lbot._bp ^= 3;
		} else {
			lbot.initFromRow(bot, ep, ebwt);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r13d
movl 0x68(%rdx), %eax
movl %eax, 0xc(%rsp)
movl 0x6c(%rdx), %r12d
movq %r8, %rdi
movl %r13d, %esi
movq %rcx, 0x10(%rsp)
callq 0x15ee4
movl %ebp, %ecx
subl %r13d, %ecx
movzwl 0x8(%r15), %eax
addl %ecx, %eax
cmpl %r12d, %eax
jae 0x23994
movw %ax, 0x8(%rbx)
movl 0x4(%r15), %ecx
movl %ecx, 0x4(%rbx)
movl (%r15), %ecx
movl %ecx, (%rbx)
movzbl 0xa(%r15), %ecx
cmpb $0x0, 0x85(%r14)
pushq $0x1
popq %rdx
cmovel %ecx, %edx
movb %dl, 0xa(%rbx)
movl %eax, %ecx
shrl $0x2, %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
movl %ecx, %esi
notl %esi
addl 0xc(%rsp), %esi
andb $0x3, %al
testb $0x1, %dl
cmovnel %ecx, %esi
movw %si, 0xc(%rbx)
movb %al, 0xe(%rbx)
jne 0x23985
xorb $0x3, %al
movb %al, 0xe(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15ee4
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::allocC(unsigned int)
T* allocC(uint32_t num) {
		T* t = alloc(num);
		if(t != NULL) {
			memset(t, 0, sizeof(T) * num);
		}
		return t;
	}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x23a60
testq %rax, %rax
je 0x239d2
movl %ebx, %ecx
imulq $0x30, %rcx, %rdx
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x9270
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: EditList::add(Edit const&, AllocOnlyPool<Edit>&, unsigned long)
bool add(const Edit& e, AllocOnlyPool<Edit>& pool, size_t qlen) {
		assert_lt(sz_, qlen + 10);
		if(sz_ < numEdits) {
			assert(moreEdits_ == NULL);
			assert(yetMoreEdits_ == NULL);
			edits_[sz_++] = e;
		} else if(sz_ == numEdits) {
			assert(moreEdits_ == NULL);
			assert(yetMoreEdits_ == NULL);
			moreEdits_ = pool.alloc(numMoreEdits);
			if(moreEdits_ == NULL) {
				return false;
			}
			assert(moreEdits_ != NULL);
			moreEdits_[0] = e;
			sz_++;
		} else if(sz_ < (numEdits + numMoreEdits)) {
			assert(moreEdits_ != NULL);
			assert(yetMoreEdits_ == NULL);
			moreEdits_[sz_ - numEdits] = e;
			sz_++;
		} else if(sz_ == (numEdits + numMoreEdits)) {
			assert(moreEdits_ != NULL);
			assert(yetMoreEdits_ == NULL);
			yetMoreEdits_ = pool.alloc((uint32_t)qlen + 10 - numMoreEdits - numEdits);
			if(yetMoreEdits_ == NULL) {
				return false;
			}
			assert(yetMoreEdits_ != NULL);
			yetMoreEdits_[0] = e;
			sz_++;
		} else {
			assert(moreEdits_ != NULL);
			assert(yetMoreEdits_ != NULL);
			yetMoreEdits_[sz_ - numEdits - numMoreEdits] = e;
			sz_++;
		}
		return true;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpq $0x5, %rax
ja 0x239f7
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movl (%r14), %ecx
movl %ecx, 0x8(%rbx,%rax,4)
jmp 0x23a56
cmpq $0x6, %rax
jne 0x23a18
pushq $0x10
popq %rsi
movq %rdx, %rdi
callq 0x23d9a
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x23a44
movl (%r14), %ecx
movl %ecx, (%rax)
jmp 0x23a53
cmpq $0x15, %rax
ja 0x23a2b
movq 0x20(%rbx), %rcx
movl (%r14), %edx
movl %edx, -0x18(%rcx,%rax,4)
jmp 0x23a53
cmpq $0x16, %rax
jne 0x23a48
addl $-0xc, %ecx
movq %rdx, %rdi
movl %ecx, %esi
callq 0x23d9a
movq %rax, 0x28(%rbx)
jmp 0x23a0c
xorl %eax, %eax
jmp 0x23a58
movq 0x28(%rbx), %rcx
movl (%r14), %edx
movl %edx, -0x58(%rcx,%rax,4)
incq (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::alloc(unsigned int)
T* alloc(uint32_t num) {
		if(!lazyInit()) return NULL;
		if(cur_ + num >= lim_) {
			if(!allocNextPool()) return NULL;
			assert_eq(0, cur_);
		}
		assert_leq(num, lim_);
		cur_ += num;
		return &pools_[curPool_][cur_ - num];
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x23ab4
testb %al, %al
je 0x23aaa
movl 0x5c(%rbx), %eax
leal (%rax,%r14), %ecx
cmpl 0x58(%rbx), %ecx
jb 0x23a94
movq %rbx, %rdi
callq 0x23b88
testb %al, %al
je 0x23aaa
movl 0x5c(%rbx), %eax
addl %eax, %r14d
movl %r14d, %ecx
movl %ecx, 0x5c(%rbx)
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
movl %eax, %eax
imulq $0x30, %rax, %rax
addq (%rdx,%rcx,8), %rax
jmp 0x23aac
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: BranchQueue::push(Branch*)
void push(Branch *b) {
#ifndef NDEBUG
		bool bIsBetter = empty() || !CostCompare()(b, branchQ_.top());
#endif
		if(verbose_) {
			stringstream ss;
			ss << patid_ << ": Pushing " << b->id_ << ", " << b << ", " << b->cost_ << ", " << b->exhausted_ << ", " << b->curtailed_ << ", " << sz_ << "->" << (sz_+1);
			glog.msg(ss.str());
		}
		branchQ_.push(b);
#ifndef NDEBUG
		assert(bIsBetter  || branchQ_.top() != b || CostCompare::equal(branchQ_.top(), b));
		assert(!bIsBetter || branchQ_.top() == b || CostCompare::equal(branchQ_.top(), b));
#endif
		sz_++;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpb $0x1, 0x2c(%rdi)
jne 0x24200
movq %rsi, %r14
leaq 0x30(%rsp), %rdi
callq 0x9340
leaq 0x40(%rsp), %rdi
movl 0x28(%rbx), %esi
callq 0x9310
leaq 0x2688a(%rip), %rsi     # 0x4a99b
movq %rax, %rdi
callq 0x94e0
movl (%r14), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x23e26(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x93d0
leaq 0x23e0c(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzwl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x98b0
leaq 0x23df0(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzbl 0x83(%r14), %esi
movq %rax, %rdi
callq 0x9870
leaq 0x23dd1(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzbl 0x82(%r14), %esi
movq %rax, %rdi
callq 0x9870
leaq 0x23db2(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x267ee(%rip), %rsi     # 0x4a9a6
movq %rax, %rdi
callq 0x94e0
movl (%rbx), %esi
incl %esi
movq %rax, %rdi
callq 0x9310
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x97f0
leaq 0x4144f(%rip), %rdi     # 0x65631
leaq 0x10(%rsp), %rsi
callq 0x237b4
leaq 0x10(%rsp), %rdi
callq 0x9a68
leaq 0x30(%rsp), %rdi
callq 0x9390
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x24398
incl (%rbx)
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9a68
jmp 0x2422f
jmp 0x2422c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: BranchQueue::front()
void extend() {
		assert(!exhausted_);
		assert(!curtailed_);
		assert(ranges_ != NULL);
		assert(repOk());
		prepped_ = false;
		len_++;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq 0x8(%rdi), %rax
movq (%rax), %rbx
cmpb $0x1, 0x2c(%rdi)
jne 0x24366
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0x30(%rsp), %rdi
movl 0x28(%r14), %esi
callq 0x9310
leaq 0x26744(%rip), %rsi     # 0x4a9c3
movq %rax, %rdi
callq 0x94e0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x23cb9(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x93d0
leaq 0x23c9f(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzwl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x98b0
leaq 0x23c84(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzbl 0x83(%rbx), %esi
movq %rax, %rdi
callq 0x9870
leaq 0x23c66(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzbl 0x82(%rbx), %esi
movq %rax, %rdi
callq 0x9870
leaq 0x23c48(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movl (%r14), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x26683(%rip), %rsi     # 0x4a9a6
movq %rax, %rdi
callq 0x94e0
movl (%r14), %esi
decl %esi
movq %rax, %rdi
callq 0x9310
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x97f0
leaq 0x412e5(%rip), %rdi     # 0x65631
movq %rsp, %rsi
callq 0x237b4
movq %rsp, %rdi
callq 0x9a68
leaq 0x20(%rsp), %rdi
callq 0x9390
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9a68
jmp 0x24386
jmp 0x24383
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: CostCompare::operator()(Branch const*, Branch const*) const
bool operator()(const Branch* a, const Branch* b) const {
		bool aUnextendable = a->curtailed_ || a->exhausted_;
		bool bUnextendable = b->curtailed_ || b->exhausted_;
		// Branch with the best cost
		if(a->cost_ == b->cost_) {
			// If one or the other is curtailed, take the one that's
			// still getting extended
			if(bUnextendable && !aUnextendable) {
				// a still being extended, return false
				return false;
			}
			if(aUnextendable && !bUnextendable) {
				// b still being extended, return true
				return true;
			}
			// Either both are curtailed or both are still being
			// extended, pick based on which one is deeper
			if(a->tipDepth() != b->tipDepth()) {
				// Expression is true if b is deeper
				return a->tipDepth() < b->tipDepth();
			}
			// Keep things deterministic by providing an unambiguous
			// order using the id_ field
			assert_neq(b->id_, a->id_);
			return b->id_ < a->id_;
		} else {
			return b->cost_ < a->cost_;
		}
	}

// Assembly:
movb $0x1, %al
cmpb $0x0, 0x82(%rsi)
movb $0x1, %cl
jne 0x245cb
movb 0x83(%rsi), %cl
cmpb $0x0, 0x82(%rdx)
jne 0x245da
movb 0x83(%rdx), %al
movzwl 0x10(%rsi), %edi
movzwl 0x10(%rdx), %r8d
cmpw %r8w, %di
jne 0x2461f
movl %eax, %edi
notb %dil
orb %cl, %dil
testb $0x1, %dil
je 0x24623
notb %cl
orb %al, %cl
movb $0x1, %al
testb $0x1, %cl
je 0x2461e
movzwl 0xe(%rsi), %eax
addw 0xc(%rsi), %ax
movzwl 0xe(%rdx), %ecx
addw 0xc(%rdx), %cx
cmpw %cx, %ax
jne 0x2461b
movl (%rdx), %eax
cmpl (%rsi), %eax
setb %al
retq
seta %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: PathManager::curtail(Branch*, unsigned int, int, bool)
void curtail(Branch *br, uint32_t qlen, int seedLen, bool qualOrder) {
		assert(!br->exhausted_);
		assert(!br->curtailed_);
		uint16_t origCost = br->cost_;
		br->curtail(rpool, seedLen, qualOrder);
		assert(br->curtailed_);
		assert_geq(br->cost_, origCost);
		if(br->exhausted_) {
			assert(br == front());
			ASSERT_ONLY(Branch *popped =) pop();
			assert(popped == br);
			br->free(qlen, rpool, epool, bpool);
		} else if(br->cost_ != origCost) {
			// Re-insert the newly-curtailed branch
			assert(br == front());
			Branch *popped = pop();
			assert(popped == br);
			push(popped);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x10(%rsi), %r12d
leaq 0x98(%rdi), %r15
movq %rsi, %rdi
movq %r15, %rsi
movl %ecx, %edx
movl %r8d, %ecx
callq 0x2516a
cmpb $0x1, 0x83(%r14)
jne 0x24c53
movq %rbx, %rdi
callq 0x252d2
leaq 0xf8(%rbx), %rcx
addq $0x38, %rbx
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25300
cmpw %r12w, 0x10(%r14)
jne 0x24c63
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x252d2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x233b0
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::mapLFEx(SideLocus const&, SideLocus const&, unsigned int*, unsigned int*) const
inline void Ebwt::mapLFEx(const SideLocus& ltop,
                                const SideLocus& lbot,
                                TIndexOffU *tops,
                                TIndexOffU *bots
                                ASSERT_ONLY(, bool overrideSanity)
                                ) const
{
	// TODO: Where there's overlap, reuse the count for the overlapping
	// portion
#ifdef EBWT_STATS
	const_cast<Ebwt*>(this)->mapLFExs_++;
#endif
	assert_eq(0, tops[0]); assert_eq(0, bots[0]);
	assert_eq(0, tops[1]); assert_eq(0, bots[1]);
	assert_eq(0, tops[2]); assert_eq(0, bots[2]);
	assert_eq(0, tops[3]); assert_eq(0, bots[3]);
	if(ltop._fw) {
		 // Forward side
		!_eh._isBt2Index ? countFwSideEx(ltop, tops)
		                 : countBt2SideEx(ltop, tops);
	} else {
		countBwSideEx(ltop, tops); // Backward side
	}

	if(lbot._fw) {
		// Forward side
		!_eh._isBt2Index ? countFwSideEx(lbot, bots)
		                 : countBt2SideEx(lbot, bots);
	} else {
		countBwSideEx(lbot, bots); // Backward side
	}
#ifndef NDEBUG
	if(_sanity && !overrideSanity) {
		// Make sure results match up with individual calls to mapLF;
		// be sure to override sanity-checking in the callee, or we'll
		// have infinite recursion
		assert_eq(mapLF(ltop, 0, true), tops[0]);
		assert_eq(mapLF(ltop, 1, true), tops[1]);
		assert_eq(mapLF(ltop, 2, true), tops[2]);
		assert_eq(mapLF(ltop, 3, true), tops[3]);
		assert_eq(mapLF(lbot, 0, true), bots[0]);
		assert_eq(mapLF(lbot, 1, true), bots[1]);
		assert_eq(mapLF(lbot, 2, true), bots[2]);
		assert_eq(mapLF(lbot, 3, true), bots[3]);
	}
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %r15
cmpb $0x1, 0xa(%rsi)
jne 0x24d93
cmpb $0x0, 0x17d(%r15)
je 0x24da0
movq %r15, %rdi
movq %rcx, %rdx
callq 0x25da6
jmp 0x24dab
movq %r15, %rdi
movq %rcx, %rdx
callq 0x25e3a
jmp 0x24dab
movq %r15, %rdi
movq %rcx, %rdx
callq 0x25d14
cmpb $0x1, 0xa(%r14)
jne 0x24dcf
cmpb $0x0, 0x17d(%r15)
je 0x24de2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x25da6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x25e3a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x25d14
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::mapLF1(unsigned int&, SideLocus const&) const
inline int Ebwt::mapLF1(TIndexOffU& row, const SideLocus& l
                              ASSERT_ONLY(, bool overrideSanity)
                              ) const
{
#ifdef EBWT_STATS
	const_cast<Ebwt*>(this)->mapLF1s_++;
#endif
	if(row == _zOff) return -1;
	int c = rowL(l);
	assert_lt(c, 4);
	assert_geq(c, 0);
	if(l._fw) {
		// Forward side
		row = !_eh._isBt2Index ? countFwSide(l, c)
		                       : countBt2Side(l, c);
	} else {
		row = countBwSide(l, c); // Backward side
	}
	assert_lt(row, this->_eh._bwtLen);
#ifndef NDEBUG
	if(_sanity && !overrideSanity) {
		// Make sure results match up with results from mapLFEx;
		// be sure to override sanity-checking in the callee, or we'll
		// have infinite recursion
		TIndexOffU arrs[] = { 0, 0, 0, 0 };
		mapLFEx(l, arrs, true);
		assert_eq(arrs[c], row);
	}
#endif
	return c;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpl 0x68(%rdi), %eax
jne 0x24e05
pushq $-0x1
popq %rbp
jmp 0x24e57
movq %rsi, %rbx
movl (%rdx), %eax
addq 0xb8(%rdi), %rax
movswq 0xc(%rdx), %rcx
movzbl (%rcx,%rax), %ebp
movb 0xe(%rdx), %cl
addb %cl, %cl
shrl %cl, %ebp
andl $0x3, %ebp
cmpb $0x1, 0xa(%rdx)
jne 0x24e3f
cmpb $0x0, 0x17d(%rdi)
je 0x24e4b
movq %rdx, %rsi
movl %ebp, %edx
callq 0x17544
jmp 0x24e55
movq %rdx, %rsi
movl %ebp, %edx
callq 0x175b0
jmp 0x24e55
movq %rdx, %rsi
movl %ebp, %edx
callq 0x174c2
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: PathManager::reset(unsigned int)
void reset(uint32_t patid) {
		branchQ_.reset(patid); // reset the priority queue
		assert(branchQ_.empty());
		bpool.reset();    // reset the Branch pool
		epool.reset();    // reset the Edit pool
		rpool.reset();    // reset the RangeState pool
		assert(bpool.empty());
		assert(epool.empty());
		assert(rpool.empty());
		ASSERT_ONLY(branchSet_.clear());
		assert_eq(0, branchSet_.size());
		assert_eq(0, branchQ_.size());
		minCost = 0;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x267d8
andq $0x0, 0x60(%rbx)
andq $0x0, 0x88(%rbx)
andl $0x0, 0x94(%rbx)
andl $0x0, 0x68(%rbx)
andq $0x0, 0x120(%rbx)
andq $0x0, 0x148(%rbx)
andl $0x0, 0x154(%rbx)
andl $0x0, 0x128(%rbx)
andq $0x0, 0xc0(%rbx)
andq $0x0, 0xe8(%rbx)
andl $0x0, 0xf4(%rbx)
andl $0x0, 0xc8(%rbx)
andw $0x0, 0x158(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: Branch::free(unsigned int, AllocOnlyPool<RangeState>&, AllocOnlyPool<Edit>&, AllocOnlyPool<Branch>&)
void free(uint32_t qlen,
	          AllocOnlyPool<RangeState>& rpool,
	          AllocOnlyPool<Edit>& epool,
	          AllocOnlyPool<Branch>& bpool)
	{
		edits_.free(epool, qlen);
		if(ranges_ != NULL) {
			assert_gt(rangesSz_, 0);
			rpool.free(ranges_, rangesSz_);
			ranges_ = NULL;
			rangesSz_ = 0;
		}
		bpool.free(this);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdx, %r15
movq %rdi, %r14
addq $0x50, %rdi
movl %esi, %edx
movq %rcx, %rsi
callq 0x258f0
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x2533d
movzwl 0x20(%r14), %edx
movq %r15, %rdi
callq 0x25370
andq $0x0, 0x18(%r14)
andw $0x0, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x25932
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::free(RangeState*, unsigned int)
bool free(T* t, uint32_t num) {
		assert(t != NULL);
		if(pool_->verbose) {
			stringstream ss;
			ss << pool_->patid << ": Freeing " << num << " " << name_ << "s";
			glog.msg(ss.str());
		}
		if(num <= cur_ && t == &pools_[curPool_][cur_ - num]) {
			cur_ -= num;
			if(cur_ == 0 && curPool_ > 0) {
				rewindPool();
			}
			return true; // deallocated
		}
		return false; // didn't deallocate
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x25420
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0x38(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x9310
leaq 0x25664(%rip), %rsi     # 0x4aa14
movq %rax, %rdi
callq 0x94e0
movl %ebp, %esi
movq %rax, %rdi
callq 0x9310
leaq 0x25a3f(%rip), %rsi     # 0x4ae08
movq %rax, %rdi
callq 0x94e0
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x94e0
leaq 0x25d39(%rip), %rsi     # 0x4b11d
movq %rax, %rdi
callq 0x94e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97f0
leaq 0x4022f(%rip), %rdi     # 0x65631
leaq 0x8(%rsp), %rsi
callq 0x237b4
leaq 0x8(%rsp), %rdi
callq 0x9a68
leaq 0x28(%rsp), %rdi
callq 0x9390
movl 0x5c(%rbx), %eax
movl %eax, %ecx
subl %ebp, %ecx
jb 0x2543d
movl 0x30(%rbx), %edx
movq 0x18(%rbx), %rsi
imulq $0x30, %rcx, %rdi
addq (%rsi,%rdx,8), %rdi
cmpq %r14, %rdi
je 0x2544d
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movl %ecx, 0x5c(%rbx)
cmpl %ebp, %eax
setne %al
testl %edx, %edx
sete %cl
orb %al, %cl
movb $0x1, %bpl
jne 0x2543f
movq %rbx, %rdi
callq 0x25492
jmp 0x2543f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9a68
jmp 0x2547f
jmp 0x2547c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::rewindPool()
void rewindPool() {
		assert_eq(curPool_+1, pools_.size());
		assert_eq(curPool_, lastCurInPool_.size());
		if(pool_->verbose) {
			stringstream ss;
			ss << pool_->patid << ": Freeing a " << name_ << " pool";
			glog.msg(ss.str());
		}
		pool_->free(pools_.back());
		pools_.pop_back();
		curPool_--;
		assert_gt(lastCurInPool_.size(), 0);
		cur_ = lastCurInPool_.back();
		lastCurInPool_.pop_back();
	}

// Assembly:
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x1, (%rdi)
jne 0x25520
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0x38(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x9310
leaq 0x25559(%rip), %rsi     # 0x4aa1f
movq %rax, %rdi
callq 0x94e0
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x94e0
leaq 0x2554b(%rip), %rsi     # 0x4aa2c
movq %rax, %rdi
callq 0x94e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97f0
leaq 0x40132(%rip), %rdi     # 0x65631
leaq 0x8(%rsp), %rsi
callq 0x237b4
leaq 0x8(%rsp), %rdi
callq 0x9a68
leaq 0x28(%rsp), %rdi
callq 0x9390
movq (%rbx), %rdi
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rsi
callq 0x2557e
decq 0x28(%rbx)
decl 0x30(%rbx)
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
movl -0x4(%rax,%rcx,4), %eax
movl %eax, 0x5c(%rbx)
decq %rcx
movq %rcx, 0x50(%rbx)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9a68
jmp 0x2556c
jmp 0x25569
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::free(void*)
void free(void *ptr) {
		uint32_t off = (uint32_t)((int8_t*)ptr - pool_);
		assert_eq(0, off % chunkSz_);
		off /= chunkSz_;
		if(verbose) {
			stringstream ss;
			ss << patid << ": Freeing chunk with offset: " << cur_;
			glog.msg(ss.str());
		}
		bits_.clear(off);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movl 0x14(%rdi), %ebp
cmpb $0x1, (%rdi)
jne 0x255fc
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0x30(%rsp), %rdi
movl 0x4(%rbx), %esi
callq 0x9310
leaq 0x25477(%rip), %rsi     # 0x4aa32
movq %rax, %rdi
callq 0x94e0
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x97f0
leaq 0x4004f(%rip), %rdi     # 0x65631
movq %rsp, %rsi
callq 0x237b4
movq %rsp, %rdi
callq 0x9a68
leaq 0x20(%rsp), %rdi
callq 0x9390
subl %r15d, %r14d
movl %r14d, %eax
xorl %edx, %edx
divl %ebp
addq $0x20, %rbx
movq %rbx, %rdi
movl %eax, %esi
callq 0x25646
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9a68
jmp 0x25634
jmp 0x25631
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: BranchQueue::pop()
Branch *pop() {
		Branch *b = branchQ_.top(); // get it
		branchQ_.pop(); // remove it
		if(verbose_) {
			stringstream ss;
			ss << patid_ << ": Popping " << b->id_ << ", " << b << ", " << b->cost_ << ", " << b->exhausted_ << ", " << b->curtailed_ << ", " << sz_ << "->" << (sz_-1);
			glog.msg(ss.str());
		}
		sz_--;
		return b;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rbx), %rax
movq (%rax), %r14
callq 0x257c8
cmpb $0x1, 0x2c(%rbx)
jne 0x25794
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0x30(%rsp), %rdi
movl 0x28(%rbx), %esi
callq 0x9310
leaq 0x253a5(%rip), %rsi     # 0x4aa50
movq %rax, %rdi
callq 0x94e0
movl (%r14), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x2288c(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x93d0
leaq 0x22872(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzwl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x98b0
leaq 0x22856(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzbl 0x83(%r14), %esi
movq %rax, %rdi
callq 0x9870
leaq 0x22837(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movzbl 0x82(%r14), %esi
movq %rax, %rdi
callq 0x9870
leaq 0x22818(%rip), %rsi     # 0x47f51
movq %rax, %rdi
callq 0x94e0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x9310
leaq 0x25254(%rip), %rsi     # 0x4a9a6
movq %rax, %rdi
callq 0x94e0
movl (%rbx), %esi
decl %esi
movq %rax, %rdi
callq 0x9310
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x97f0
leaq 0x3feb7(%rip), %rdi     # 0x65631
movq %rsp, %rsi
callq 0x237b4
movq %rsp, %rdi
callq 0x9a68
leaq 0x20(%rsp), %rdi
callq 0x9390
decl (%rbx)
movq %r14, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9a68
jmp 0x257b6
jmp 0x257b3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./range_source.h
// Function: EditList::free(AllocOnlyPool<Edit>&, unsigned long)
void free(AllocOnlyPool<Edit>& epool, size_t qlen) {
		if(yetMoreEdits_ != NULL)
			epool.free(yetMoreEdits_, (uint32_t)qlen + 10 - numMoreEdits - numEdits);
		if(moreEdits_ != NULL)
			epool.free(moreEdits_, numMoreEdits);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x2590e
addl $-0xc, %edx
movq %rbx, %rdi
callq 0x25a16
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x25929
pushq $0x10
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x25a16
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::free(Branch*)
void free(T* t) {
		assert(t != NULL);
		if(pool_->verbose) {
			stringstream ss;
			ss << pool_->patid << ": Freeing a " << name_;
			glog.msg(ss.str());
		}
		if(cur_ > 0 && t == &pools_[curPool_][cur_-1]) {
			cur_--;
			if(cur_ == 0 && curPool_ > 0) {
				rewindPool();
			}
		}
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x259ad
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0x30(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x9310
leaq 0x250b4(%rip), %rsi     # 0x4aa1f
movq %rax, %rdi
callq 0x94e0
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x94e0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x97f0
leaq 0x3fc9e(%rip), %rdi     # 0x65631
movq %rsp, %rsi
callq 0x237b4
movq %rsp, %rdi
callq 0x9a68
leaq 0x20(%rsp), %rdi
callq 0x9390
movl 0x5c(%rbx), %eax
testl %eax, %eax
je 0x259e6
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
decl %eax
imulq $0x88, %rax, %rsi
addq (%rdx,%rcx,8), %rsi
cmpq %r14, %rsi
jne 0x259e6
movl %eax, 0x5c(%rbx)
testl %eax, %eax
setne %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
jne 0x259e6
movq %rbx, %rdi
callq 0x25c28
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9a68
jmp 0x25a03
jmp 0x25a00
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9390
movq %rbx, %rdi
callq 0x9950
nop