LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./aligner.h
// Function: MixedMultiAligner::MixedMultiAligner(unsigned int, unsigned int, AlignerFactory const&, AlignerFactory const&, PatternSourcePerThreadFactory const&)
MixedMultiAligner(
			uint32_t n,
			uint32_t qUpto,
			const AlignerFactory& alignSEFact,
			const AlignerFactory& alignPEFact,
			const PatternSourcePerThreadFactory& patsrcFact) :
			n_(n), qUpto_(qUpto),
			alignSEFact_(alignSEFact),
			alignPEFact_(alignPEFact),
			patsrcFact_(patsrcFact),
			alignersSE_(NULL),
			alignersPE_(NULL),
			seOrPe_(NULL),
			patsrcs_(NULL)
	{
		// Instantiate all single-end aligners
		alignersSE_ = alignSEFact_.create(n_);
		assert(alignersSE_ != NULL);
		// Instantiate all paired-end aligners
		alignersPE_ = alignPEFact_.create(n_);
		assert(alignersPE_ != NULL);
		// Allocate array of boolean flags indicating whether each of
		// the slots is currently using the single-end or paired-end
		// aligner
		seOrPe_ = new bool[n_];
		for(uint32_t i = 0; i < n_; i++) {
			seOrPe_[i] = true;
		}
		// Instantiate all read sources
		patsrcs_ = patsrcFact_.create(n_);
		assert(patsrcs_ != NULL);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x47084(%rip), %rax     # 0x6a4d8
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %r9, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq (%rcx), %rax
movq %rcx, %rdi
callq *0x18(%rax)
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rdi
movl 0x8(%rbx), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, 0x30(%rbx)
movl 0x8(%rbx), %r14d
movq %r14, %rdi
callq 0x9030
movq %rax, 0x38(%rbx)
testq %r14, %r14
je 0x234bd
xorl %eax, %eax
movq 0x38(%rbx), %rcx
movb $0x1, (%rcx,%rax)
incq %rax
movl 0x8(%rbx), %r14d
cmpq %r14, %rax
jb 0x234a9
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x8(%rax)
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./aligner.h
// Function: MixedMultiAligner::~MixedMultiAligner()
virtual ~MixedMultiAligner() {
		alignSEFact_.destroy(alignersSE_);
		alignPEFact_.destroy(alignersPE_);
		patsrcFact_.destroy(patsrcs_);
		delete[] seOrPe_;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x46e09(%rip), %rax     # 0x6a4d8
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x18(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x20(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2370b
popq %rbx
jmp 0x95e0
popq %rbx
retq
movq %rax, %rdi
callq 0x1b23d
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./pat.h
// Function: PatternSourcePerThreadFactory::create(unsigned int) const
virtual EList<PatternSourcePerThread*>* create(uint32_t n) const {
		EList<PatternSourcePerThread*>* v = new EList<PatternSourcePerThread*>;
		for(size_t i = 0; i < n; i++) {
			v->push_back(new PatternSourcePerThread(composer_, max_buf_, skip_, seed_));
			assert(v->back() != NULL);
		}
		return v;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x20, %edi
callq 0x94b0
movq %rax, %r14
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq $0x80, 0x10(%r14)
movq %rax, 0x18(%r14)
testl %ebp, %ebp
je 0x24d0e
movl %ebp, %r13d
movl $0x80, %edi
callq 0x94b0
movq %rax, %r12
movq 0x8(%rbx), %rax
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %r15d
movl 0x18(%rbx), %ebp
movq %rax, (%r12)
leaq 0x8(%r12), %rdi
callq 0x24df4
movb $0x0, 0x60(%r12)
xorl %eax, %eax
movq %rax, 0x68(%r12)
movl %r15d, 0x70(%r12)
movl %ebp, 0x74(%r12)
movq %rax, 0x78(%r12)
movq %r12, (%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0x25ea0
decq %r13
jne 0x24cb5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x80, %esi
movq %r12, %rdi
callq 0x94c0
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./pat.h
// Function: PatternSourcePerThreadFactory::destroy(EList<PatternSourcePerThread*, 128>*) const
virtual void destroy(EList<PatternSourcePerThread*>* composers) const {
		assert(composers != NULL);
		// Free all of the PatternSourcePerThreads
		for(size_t i = 0; i < composers->size(); i++) {
			if((*composers)[i] != NULL) {
				delete (*composers)[i];
				(*composers)[i] = NULL;
			}
		}
		// Free the vector
		delete composers;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x18(%rsi)
je 0x24db5
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x24dac
leaq 0x30(%r14), %rdi
callq 0x259fe
leaq 0x10(%r14), %rdi
callq 0x259fe
movl $0x80, %esi
movq %r14, %rdi
callq 0x94c0
movq 0x8(%rbx), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
cmpq 0x18(%rbx), %r15
jb 0x24d74
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x24dd6
leaq 0x8(%rbx), %r14
callq 0x95e0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x20, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x94c0
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 0, 2, 2048>::~SStringExpandable()
virtual ~SStringExpandable() {
		if(cs_ != NULL) {
			delete[] cs_;
			cs_ = NULL;
		}
		if(printcs_ != NULL) {
			delete[] printcs_;
			printcs_ = NULL;
		}
		sz_ = len_ = 0;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x447d9(%rip), %rax     # 0x69b40
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x25380
callq 0x95e0
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x25396
callq 0x95e0
movq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::install(char const*, unsigned long)
virtual void install(const char* b, size_t sz) {
		if(this->sz_ < sz) this->expandCopy((sz + S) * M);
		memcpy(this->cs_, b, sz);
#ifndef NDEBUG
		for(size_t i = 0; i < sz; i++) {
			assert_range(0, 4, (int)this->cs_[i]);
		}
#endif
		this->len_ = sz;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdx, 0x28(%rdi)
jae 0x25420
leaq 0x32(,%rbx,2), %rsi
movq %r14, %rdi
callq 0x25560
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x93c0
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::installChars(char const*, unsigned long)
virtual void installChars(const char* b, size_t sz) {
		if(this->sz_ < sz) this->expandCopy((sz + S) * M);
		for(size_t i = 0; i < sz; i++) {
			assert_in(toupper(b[i]), "ACGTN-");
			this->cs_[i] = asc2dna[(int)b[i]];
			assert_range(0, 4, (int)this->cs_[i]);
		}
		this->len_ = sz;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdx, 0x28(%rdi)
jae 0x254b4
leaq 0x32(,%rbx,2), %rsi
movq %r14, %rdi
callq 0x25560
testq %rbx, %rbx
je 0x254d9
xorl %eax, %eax
leaq 0x4808e(%rip), %rcx     # 0x6d550
movsbq (%r15,%rax), %rdx
movb (%rcx,%rdx), %dl
movq 0x8(%r14), %rsi
movb %dl, (%rsi,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x254c2
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SDnaStringExpandable<25, 2>::installColors(char const*, unsigned long)
virtual void installColors(const char* b, size_t sz) {
		if(this->sz_ < sz) this->expandCopy((sz + S) * M);
		for(size_t i = 0; i < sz; i++) {
			assert_in(b[i], "0123.");
			this->cs_[i] = asc2col[(int)b[i]];
			assert_range(0, 4, (int)this->cs_[i]);
		}
		this->len_ = sz;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdx, 0x28(%rdi)
jae 0x25508
leaq 0x32(,%rbx,2), %rsi
movq %r14, %rdi
callq 0x25560
testq %rbx, %rbx
je 0x2552d
xorl %eax, %eax
leaq 0x4813a(%rip), %rcx     # 0x6d650
movsbq (%r15,%rax), %rdx
movb (%rcx,%rdx), %dl
movq 0x8(%r14), %rsi
movb %dl, (%rsi,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x25516
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::expandCopy(unsigned long)
void expandCopy(size_t sz) {
		if(sz_ >= sz) return; // done!
		T *tmp  = new T[sz + 1];
		char *ptmp = new char[sz + 1];
		if(cs_ != NULL) {
			memcpy(tmp, cs_, sizeof(T)*len_);
			delete[] cs_;
		}
		if(printcs_ != NULL) {
			memcpy(ptmp, printcs_, sizeof(char)*len_);
			delete[] printcs_;
		}
		cs_ = tmp;
		printcs_ = ptmp;
		sz_ = sz;
	}

// Assembly:
cmpq %rsi, 0x28(%rdi)
jae 0x255e4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %r12
movq %r12, %rdi
callq 0x9030
movq %rax, %r15
movq %r12, %rdi
callq 0x9030
movq %rax, %r12
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x255af
movq 0x20(%r14), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x93c0
movq %r13, %rdi
callq 0x95e0
movq 0x10(%r14), %r13
testq %r13, %r13
je 0x255cf
movq 0x20(%r14), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x93c0
movq %r13, %rdi
callq 0x95e0
movq %r15, 0x8(%r14)
movq %r12, 0x10(%r14)
movq %rbx, 0x28(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::toZBufXForm(char const*) const
const char* toZBufXForm(const char *xform) const {
		ASSERT_ONLY(size_t xformElts = strlen(xform));
		if(empty()) {
			const_cast<char&>(zero_) = 0;
			return &zero_;
		}
		char* printcs = const_cast<char*>(printcs_);
		// Lazily allocate space for print buffer
		for(size_t i = 0; i < len_; i++) {
			assert_lt(cs_[i], (int)xformElts);
			printcs[i] = xform[(int)cs_[i]];
		}
		printcs[len_] = 0;
		return printcs_;
	}

// Assembly:
movq %rdi, %rax
cmpq $0x0, 0x20(%rdi)
je 0x25625
movq 0x10(%rax), %rcx
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x2561c
xorl %edx, %edx
movq 0x8(%rax), %rdi
movsbq (%rdi,%rdx), %rdi
movb (%rsi,%rdi), %dil
movb %dil, (%rcx,%rdx)
incq %rdx
movq 0x20(%rax), %rdi
cmpq %rdi, %rdx
jb 0x255ff
movb $0x0, (%rcx,%rdi)
movq 0x10(%rax), %rax
retq
movb $0x0, 0x18(%rax)
addq $0x18, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./hit.h
// Function: HitSinkPerThread::finishRead(PatternSourcePerThread&, bool, bool)
virtual uint32_t finishRead(PatternSourcePerThread& p, bool report, bool dump) {
		uint32_t ret = finishReadImpl();
		_bestRemainingStratum = 0;
		if(!report) {
			_bufferedHits.clear();
			return 0;
		}
		bool maxed = (ret > _max);
		bool unal = (ret == 0);
		if(dump && (unal || maxed)) {
			// Either no reportable hits were found or the number of
			// reportable hits exceeded the -m limit specified by the
			// user
			assert(ret == 0 || ret > _max);
			if(maxed) _sink.dumpMaxed(p);
			else      _sink.dumpUnal(p);
		}
		ret = 0;
		if(maxed) {
			// Report that the read maxed-out; useful for chaining output
			if(dump) _sink.reportMaxed(_bufferedHits, threadId_, p);
			_bufferedHits.clear();
		} else if(unal) {
			// Report that the read failed to align; useful for chaining output
			if(dump) _sink.reportUnaligned(threadId_, p);
		} else {
			// Flush buffered hits
			assert_gt(_bufferedHits.size(), 0);
			if(_bufferedHits.size() > _n) {
				_bufferedHits.resize(_n);
			}
			int mapq = defaultMapq_;
			int xms = (int)(_bufferedHits.size());
			const bool paired = p.bufa().mate > 0;
			if(paired) {
				xms /= 2;
			}
			_sink.reportHits(NULL, &_bufferedHits, 0, _bufferedHits.size(),
			                 threadId_, mapq, xms, true, p);
			_sink.dumpAlign(p);
			ret = (uint32_t)_bufferedHits.size();
			_bufferedHits.clear();
		}
		assert_eq(0, _bufferedHits.size());
		return ret;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x0, 0x10(%rbx)
testl %r12d, %r12d
je 0x2618c
movl %eax, %r15d
movl 0x64(%rbx), %r12d
cmpl %r12d, %eax
seta %al
testl %r15d, %r15d
sete %cl
testb %bpl, %bpl
je 0x2616d
orb %al, %cl
je 0x2616d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
cmpl %r12d, %r15d
jbe 0x26168
callq 0x2647c
jmp 0x2616d
callq 0x26768
cmpl %r12d, %r15d
jbe 0x261a3
testb %bpl, %bpl
je 0x2618c
leaq 0x40(%rbx), %rsi
movq 0x8(%rbx), %rdi
movq 0x70(%rbx), %rdx
movq (%rdi), %rax
movq %r14, %rcx
callq *0x20(%rax)
movq $0x0, 0x58(%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
je 0x26227
leaq 0x40(%rbx), %r15
movl 0x68(%rbx), %esi
cmpq %rsi, 0x58(%rbx)
jbe 0x261bd
movq %r15, %rdi
callq 0x269da
movl 0x6c(%rbx), %eax
movq 0x8(%rbx), %rdi
movq 0x58(%rbx), %r8
movq 0x18(%r14), %rcx
imulq $0x268, 0x50(%r14), %rdx # imm = 0x268
movl %r8d, %r10d
shrl $0x1f, %r10d
addl %r8d, %r10d
sarl %r10d
cmpl $0x0, 0x188(%rcx,%rdx)
cmovlel %r8d, %r10d
movq 0x70(%rbx), %r9
movq (%rdi), %r11
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
pushq %r14
pushq $0x1
pushq %r10
pushq %rax
callq *0x18(%r11)
addq $0x20, %rsp
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x26a40
movl 0x58(%rbx), %r15d
movq $0x0, 0x58(%rbx)
jmp 0x26197
xorl %r15d, %r15d
testb %bpl, %bpl
je 0x26197
movq 0x8(%rbx), %rdi
movq 0x70(%rbx), %rsi
movq (%rdi), %rax
movq %r14, %rdx
callq *0x28(%rax)
jmp 0x26197
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./hit.h
// Function: Hit::operator=(Hit const&)
Hit& operator = (const Hit &other) {
		this->h       = other.h;
		this->mh      = other.mh;
		this->patId   = other.patId;
		this->patName = other.patName;
		this->patSeq  = other.patSeq;
		this->quals   = other.quals;
		this->mms     = other.mms;
		this->refcs   = other.refcs;
		this->crefcs  = other.crefcs;
		this->oms     = other.oms;
		this->fw      = other.fw;
		this->mfw     = other.mfw;
		this->mlen    = other.mlen;
		this->stratum = other.stratum;
		this->cost    = other.cost;
		this->mate    = other.mate;
		this->seed    = other.seed;
		return *this;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
addq $0x18, %rdi
movq 0x20(%rsi), %rsi
movq 0x38(%r14), %rdx
movq 0x18(%rbx), %rax
callq *0x10(%rax)
leaq 0x48(%rbx), %rdi
movq 0x50(%r14), %rsi
movq 0x68(%r14), %rdx
movq 0x48(%rbx), %rax
callq *0x10(%rax)
leaq 0x78(%rbx), %rdi
movq 0x80(%r14), %rsi
movq 0x98(%r14), %rdx
movq 0x78(%rbx), %rax
callq *0x10(%rax)
movl $0xa8, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
movl $0x8c, %edx
callq 0x93c0
movl $0x138, %edi            # imm = 0x138
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x274e6
movl $0x158, %edi            # imm = 0x158
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x274e6
movl 0x178(%r14), %eax
movl %eax, 0x178(%rbx)
movb 0x17c(%r14), %al
movb %al, 0x17c(%rbx)
movb 0x17d(%r14), %al
movb %al, 0x17d(%rbx)
movzwl 0x17e(%r14), %eax
movw %ax, 0x17e(%rbx)
movb 0x180(%r14), %al
movb %al, 0x180(%rbx)
movl 0x184(%r14), %eax
movl %eax, 0x184(%rbx)
movb 0x188(%r14), %al
movb %al, 0x188(%rbx)
movl 0x18c(%r14), %eax
movl %eax, 0x18c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./hit.h
// Function: NBestFirstStratHitSinkPerThread::finishReadImpl()
virtual uint32_t finishReadImpl() {
		uint32_t ret = hitsForThisRead_;
		hitsForThisRead_ = 0;
		bestStratum_ = 999;
		const size_t sz = _bufferedHits.size();
		for(size_t i = 0; i < sz; i++) {
			// Set 'oms' according to the number of other alignments
			// at this stratum
			_bufferedHits[i].oms = ((uint32_t)sz / mult_) - 1;
		}
		return ret;
	}

// Assembly:
movl 0x60(%rdi), %ecx
movl $0x0, 0x60(%rdi)
movl $0x3e7, 0x78(%rdi)      # imm = 0x3E7
movq 0x58(%rdi), %rsi
testq %rsi, %rsi
je 0x279a2
movl $0x178, %r8d            # imm = 0x178
movq %rsi, %r9
movl %esi, %eax
xorl %edx, %edx
divl 0x7c(%rdi)
decl %eax
movq 0x48(%rdi), %rdx
movl %eax, (%rdx,%r8)
addq $0x190, %r8             # imm = 0x190
decq %r9
jne 0x27985
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x279c4
movl %edx, 0x78(%r14)
movb $0x1, %bl
cmpl 0x64(%r14), %eax
ja 0x279f4
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movl 0x68(%r14), %eax
cmpl %eax, 0x60(%r14)
jne 0x279f2
movl 0x64(%r14), %ecx
cmpl $-0x1, %ecx
sete %dl
cmpl %eax, %ecx
setb %al
orb %dl, %al
jne 0x279f4
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl 0x3c(%rdi), %eax
je 0x27af8
cmpb $0x0, 0x38(%rbx)
jne 0x27a5e
cmpb $0x0, 0x4661c(%rip)     # 0x6e060
jne 0x27a5e
movq 0x435a3(%rip), %rdi     # 0x6aff0
leaq 0x2ee0d(%rip), %rsi     # 0x56861
movl $0x9, %edx
callq 0x9560
cmpb $0x0, 0x465fb(%rip)     # 0x6e060
jne 0x27af2
movq 0x4357e(%rip), %r14     # 0x6aff0
leaq 0x2edf2(%rip), %rsi     # 0x5686b
movl $0x2b, %edx
movq %r14, %rdi
callq 0x9560
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x1fe01
movq %rax, %r14
leaq 0x2edfb(%rip), %rsi     # 0x56897
movl $0x8, %edx
movq %rax, %rdi
callq 0x9560
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x92e0
movq %rax, %r14
leaq 0x2ede2(%rip), %rsi     # 0x568a0
movl $0x10, %edx
movq %rax, %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
cmpb $0x1, 0x38(%rbx)
je 0x27b06
movl 0x4(%rbx), %eax
movl %eax, 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x0, 0x46553(%rip)     # 0x6e060
jne 0x27b32
movq 0x434da(%rip), %rbx     # 0x6aff0
leaq 0x2ed94(%rip), %rsi     # 0x568b1
movl $0x3f, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
callq 0x91f0
movl $0x4, %edi
callq 0x9200
movl $0x1, (%rax)
movq 0x433ef(%rip), %rsi     # 0x6af38
movq %rax, %rdi
xorl %edx, %edx
callq 0x98f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x20, %edi
callq 0x94b0
movq %rax, %r15
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq $0x80, 0x10(%r15)
movq %rax, 0x18(%r15)
testl %ebx, %ebx
je 0x29c9a
movq %rsp, %r12
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x330fc
decl %ebx
jne 0x29c7e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x18(%rsi)
je 0x29cf3
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x29cea
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
cmpq 0x18(%rbx), %r14
jb 0x29ccb
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x29d14
leaq 0x8(%rbx), %r14
callq 0x95e0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x20, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x94c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
movw $0x0, 0xc(%rdi)
leaq 0x40121(%rip), %rax     # 0x6a190
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
xorl %edi, %edi
movq %rdi, 0x18(%r14)
movl $0x80, %r10d
movq %r10, 0x20(%r14)
movq %rdi, 0x28(%r14)
movq %rax, 0x30(%r14)
leaq 0x38(%r14), %r12
movq %rdi, 0x38(%r14)
movq %r10, 0x40(%r14)
movq %rdi, 0x48(%r14)
movb %sil, 0x51(%r14)
movabsq $0x3c6ef35f0019660d, %rax # imm = 0x3C6EF35F0019660D
movq %rax, 0x58(%r14)
movb $0x0, 0x68(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
movq %rdi, 0x80(%r14)
movb %cl, 0x88(%r14)
movb %r8b, 0x89(%r14)
movb %r9b, 0x8a(%r14)
testq %rdx, %rdx
je 0x2a0fb
movq %r15, %rdi
movq %rdx, %rsi
callq 0x30676
movb $0x0, 0x50(%r14)
movw $0x0, 0x8(%r14)
cmpq $0x0, 0x28(%r14)
je 0x2a129
movq %r14, %rdi
callq 0x30d06
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x30676
movw $0x0, 0xa(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2a157
callq 0x95e0
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %rbx, %rdi
callq 0x9b1f
movq %r14, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rcx
movb 0x70(%rdi), %al
cmpb $0x1, 0x10(%rcx)
jne 0x2a3bd
leaq 0x30(%r14), %rcx
testb %al, %al
cmovneq %r14, %rcx
movq %rcx, 0x18(%rbx)
movl $0x60, %ecx
movl $0xf0, %eax
jmp 0x2a3df
leaq 0xc0(%r14), %rcx
leaq 0x90(%r14), %rdx
testb %al, %al
cmovneq %rdx, %rcx
movq %rcx, 0x18(%rbx)
movl $0xf0, %ecx
movl $0x60, %eax
cmovneq %rcx, %rax
addq %r14, %rax
movq %rax, 0x58(%rbx)
leaq 0x150(%r14), %rax
movq %rax, 0x60(%rbx)
leaq 0x118(%rbx), %rax
testq %r15, %r15
je 0x2a43d
movq 0xe(%r15), %rcx
movq %rcx, 0xe(%rax)
movups (%r15), %xmm0
movups %xmm0, (%rax)
leaq 0x130(%rbx), %rdi
leaq 0x18(%r15), %rsi
callq 0x2b430
leaq 0x150(%rbx), %rdi
leaq 0x38(%r15), %rsi
callq 0x2b4e0
movq 0x58(%r15), %rax
movq %rax, 0x170(%rbx)
jmp 0x2a443
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movb $0x0, 0x178(%rbx)
cmpl $-0x1, 0x118(%rbx)
je 0x2a4c0
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
testq %rax, %rax
je 0x2a4bc
xorl %ecx, %ecx
leaq 0x430c6(%rip), %rdx     # 0x6d550
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
addq 0x50(%rbx), %rdi
notq %r8
movb %sil, (%r8,%rdi)
incq %rcx
cmpq %rcx, %rax
jne 0x2a48a
movq %r15, 0x18(%rbx)
movw $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
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
cmpl $0x0, 0x80(%rdi)
sete %al
je 0x2b698
movq $-0x1, %r8
xorl %r9d, %r9d
movq 0x18(%rdi), %r10
movq 0x8(%r10), %r10
addq 0x50(%rdi), %r10
cmpb $0x4, (%r8,%r10)
jne 0x2b684
movl (%rsi), %r10d
leal 0x1(%r10), %r11d
movl %r11d, (%rsi)
cmpl $0x2, %r10d
je 0x2b67b
cmpl $0x1, %r10d
je 0x2b675
testl %r10d, %r10d
jne 0x2b6cb
movl 0x74(%rdi), %r10d
jmp 0x2b67f
movl 0x78(%rdi), %r10d
jmp 0x2b67f
movl 0x7c(%rdi), %r10d
cmpq %r10, %r9
jb 0x2b6cb
incq %r9
movl 0x80(%rdi), %eax
decq %r8
cmpq %rax, %r9
setae %al
jb 0x2b641
testl %ecx, %ecx
je 0x2b6cb
movq $-0x1, %rsi
xorl %r8d, %r8d
movq 0x50(%rdi), %r9
cmpq %r9, %r8
jae 0x2b6cb
movq 0x18(%rdi), %r10
addq 0x8(%r10), %r9
cmpb $0x4, (%rsi,%r9)
jne 0x2b6c0
incl (%rdx)
incq %r8
decq %rsi
cmpq %r8, %rcx
jne 0x2b6a6
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ba92
testb %al, %al
je 0x2b798
movl 0x5c(%rbx), %eax
incl %eax
cmpl 0x58(%rbx), %eax
jb 0x2b777
movq %rbx, %rdi
callq 0x2bb70
testb %al, %al
je 0x2b798
movl 0x5c(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x5c(%rbx)
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
movq %rax, %rsi
shlq $0x7, %rsi
leaq (%rsi,%rax,8), %rax
addq (%rdx,%rcx,8), %rax
jmp 0x2b79a
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bad0
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0x2bad0
movq (%rbx), %rdi
callq 0x2bc4a
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2badb
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2bdba
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x8, %edi
callq 0x9200
movq 0x3f49c(%rip), %rcx     # 0x6af88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3f4be(%rip), %rsi     # 0x6afb8
movq 0x3f467(%rip), %rdx     # 0x6af68
movq %rax, %rdi
callq 0x98f0
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2bb5f
movq %r14, %rdi
callq 0x91a0
leaq 0x426d8(%rip), %rdi     # 0x6e1f8
callq 0x4bff0
movq (%rbx), %rdi
callq 0x27a24
leaq 0x426c4(%rip), %rdi     # 0x6e1f8
callq 0x4c02c
callq 0x9840
xorl %ebp, %ebp
jmp 0x2bad0
jmp 0x2bb67
movq %rax, %r14
leaq 0x426aa(%rip), %rdi     # 0x6e1f8
callq 0x4c02c
jmp 0x2bb5a
jmp 0x2bb67
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/./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
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2bc4a
movq %rax, (%rsp)
testq %rax, %rax
je 0x2bbb5
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x2bdba
leaq 0x38(%rbx), %rdi
leaq 0x5c(%rbx), %rsi
callq 0x22e84
incl 0x30(%rbx)
movl $0x0, 0x5c(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x9200
movq 0x3f3c2(%rip), %rcx     # 0x6af88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3f3e4(%rip), %rsi     # 0x6afb8
movq 0x3f38d(%rip), %rdx     # 0x6af68
movq %rax, %rdi
callq 0x98f0
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2bc39
movq %r14, %rdi
callq 0x91a0
leaq 0x425fe(%rip), %rdi     # 0x6e1f8
callq 0x4bff0
movq (%rbx), %rdi
callq 0x27a24
leaq 0x425ea(%rip), %rdi     # 0x6e1f8
callq 0x4c02c
callq 0x9840
xorl %eax, %eax
jmp 0x2bbad
jmp 0x2bc41
movq %rax, %r14
leaq 0x425d0(%rip), %rdi     # 0x6e1f8
callq 0x4c02c
jmp 0x2bc34
jmp 0x2bc41
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/./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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %r14
movl 0x10(%rdi), %edx
movl 0x1c(%rdi), %esi
movq 0x30(%rdi), %rax
xorl %ebx, %ebx
movl %edx, %r15d
movl %r15d, %edi
shrl $0x5, %edi
movl (%rax,%rdi,4), %r8d
movl $0x1, %r9d
movl %r15d, %ecx
shll %cl, %r9d
btl %r15d, %r8d
jae 0x2bc9a
incl %r15d
cmpl %esi, %r15d
cmovael %ebx, %r15d
cmpl %edx, %r15d
jne 0x2bc6a
jmp 0x2bd5c
movl 0x14(%r14), %ebx
imull %r15d, %ebx
addq 0x8(%r14), %rbx
orl %r9d, %r8d
movl %r8d, (%rax,%rdi,4)
incl 0x24(%r14)
cmpl %r15d, 0x28(%r14)
ja 0x2bcbf
leal 0x1(%r15), %eax
movl %eax, 0x28(%r14)
cmpb $0x1, (%r14)
jne 0x2bd58
leaq 0x20(%rsp), %rdi
callq 0x9310
leaq 0x30(%rsp), %rdi
movl 0x4(%r14), %esi
callq 0x92e0
movq %rax, %r12
leaq 0x2ac44(%rip), %rsi     # 0x5692f
movl $0x20, %edx
movq %rax, %rdi
callq 0x9560
movl %r15d, %esi
movq %r12, %rdi
callq 0x92e0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x97e0
leaq 0x4290a(%rip), %rdi     # 0x6e621
movq %rsp, %rsi
callq 0x2be40
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bd3a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3f207(%rip), %rsi     # 0x6af48
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0xa0(%rsp), %rdi
callq 0x9180
movl %r15d, 0x10(%r14)
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bd93
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2bd93
jmp 0x2bd90
movq %rax, %rbx
movq 0x3f1ae(%rip), %rsi     # 0x6af48
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0xa0(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b2d0
movl %ebp, %ecx
subl %r13d, %ecx
movzwl 0x8(%r15), %eax
addl %ecx, %eax
cmpl %r12d, %eax
jae 0x2bff6
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)
movl $0x1, %edx
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 0x2bfe7
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 0x1b2d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c039
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movl (%r14), %ecx
movl %ecx, 0x8(%rbx,%rax,4)
jmp 0x2c09a
cmpq $0x6, %rax
jne 0x2c05c
movq %rdx, %rdi
movl $0x10, %esi
callq 0x2c3c4
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x2c088
movl (%r14), %ecx
movl %ecx, (%rax)
jmp 0x2c097
cmpq $0x15, %rax
ja 0x2c06f
movq 0x20(%rbx), %rcx
movl (%r14), %edx
movl %edx, -0x18(%rcx,%rax,4)
jmp 0x2c097
cmpq $0x16, %rax
jne 0x2c08c
addl $-0xc, %ecx
movq %rdx, %rdi
movl %ecx, %esi
callq 0x2c3c4
movq %rax, 0x28(%rbx)
jmp 0x2c050
xorl %eax, %eax
jmp 0x2c09c
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_O1/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2c0f2
testb %al, %al
je 0x2c0e8
movl 0x5c(%rbx), %eax
addl %ebp, %eax
cmpl 0x58(%rbx), %eax
jb 0x2c0cb
movq %rbx, %rdi
callq 0x2c1d0
testb %al, %al
je 0x2c0e8
movl 0x5c(%rbx), %eax
addl %eax, %ebp
movl %ebp, 0x5c(%rbx)
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq (%rdx,%rcx,8), %rax
jmp 0x2c0ea
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c878
leaq 0x30(%rsp), %rdi
callq 0x9310
leaq 0x40(%rsp), %rdi
movl 0x28(%rbx), %esi
callq 0x92e0
movq %rax, %r14
leaq 0x2a233(%rip), %rsi     # 0x56950
movl $0xa, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq %r14, %rdi
callq 0x92e0
movq %rax, %r14
leaq 0x277c3(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9390
movq %rax, %r14
leaq 0x2779f(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rsp), %rax
movzwl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x92e0
movq %rax, %r14
leaq 0x27777(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rsp), %rax
movzbl 0x83(%rax), %esi
movq %r14, %rdi
callq 0x9850
movq %rax, %r14
leaq 0x2774c(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rsp), %rax
movzbl 0x82(%rax), %esi
movq %r14, %rdi
callq 0x9850
movq %rax, %r14
leaq 0x27721(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
movq %r14, %rdi
callq 0x92e0
movq %rax, %r14
leaq 0x2a155(%rip), %rsi     # 0x5695b
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
incl %esi
movq %r14, %rdi
callq 0x92e0
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x97e0
leaq 0x41dec(%rip), %rdi     # 0x6e621
leaq 0x10(%rsp), %rsi
callq 0x2be40
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c85a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3e6e7(%rip), %rsi     # 0x6af48
leaq 0x30(%rsp), %rdi
callq 0x9340
leaq 0xb0(%rsp), %rdi
callq 0x9180
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2cac2
incl (%rbx)
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c8b8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2c8b8
jmp 0x2c8b5
movq %rax, %rbx
movq 0x3e689(%rip), %rsi     # 0x6af48
leaq 0x30(%rsp), %rdi
callq 0x9340
leaq 0xb0(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq 0x8(%rdi), %rax
movq (%rax), %rbx
cmpb $0x1, 0x2c(%rdi)
jne 0x2ca67
movq %rdi, %r14
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movl 0x28(%r14), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x2a058(%rip), %rsi     # 0x56978
movl $0xb, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x275c5(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9390
movq %rax, %r15
leaq 0x275a3(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzwl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x27580(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x83(%rbx), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x2755a(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x82(%rbx), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x27534(%rip), %rsi     # 0x53f06
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x29f67(%rip), %rsi     # 0x5695b
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%r14), %esi
decl %esi
movq %r15, %rdi
callq 0x92e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x41bfd(%rip), %rdi     # 0x6e621
leaq 0x8(%rsp), %rsi
callq 0x2be40
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ca49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3e4f8(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ca9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2ca9c
jmp 0x2ca99
movq %rax, %rbx
movq 0x3e4a5(%rip), %rsi     # 0x6af48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ccb3
movb 0x83(%rsi), %cl
cmpb $0x0, 0x82(%rdx)
jne 0x2ccc2
movb 0x83(%rdx), %al
movzwl 0x10(%rsi), %edi
movzwl 0x10(%rdx), %r8d
cmpw %r8w, %di
jne 0x2cd07
movl %eax, %edi
notb %dil
orb %cl, %dil
testb $0x1, %dil
je 0x2cd0b
notb %cl
orb %al, %cl
movb $0x1, %al
testb $0x1, %cl
je 0x2cd06
movzwl 0xe(%rsi), %eax
addw 0xc(%rsi), %ax
movzwl 0xe(%rdx), %ecx
addw 0xc(%rdx), %cx
cmpw %cx, %ax
jne 0x2cd03
movl (%rdx), %eax
cmpl (%rsi), %eax
setb %al
retq
seta %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2dd24
cmpb $0x1, 0x83(%r14)
jne 0x2d4a2
movq %rbx, %rdi
callq 0x2e35a
movq %rbx, %rdi
callq 0x2c8de
movzwl 0x10(%rax), %eax
movw %ax, 0x158(%rbx)
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 0x2de90
cmpw %r12w, 0x10(%r14)
je 0x2d4e5
movq %rbx, %rdi
callq 0x2e35a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c8de
movzwl 0x10(%rax), %eax
movw %ax, 0x158(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c6e0
movq %rbx, %rdi
callq 0x2c8de
movzwl 0x10(%rax), %eax
movw %ax, 0x158(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq