LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ref_aligner.h
// Function: RefAligner::newBuf(unsigned int)
void newBuf(uint32_t newsz) {
		if(freeRefbuf_) {
			delete[] refbuf_;
		}
		try {
			refbuf_ = new uint32_t[(newsz + 3) / 4];
			if(refbuf_ == NULL) throw std::bad_alloc();
		} catch(std::bad_alloc& e) {
			cerr << "Error: Could not allocate reference-space alignment buffer of " << newsz << "B" << endl;
			throw 1;
		}
		refbufSz_ = newsz;
		freeRefbuf_ = true;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x1, 0x4024(%rdi)
jne 0x2e632
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x2e632
callq 0x9610
leal 0x3(%rbx), %edi
andl $-0x4, %edi
callq 0x9030
movq %rax, 0x18(%r14)
movl %ebx, 0x20(%r14)
movb $0x1, 0x4024(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2e6c0
movq %r14, %rdi
callq 0x91a0
movq 0x33984(%rip), %rdi     # 0x61ff0
leaq 0x1c548(%rip), %rsi     # 0x4abbb
callq 0x94e0
movl %ebx, %esi
movq %rax, %rdi
callq 0x9310
leaq 0x1c571(%rip), %rsi     # 0x4abfa
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
pushq $0x4
popq %rdi
callq 0x9220
movl $0x1, (%rax)
movq 0x338aa(%rip), %rsi     # 0x61f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x9910
movq %rax, %r14
callq 0x9860
movq %r14, %rdi
callq 0x9950
movq %rax, %rdi
callq 0x15e2d
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV1<EbwtRangeSource>::~PairedBWAlignerV1()
virtual ~PairedBWAlignerV1() {
		delete driver1Fw_; driver1Fw_ = NULL;
		delete driver1Rc_; driver1Rc_ = NULL;
		delete driver2Fw_; driver2Fw_ = NULL;
		delete driver2Rc_; driver2Rc_ = NULL;
		delete params_;    params_    = NULL;
		delete rchase_;    rchase_    = NULL;
		delete[] btCnt_;   btCnt_     = NULL;
		delete refAligner_; refAligner_ = NULL;
		sinkPtFactory_.destroy(sinkPt_); sinkPt_ = NULL;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2f4ed(%rip), %rax     # 0x61418
movq %rax, (%rdi)
movq 0xd8(%rdi), %rdi
testq %rdi, %rdi
je 0x31f40
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xd8(%rbx)
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x31f5a
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xe0(%rbx)
movq 0x10f8(%rbx), %rdi
testq %rdi, %rdi
je 0x31f74
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x10f8(%rbx)
movq 0x1100(%rbx), %rdi
testq %rdi, %rdi
je 0x31f8e
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x1100(%rbx)
movq 0x90(%rbx), %rdi
pushq $0x18
popq %rsi
callq 0x9510
andq $0x0, 0x90(%rbx)
movq 0xb8(%rbx), %rdi
movl $0xc8, %esi
callq 0x9510
andq $0x0, 0xb8(%rbx)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x31fd7
callq 0x9610
andq $0x0, 0xd0(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x31fee
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x78(%rbx)
movq 0x80(%rbx), %rdi
movq 0x88(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
andq $0x0, 0x88(%rbx)
leaq 0x2278(%rbx), %rdi
callq 0x32534
leaq 0x2248(%rbx), %rdi
callq 0x32534
leaq 0x20f0(%rbx), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x2ee06
addq $-0x20, %r15
cmpq $-0x400, %r15           # imm = 0xFC00
jne 0x32031
leaq 0x1cf0(%rbx), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x32510
addq $-0x20, %r15
cmpq $-0x400, %r15           # imm = 0xFC00
jne 0x32051
leaq 0x18e8(%rbx), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x2ee06
addq $-0x20, %r15
cmpq $-0x400, %r15           # imm = 0xFC00
jne 0x32071
leaq 0x14e8(%rbx), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x32510
addq $-0x20, %r15
cmpq $-0x400, %r15           # imm = 0xFC00
jne 0x32091
leaq 0x10d0(%rbx), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x2ee06
addq $-0x20, %r15
cmpq $-0x400, %r15           # imm = 0xFC00
jne 0x320b1
leaq 0xcd0(%rbx), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x32510
addq $-0x20, %r15
cmpq $-0x400, %r15           # imm = 0xFC00
jne 0x320d1
movl $0x8c8, %r14d           # imm = 0x8C8
leaq (%rbx,%r14), %rdi
callq 0x2ee06
addq $-0x20, %r14
cmpq $0x4c8, %r14            # imm = 0x4C8
jne 0x320ed
movl $0x4c8, %r14d           # imm = 0x4C8
leaq (%rbx,%r14), %rdi
callq 0x32510
addq $-0x20, %r14
cmpq $0xc8, %r14
jne 0x32109
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x15e2d
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV1<EbwtRangeSource>::advance()
virtual bool advance() {
		assert(!this->done);
		if(doneFw_ && doneFwFirst_) {
			if(verbose2_) cout << "--" << endl;
			chaseL_        = &chaseL_rc_;
			chaseR_        = &chaseR_rc_;
			delayedchaseL_ = &delayedchaseL_rc_;
			delayedchaseR_ = &delayedchaseR_rc_;
			drL_           = &drL_rc_;
			drR_           = &drR_rc_;
			offsLarr_      = offsLarr_rc_;
			offsRarr_      = offsRarr_rc_;
			rangesLarr_    = rangesLarr_rc_;
			rangesRarr_    = rangesRarr_rc_;
			offsLsz_       = &offsLsz_rc_;
			offsRsz_       = &offsRsz_rc_;
			donePair_      = &this->done;
			fwL_           = !fw2_;
			fwR_           = !fw1_;
			doneFwFirst_   = false;
			mixedAttempts_ = 0;
		}
		bool chasing = *chaseL_ || *chaseR_;
		if(chasing && !rchase_->foundOff() && !rchase_->done) {
			rchase_->advance();
			return false;
		}
		advanceOrientation(!doneFw_);
		if(this->done) {
			if(verbose2_) cout << "----" << endl;
			sinkPt_->finishRead(*patsrc_, true, true);
		}
		return this->done;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x68(%rdi)
jne 0x32209
cmpb $0x1, 0x69(%rbx)
jne 0x32209
cmpb $0x1, 0x22a8(%rbx)
jne 0x32182
movq 0x2fe42(%rip), %rdi     # 0x61fb0
leaq 0x18ab1(%rip), %rsi     # 0x4ac26
callq 0x94e0
movq %rax, %rdi
callq 0x9210
movups 0x2178(%rbx), %xmm0
movups %xmm0, 0x21d8(%rbx)
movups 0x2188(%rbx), %xmm0
movups %xmm0, 0x21e8(%rbx)
movups 0x2198(%rbx), %xmm0
movups %xmm0, 0x21f8(%rbx)
movups 0x21a8(%rbx), %xmm0
movups %xmm0, 0x2208(%rbx)
movups 0x21b8(%rbx), %xmm0
movups %xmm0, 0x2218(%rbx)
movups 0x21c8(%rbx), %xmm0
movups %xmm0, 0x2228(%rbx)
leaq 0x8(%rbx), %rax
movq %rax, 0x2238(%rbx)
movb 0xb4(%rbx), %al
movb 0xb5(%rbx), %cl
xorb $0x1, %cl
movb %cl, 0x2240(%rbx)
xorb $0x1, %al
movb %al, 0x2241(%rbx)
movb $0x0, 0x69(%rbx)
andl $0x0, 0xb0(%rbx)
movq 0x21d8(%rbx), %rax
cmpb $0x0, (%rax)
jne 0x32221
movq 0x21e0(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x32233
movq 0xb8(%rbx), %rdi
cmpl $-0x1, 0x28(%rdi)
jne 0x32233
cmpb $0x0, (%rdi)
je 0x32287
movzbl 0x68(%rbx), %esi
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x3258c
cmpb $0x1, 0x8(%rbx)
jne 0x3228c
cmpb $0x1, 0x22a8(%rbx)
jne 0x3226c
movq 0x2fd58(%rip), %rdi     # 0x61fb0
leaq 0x189c5(%rip), %rsi     # 0x4ac24
callq 0x94e0
movq %rax, %rdi
callq 0x9210
movq 0x58(%rbx), %rsi
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rcx
movl %ecx, %edx
callq *0x10(%rax)
movb 0x8(%rbx), %al
jmp 0x3228e
callq 0x281ee
xorl %eax, %eax
andb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV2<EbwtRangeSource>::~PairedBWAlignerV2()
virtual ~PairedBWAlignerV2() {
		delete driver_; driver_ = NULL;
		delete params_; params_ = NULL;
		if(paramsSe1_ != NULL) {
			delete paramsSe1_; paramsSe1_ = NULL;
			delete paramsSe2_; paramsSe2_ = NULL;
		}
		delete rchase_; rchase_ = NULL;
		delete[] btCnt_; btCnt_ = NULL;
		delete refAligner_; refAligner_ = NULL;
		sinkPtFactory_.destroy(sinkPt_); sinkPt_ = NULL;
		if(sinkPtSe1_ != NULL) {
			sinkPtFactory_.destroy(sinkPtSe1_); sinkPtSe1_ = NULL;
			sinkPtFactory_.destroy(sinkPtSe2_); sinkPtSe2_ = NULL;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2df78(%rip), %rax     # 0x61460
movq %rax, (%rdi)
movq 0xd0(%rdi), %rdi
testq %rdi, %rdi
je 0x334fd
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0xd0(%rbx)
movq 0x98(%rbx), %rdi
pushq $0x18
popq %rsi
callq 0x9510
andq $0x0, 0x98(%rbx)
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x33553
pushq $0x18
popq %r14
movq %r14, %rsi
callq 0x9510
andq $0x0, 0xa0(%rbx)
movq 0xa8(%rbx), %rdi
movq %r14, %rsi
callq 0x9510
andq $0x0, 0xa8(%rbx)
movq 0xc8(%rbx), %rdi
movl $0xc8, %esi
callq 0x9510
andq $0x0, 0xc8(%rbx)
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x3357d
callq 0x9610
andq $0x0, 0xe8(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x33594
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x70(%rbx)
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
andq $0x0, 0x80(%rbx)
movq 0x88(%rbx), %rsi
testq %rsi, %rsi
je 0x335e9
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andq $0x0, 0x88(%rbx)
movq 0x78(%rbx), %rdi
movq 0x90(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
andq $0x0, 0x90(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x32534
addq $0xf0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32534
movq %rax, %rdi
callq 0x15e2d
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV2<EbwtRangeSource>::setQuery(PatternSourcePerThread*)
virtual void setQuery(PatternSourcePerThread* patsrc) {
		Aligner::setQuery(patsrc); // set fields & random seed
		assert(!patsrc->bufb().empty());
		// Give all of the drivers pointers to the relevant read info
		patsrc_ = patsrc;
		pool_->reset(&patsrc->bufa().name, (uint32_t)patsrc->rdid());
		if(patsrc->bufa().length() < 4 || patsrc->bufb().length() < 4) {
			if(!quiet_) {
				cerr << "Warning: Skipping pair " << patsrc->bufa().name
				     << " because a mate is less than 4 characters long" << endl;
			}
			this->done = true;
			sinkPt_->finishRead(*patsrc_, true, true);
			return;
		}
		driver_->setQuery(patsrc, NULL);
		qlen1_ = patsrc_->bufa().length();
		qlen2_ = patsrc_->bufb().length();
		if(btCnt_ != NULL) (*btCnt_) = maxBts_;
		mixedAttempts_ = 0;
		// Neither orientation is done
		this->done = false;
		// No ranges are being chased yet
		chase_ = false;
		donePe_ = doneSe1_ = doneSe2_ = false;
		pairs_fw_.clear();
		pairs_rc_.clear();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x28196
movq %r14, 0x58(%rbx)
movq 0xd8(%rbx), %rdi
movq 0x18(%r14), %rax
movq 0x50(%r14), %rdx
imulq $0x268, %rdx, %rcx      # imm = 0x268
leaq (%rax,%rcx), %rsi
addq $0x150, %rsi            # imm = 0x150
addl 0x58(%r14), %edx
callq 0x296ac
movq 0x18(%r14), %rcx
imulq $0x268, 0x50(%r14), %rax # imm = 0x268
cmpq $0x4, 0x20(%rcx,%rax)
jb 0x33943
movq 0x38(%r14), %rcx
cmpq $0x3, 0x20(%rcx,%rax)
ja 0x339b9
cmpb $0x0, 0xe1(%rbx)
jne 0x33995
movq 0x2e69d(%rip), %rdi     # 0x61ff0
leaq 0x17441(%rip), %rsi     # 0x4ad9b
callq 0x94e0
movq 0x18(%r14), %rcx
imulq $0x268, 0x50(%r14), %rdx # imm = 0x268
leaq (%rcx,%rdx), %rsi
addq $0x150, %rsi            # imm = 0x150
movq %rax, %rdi
callq 0x1970d
leaq 0x1742e(%rip), %rsi     # 0x4adb3
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
movb $0x1, 0x8(%rbx)
movq 0x58(%rbx), %rsi
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
pushq $0x1
popq %rcx
movl %ecx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0xd0(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
xorl %edx, %edx
callq *0x10(%rax)
movq 0x58(%rbx), %rcx
movq 0xe8(%rbx), %rax
movq 0x18(%rcx), %rdx
imulq $0x268, 0x50(%rcx), %rsi # imm = 0x268
movl 0x20(%rdx,%rsi), %edx
movl %edx, 0x60(%rbx)
imulq $0x268, 0x50(%rcx), %rdx # imm = 0x268
movq 0x38(%rcx), %rcx
movl 0x20(%rcx,%rdx), %ecx
movl %ecx, 0x64(%rbx)
testq %rax, %rax
je 0x33a09
movl 0xe4(%rbx), %ecx
movl %ecx, (%rax)
andl $0x0, 0xbc(%rbx)
movb $0x0, 0x8(%rbx)
leaq 0xf0(%rbx), %rdi
andl $0x0, 0x68(%rbx)
callq 0x334ac
addq $0x120, %rbx            # imm = 0x120
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x334ac
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./aligner.h
// Function: PairedBWAlignerV2<EbwtRangeSource>::resolveOutstanding(std::pair<unsigned int, unsigned int> const&, unsigned int, Range const&)
void resolveOutstanding(const UPair& off,
	                        const TIndexOffU tlen,
	                        const Range& range)
	{
		assert(!this->done);
		if(!donePe_) {
			bool ret = resolveOutstandingInRef(off, tlen, range);
			if(++mixedAttempts_ > mixedAttemptLim_ || ret) {
				// Give up on this pair
				donePe_ = true;
				if(sinkPtSe1_ != NULL) {
					if(doneSe1_) driver_->removeMate(1);
					if(doneSe2_) driver_->removeMate(2);
				}
			}
			this->done = (donePe_ && (!sinkPt_->empty() || sinkPtSe1_ == NULL || (doneSe1_ && doneSe2_)));
		}
		if(!this->done && sinkPtSe1_ != NULL) {
			bool doneSe = (range.mate1 ? doneSe1_ : doneSe2_);
			if(!doneSe) {
				// Hold onto this single-end alignment in case we don't
				// find any paired alignments
				reportSe(range, off, tlen);
			}
			this->done = doneSe1_ && doneSe2_ && donePe_;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movb 0x69(%rdi), %al
cmpb $0x1, %al
jne 0x33a5b
movb 0x8(%rbx), %cl
jmp 0x33af2
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x33b4e
movl 0xb8(%rbx), %ecx
movl 0xbc(%rbx), %edx
incl %edx
movl %edx, 0xbc(%rbx)
testb %al, %al
jne 0x33a87
cmpl %ecx, %edx
jbe 0x33ac1
movb $0x1, 0x69(%rbx)
cmpq $0x0, 0x88(%rbx)
je 0x33ac1
cmpb $0x1, 0x6a(%rbx)
jne 0x33aab
movq 0xd0(%rbx), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rsi
callq *0x48(%rax)
cmpb $0x1, 0x6b(%rbx)
jne 0x33ac1
movq 0xd0(%rbx), %rdi
movq (%rdi), %rax
pushq $0x2
popq %rsi
callq *0x48(%rax)
movb 0x69(%rbx), %al
cmpb $0x1, %al
jne 0x33aed
movq 0x80(%rbx), %rcx
cmpq $0x0, 0x58(%rcx)
movb $0x1, %cl
jne 0x33aef
cmpq $0x0, 0x88(%rbx)
je 0x33aef
cmpb $0x1, 0x6a(%rbx)
jne 0x33aed
movb 0x6b(%rbx), %cl
jmp 0x33aef
xorl %ecx, %ecx
movb %cl, 0x8(%rbx)
testb $0x1, %cl
jne 0x33b42
cmpq $0x0, 0x88(%rbx)
je 0x33b42
movzbl 0x6a(%rbx), %edx
movzbl 0x6b(%rbx), %ecx
cmpb $0x0, 0x15(%r14)
movl %ecx, %esi
cmovnel %edx, %esi
testb $0x1, %sil
jne 0x33b32
movq (%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x33f62
movb 0x69(%rbx), %al
movb 0x6a(%rbx), %dl
movb 0x6b(%rbx), %cl
andb %dl, %cl
movzbl %al, %eax
xorl %edx, %edx
testb $0x1, %cl
cmovnel %eax, %edx
movb %dl, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_util.h
// Function: PartialAlignmentManager::getPartialsUnsync(unsigned int, EList<PartialAlignment, 128>&)
void getPartialsUnsync(uint32_t patid, EList<PartialAlignment>& ps) {
		assert_eq(0, ps.size());
		if(_partialsMap.find(patid) == _partialsMap.end()) {
			return;
		}
		PartialAlignment al;
		al.u64.u64 = _partialsMap[patid].u64.u64;
		uint32_t type = al.unk.type;
		if(type == 0) {
			// singleton
			ps.push_back(al);
		} else {
			// list
			assert_eq(1, type);
			uint32_t off = (uint32_t)al.off.off;
			do {
				assert_lt(off, _partialsList.size());
				ASSERT_ONLY(type = _partialsList[off].entry.type);
				assert(type == 2 || type == 3);
#ifndef NDEBUG
				// Make sure this entry isn't equal to any other entry
				for(size_t i = 0; i < ps.size(); i++) {
					assert(validPartialAlignment(ps[i]));
					assert(!samePartialAlignment(ps[i], _partialsList[off]));
				}
#endif
				assert(validPartialAlignment(_partialsList[off]));
				ps.push_back(_partialsList[off]);
				ASSERT_ONLY(uint32_t pos0 = ps.back().entry.pos0);
				ASSERT_ONLY(uint32_t pos1 = ps.back().entry.pos1);
				ASSERT_ONLY(uint32_t pos2 = ps.back().entry.pos2);
				assert(pos1 == 0xffff || pos0 != pos1);
				assert(pos2 == 0xffff || pos0 != pos2);
				assert(pos2 == 0xffff || pos1 != pos2);
			} while(_partialsList[off++].entry.type == 2);
			assert_eq(3, _partialsList[off-1].entry.type);
		}
		assert_gt(ps.size(), 0);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x3732c
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x34a13
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x37070
movq (%rax), %r15
movq %r15, 0x10(%rsp)
movq %r15, %rax
shrq $0x3e, %rax
jne 0x349ec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x366e2
jmp 0x34a13
movq 0x38(%r14), %rax
movl %r15d, %r12d
leaq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x366e2
incl %r15d
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rcx
shrq $0x3e, %rcx
cmpl $0x2, %ecx
je 0x349f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::setMuts(EList<QueryMutation, 128>*)
void setMuts(EList<QueryMutation>* muts) {
		if(_muts != NULL) {
			// Undo previous mutations
			assert_gt(_muts->size(), 0);
			undoPartialMutations();
		}
		_muts = muts;
		if(_muts != NULL) {
			assert_gt(_muts->size(), 0);
			applyPartialMutations();
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0xb0(%rdi)
je 0x34bf0
movq %rbx, %rdi
callq 0x36794
movq %r14, 0xb0(%rbx)
testq %r14, %r14
je 0x34c0b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36a1a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::tallyNs(int&, int&)
bool tallyNs(int& nsInSeed, int& nsInFtab) {
		const Ebwt& ebwt = *_ebwt;
		int ftabChars = ebwt._eh._ftabChars;
		// Count Ns in the seed region of the read and short-circuit if
		// the configuration of Ns guarantees that there will be no
		// valid alignments given the backtracking constraints.
		for(size_t i = 0; i < _3revOff; i++) {
			if((int)(*_qry)[_qlen-i-1] == 4) {
				nsInSeed++;
				if(nsInSeed == 1) {
					if(i < _unrevOff) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else if(nsInSeed == 2) {
					if(i < _1revOff) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else if(nsInSeed == 3) {
					if(i < _2revOff) {
						return false; // Exceeded mm budget on Ns alone
					}
				} else {
					assert_gt(nsInSeed, 3);
					return false;     // Exceeded mm budget on Ns alone
				}
			}
		}
		// Calculate the number of Ns there are in the region that
		// would get jumped over if the ftab were used.
		for(size_t i = 0; i < (size_t)ftabChars && i < _qlen; i++) {
			if((int)(*_qry)[_qlen-i-1] == 4) nsInFtab++;
		}
		return true;
	}

// Assembly:
movq 0x20(%rdi), %rax
movslq 0x124(%rax), %rax
pushq $-0x1
popq %r9
xorl %ecx, %ecx
movl 0x3c(%rdi), %r8d
cmpq %r8, %rcx
jae 0x34e46
movq (%rdi), %r10
movq 0x8(%r10), %r10
addq 0x8(%rdi), %r10
cmpb $0x4, (%r9,%r10)
jne 0x34e3e
movl (%rsi), %r10d
leal 0x1(%r10), %r11d
movl %r11d, (%rsi)
cmpl $0x2, %r10d
je 0x34e35
cmpl $0x1, %r10d
je 0x34e2f
testl %r10d, %r10d
jne 0x34e72
movl 0x30(%rdi), %r10d
jmp 0x34e39
movl 0x34(%rdi), %r10d
jmp 0x34e39
movl 0x38(%rdi), %r10d
cmpq %r10, %rcx
jb 0x34e72
incq %rcx
decq %r9
jmp 0x34df3
pushq $-0x1
popq %rsi
xorl %r9d, %r9d
cmpq %r9, %rax
je 0x34e72
movq 0x8(%rdi), %r10
cmpq %r10, %r9
jae 0x34e72
movq (%rdi), %r11
addq 0x8(%r11), %r10
cmpb $0x4, (%rsi,%r10)
jne 0x34e6a
incl (%rdx)
incq %r9
decq %rsi
jmp 0x34e4c
cmpq %r8, %rcx
setae %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::calcFtabOff()
uint32_t calcFtabOff() {
		const Ebwt& ebwt = *_ebwt;
		int ftabChars = ebwt._eh._ftabChars;
		uint32_t ftabOff = (*_qry)[_qlen - ftabChars];
		assert_lt(ftabOff, 4);
		assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		for(int i = ftabChars - 1; i > 0; i--) {
			ftabOff <<= 2;
			assert_lt((uint32_t)(*_qry)[_qlen-i], 4);
			ftabOff |= (uint32_t)(*_qry)[_qlen-i];
			assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		}
		assert_lt(ftabOff, ebwt._eh._ftabLen-1);
		return ftabOff;
	}

// Assembly:
movq 0x20(%rdi), %rax
movl 0x124(%rax), %ecx
movq (%rdi), %rax
movq 0x8(%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 0x34eb9
shll $0x2, %eax
movsbl (%rdx), %esi
orl %esi, %eax
decl %ecx
incq %rdx
jmp 0x34ea5
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::calcStratum(EList<unsigned int, 128> const&, unsigned int)
int calcStratum(const EList<TIndexOffU>& mms, uint32_t stackDepth) {
		int stratum = 0;
		for(size_t i = 0; i < stackDepth; i++) {
			if(mms[i] >= (_qlen - _3revOff)) {
				// This mismatch falls within the seed; count it
				// toward the stratum to report
				stratum++;
				// Don't currently support more than 3
				// mismatches in the seed
				assert_leq(stratum, 3);
			}
		}
		return stratum;
	}

// Assembly:
movl %edx, %ecx
movq 0x8(%rsi), %rdx
movq 0x8(%rdi), %rsi
movl 0x3c(%rdi), %eax
subq %rax, %rsi
xorl %eax, %eax
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x36792
movl (%rdx,%rdi,4), %r8d
cmpq %rsi, %r8
sbbl $-0x1, %eax
incq %rdi
jmp 0x3677e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::undoPartialMutations()
void undoPartialMutations() {
		if(_muts == NULL) {
			// No mutations to undo
			return;
		}
		for(size_t i = 0; i < _muts->size(); i++) {
			const QueryMutation& m = (*_muts)[i];
			assert_lt(m.pos, _qlen);
			assert_leq(m.oldBase, 4);
			assert_lt(m.newBase, 4);
			assert_neq(m.oldBase, m.newBase);
			assert_eq((uint32_t)((*_qry)[m.pos]), (uint32_t)m.newBase);
			(*_qry)[m.pos] = (char)m.oldBase; // undo it
		}
	}

// Assembly:
movq 0xb0(%rdi), %rcx
testq %rcx, %rcx
je 0x367ca
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x367ca
movq 0x8(%rcx), %rcx
movb 0x2(%rcx,%rax,4), %dl
movq (%rdi), %rsi
movzwl (%rcx,%rax,4), %ecx
movq 0x8(%rsi), %rsi
movb %dl, (%rsi,%rcx)
incq %rax
movq 0xb0(%rdi), %rcx
jmp 0x367a2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::promotePartialMutations(int)
void promotePartialMutations(int stackDepth) {
		if(_muts == NULL) {
			// No mutations to undo
			return;
		}
		size_t numMuts = _muts->size();
		assert_leq(numMuts, _qlen);
		for(size_t i = 0; i < numMuts; i++) {
			// Entries in _mms[] are in terms of offset into
			// _qry - not in terms of offset from 3' or 5' end
			assert_lt(stackDepth + i, _qlen);
			// All partial-alignment mutations should fall
			// within bounds
			assert_lt((*_muts)[i].pos, _qlen);
			// All partial-alignment mutations should fall
			// within unrevisitable region
			assert_lt(_qlen - (*_muts)[i].pos - 1, _unrevOff);
#ifndef NDEBUG
			// Shouldn't be any overlap between mismatched positions
			// and positions that mismatched in the partial alignment.
			for(size_t j = 0; j < stackDepth + i; j++) {
				assert_neq(_mms[j], (uint32_t)(*_muts)[i].pos);
			}
#endif
			if(_mms.size() <= stackDepth + i) {
				assert_eq(_mms.size(), stackDepth + i);
				_mms.push_back((*_muts)[i].pos);
			} else {
				_mms[stackDepth + i] = (*_muts)[i].pos;
			}
			if(_refcs.size() <= stackDepth + i) {
				assert_eq(_refcs.size(), stackDepth + i);
				_refcs.push_back("ACGT"[(*_muts)[i].newBase]);
			} else {
				_refcs[stackDepth + i] = "ACGT"[(*_muts)[i].newBase];
			}
		}
	}

// Assembly:
movq 0xb0(%rdi), %rax
testq %rax, %rax
je 0x368de
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rax), %rbp
movslq %esi, %r12
leaq 0x58(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x78(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq (,%r12,4), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0x10ca3(%rip), %r15     # 0x474c0
cmpq %r14, %rbp
je 0x368d0
leaq (%r12,%r14), %r13
cmpq %r13, 0x70(%rbx)
jbe 0x3684f
movq 0xb0(%rbx), %rax
movq 0x8(%rax), %rax
movzwl (%rax,%r14,4), %eax
movq 0x60(%rbx), %rcx
addq 0x10(%rsp), %rcx
movl %eax, (%rcx,%r14,4)
jmp 0x36872
movq 0xb0(%rbx), %rax
movq 0x8(%rax), %rax
movzwl (%rax,%r14,4), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1bf46
cmpq %r13, 0x90(%rbx)
jbe 0x368a0
movq 0xb0(%rbx), %rax
movq 0x8(%rax), %rax
movzbl 0x3(%rax,%r14,4), %eax
movb (%rax,%r15), %al
movq 0x80(%rbx), %rcx
addq %r12, %rcx
movb %al, (%r14,%rcx)
jmp 0x368c8
movq 0xb0(%rbx), %rax
movq 0x8(%rax), %rax
movzbl 0x3(%rax,%r14,4), %eax
movb (%rax,%r15), %al
movb %al, 0xb(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xb(%rsp), %rsi
callq 0x233ce
incq %r14
jmp 0x3681d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: GreedyDFSRangeSource::applyPartialMutations()
void applyPartialMutations() {
		if(_muts == NULL) {
			// No mutations to apply
			return;
		}
		for(size_t i = 0; i < _muts->size(); i++) {
			const QueryMutation& m = (*_muts)[i];
			assert_lt(m.pos, _qlen);
			assert_leq(m.oldBase, 4);
			assert_lt(m.newBase, 4);
			assert_neq(m.oldBase, m.newBase);
			assert_eq((uint32_t)((*_qry)[m.pos]), (uint32_t)m.oldBase);
			(*_qry)[m.pos] = (char)m.newBase; // apply it
		}
	}

// Assembly:
movq 0xb0(%rdi), %rcx
testq %rcx, %rcx
je 0x36a50
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x36a50
movq 0x8(%rcx), %rcx
movb 0x3(%rcx,%rax,4), %dl
movq (%rdi), %rsi
movzwl (%rcx,%rax,4), %ecx
movq 0x8(%rsi), %rsi
movb %dl, (%rsi,%rcx)
incq %rax
movq 0xb0(%rdi), %rcx
jmp 0x36a28
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: PatternSourcePerThread::finalize(Read&)
void PatternSourcePerThread::finalize(Read& ra) {
	ra.mate = 0;
	ra.constructRevComps();
	ra.constructReverses();
	ra.seed = genRandSeed(ra.patFw, ra.qual, ra.name, seed_);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0x188(%rsi)
movq %rsi, %rdi
callq 0x43664
movq %rbx, %rdi
callq 0x43670
leaq 0x60(%rbx), %rsi
leaq 0x150(%rbx), %rdx
movl 0x74(%r14), %ecx
movq %rbx, %rdi
callq 0x40f36
movl %eax, 0x18c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: genRandSeed(SDnaStringExpandable<25, 2> const&, SStringExpandable<char, 25, 2, 0> const&, SStringExpandable<char, 25, 2, 0> const&, unsigned int)
static uint32_t genRandSeed(
	const BTDnaString& qry,
	const BTString& qual,
	const BTString& name,
	uint32_t seed)
{
	// Calculate a per-read random seed based on a combination of
	// the read data (incl. sequence, name, quals) and the global
	// seed
	uint32_t rseed = (seed + 101) * 59 * 61 * 67 * 71 * 73 * 79 * 83;
	size_t qlen = qry.length();
	// Throw all the characters of the read into the random seed
	for(size_t i = 0; i < qlen; i++) {
		int p = (int)qry[i];
		assert_leq(p, 4);
		size_t off = ((i & 15) << 1);
		rseed ^= (p << off);
	}
	// Throw all the quality values for the read into the random
	// seed
	for(size_t i = 0; i < qlen; i++) {
		int p = (int)qual[i];
		assert_leq(p, 255);
		size_t off = ((i & 3) << 3);
		rseed ^= (p << off);
	}
	// Throw all the characters in the read name into the random
	// seed
	size_t namelen = name.length();
	for(size_t i = 0; i < namelen; i++) {
		int p = (int)name[i];
		assert_leq(p, 255);
		size_t off = ((i & 3) << 3);
		rseed ^= (p << off);
	}
	return rseed;
}

// Assembly:
imull $0x568fae7, %ecx, %eax  # imm = 0x568FAE7
addl $0x226afd23, %eax       # imm = 0x226AFD23
movq 0x8(%rdi), %r8
movq 0x20(%rdi), %rdi
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %r10, %rdi
je 0x40f6e
movsbl (%r8,%r10), %r11d
movl %r9d, %ecx
andb $0x1e, %cl
shll %cl, %r11d
xorl %r11d, %eax
incq %r10
addl $0x2, %r9d
jmp 0x40f4f
movq 0x8(%rsi), %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %r9, %rdi
je 0x40f97
movsbl (%rsi,%r9), %r10d
movl %r8d, %ecx
andb $0x18, %cl
shll %cl, %r10d
xorl %r10d, %eax
incq %r9
addl $0x8, %r8d
jmp 0x40f78
movq 0x8(%rdx), %rsi
movq 0x20(%rdx), %rdx
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x40fc1
movsbl (%rsi,%r8), %r9d
movl %edi, %ecx
andb $0x18, %cl
shll %cl, %r9d
xorl %r9d, %eax
incq %r8
addl $0x8, %edi
jmp 0x40fa4
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: PatternSourcePerThread::finalizePair(Read&, Read&)
void PatternSourcePerThread::finalizePair(Read& ra, Read& rb) {
	ra.mate = 1;
	ra.constructRevComps();
	ra.constructReverses();
	ra.fixMateName(1);
	ra.seed = genRandSeed(ra.patFw, ra.qual, ra.name, seed_);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, 0x188(%rsi)
movq %rsi, %rdi
callq 0x43664
movq %r12, %rdi
callq 0x43670
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x436a8
leaq 0x60(%r12), %rsi
movl $0x150, %r15d           # imm = 0x150
leaq (%r12,%r15), %rdx
movl 0x74(%r14), %ecx
movq %r12, %rdi
callq 0x40f36
movl %eax, 0x18c(%r12)
movl $0x2, 0x188(%rbx)
movq %rbx, %rdi
callq 0x43664
movq %rbx, %rdi
callq 0x43670
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x436a8
leaq 0x60(%rbx), %rsi
addq %rbx, %r15
movl 0x74(%r14), %ecx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x40f36
movl %eax, 0x18c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: PatternSourcePerThread::nextReadPair()
pair<bool, bool> PatternSourcePerThread::nextReadPair() {
	// Prepare batch
	if(buf_.exhausted()) {
		pair<bool, int> res = nextBatch();
		if(res.first && res.second == 0) {
			return make_pair(false, true);
		}
		last_batch_ = res.first;
		last_batch_size_ = res.second;
		assert_eq(0, buf_.cur_buf_);
	} else {
		buf_.next(); // advance cursor
		assert_gt(buf_.cur_buf_, 0);
	}
	bool this_is_last = buf_.cur_buf_ == last_batch_size_-1;
	if(buf_.rdid() < skip_) {
		return make_pair(false, this_is_last ? last_batch_ : false);
	}
	// Parse read/pair
	assert(!buf_.read_a().readOrigBuf.empty());
	assert(buf_.read_a().empty());
	if(!parse(buf_.read_a(), buf_.read_b())) {
		return make_pair(false, false);
	}
	// Finalize read/pair
	if(paired()) {
		finalizePair(buf_.read_a(), buf_.read_b());
	} else {
		finalize(buf_.read_a());
	}
	return make_pair(true, this_is_last ? last_batch_ : false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x50(%rdi), %r15
decq %rax
cmpq %rax, %r15
jae 0x4108d
incq %r15
movq %r15, 0x50(%rbx)
movq 0x68(%rbx), %r14
jmp 0x410c0
movq %rbx, %rdi
callq 0x4371c
movq %rax, %r14
shrq $0x20, %rax
sete %cl
movw $0x100, %ax             # imm = 0x100
testb %r14b, %cl
jne 0x41144
movl %r14d, %eax
andb $0x1, %al
movb %al, 0x60(%rbx)
sarq $0x20, %r14
movq %r14, 0x68(%rbx)
movq 0x50(%rbx), %r15
decq %r14
movq 0x58(%rbx), %rax
addq %r15, %rax
movl 0x70(%rbx), %ecx
cmpq %rcx, %rax
jae 0x410df
movl 0x60(%rbx), %ecx
shll $0x8, %ecx
xorl %eax, %eax
cmpq %r14, %r15
jmp 0x41141
imulq $0x268, %r15, %rdx      # imm = 0x268
movq 0x18(%rbx), %rsi
addq %rdx, %rsi
addq 0x38(%rbx), %rdx
movq %rbx, %rdi
callq 0x4375c
testb %al, %al
je 0x41127
movq 0x38(%rbx), %rdx
imulq $0x268, 0x50(%rbx), %rax # imm = 0x268
movq 0x18(%rbx), %rsi
addq %rax, %rsi
cmpb $0x1, 0x190(%rdx,%rax)
jne 0x4112b
addq %rax, %rdx
movq %rbx, %rdi
callq 0x40fc2
jmp 0x41133
xorl %eax, %eax
jmp 0x41144
movq %rbx, %rdi
callq 0x40ef0
movl 0x60(%rbx), %ecx
shll $0x8, %ecx
incl %ecx
cmpq %r14, %r15
pushq $0x1
popq %rax
cmovel %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: SoloPatternComposer::nextBatch(PerThreadReadBuf&)
pair<bool, int> SoloPatternComposer::nextBatch(PerThreadReadBuf& pt) {
	uint32_t cur = cur_;
	while(cur < src_.size()) {
		// Patterns from srca_[cur_] are unpaired
		pair<bool, int> res;
		do {
			res = src_[cur]->nextBatch(
				pt,
				true,  // batch A (or pairs)
				true); // grab lock below
		} while(!res.first && res.second == 0);
		if(res.second == 0) {
			ThreadSafe ts(&mutex_m);
			if(cur + 1 > cur_) {
				cur_++;
			}
			cur = cur_;
			continue; // on to next pair of PatternSources
		}
		return res;
	}
	assert_leq(cur, src_.size());
	return make_pair(true, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl 0xc(%rdi), %ebx
leaq 0x8(%rdi), %r12
pushq $0x1
popq %rbp
movq %rsp, %r13
movl %ebx, %ebx
cmpq %rbx, 0x28(%r15)
jbe 0x411bd
movq 0x18(%r15), %rax
movq (%rax,%rbx,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq *0x10(%rax)
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x41192
testb $0x1, %al
je 0x41170
testq %rcx, %rcx
jne 0x411c2
movq %r12, (%rsp)
movq %r12, %rdi
callq 0x40dda
incl %ebx
cmpl 0xc(%r15), %ebx
jbe 0x411af
incl 0xc(%r15)
movl 0xc(%r15), %ebx
movq %r13, %rdi
callq 0x1a9ee
jmp 0x41168
pushq $0x1
popq %rax
jmp 0x411cf
movabsq $-0xffffff01, %rcx      # imm = 0xFFFFFFFF000000FF
andq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: CFilePatternSource::nextBatchImpl(PerThreadReadBuf&, bool)
pair<bool, int> CFilePatternSource::nextBatchImpl(
	PerThreadReadBuf& pt,
	bool batch_a)
{
	bool done = false;
	size_t nread = 0;
	pt.setReadId(readCnt_);
	while(true) { // loop that moves on to next file when needed
		do {
			pair<bool, int> ret = nextBatchFromFile(pt, batch_a, nread);
			done = ret.first;
			nread = ret.second;
		} while(!done && nread == 0); // not sure why this would happen
		if(done && filecur_ < infiles_.size()) { // finished with this file
			open();
			resetForNextFile(); // reset state to handle a fresh file
			filecur_++;
			if(nread == 0 || nread < pt.max_buf_) {
				continue;
			}
			done = false;
		}
		break;
	}
	assert_geq(nread, 0);
	readCnt_ += nread;
	return make_pair(done, nread);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rax, 0x50(%rsi)
movzbl %dl, %ebp
xorl %r13d, %r13d
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r13, %rcx
callq *0x30(%rax)
movq %rax, %r14
movq %rax, %r13
sarq $0x20, %r13
xorb $0x1, %al
movq %r14, %r15
shrq $0x20, %r15
sete %cl
testb %al, %cl
jne 0x413d9
testb $0x1, %r14b
je 0x4143e
movq 0x80(%rbx), %rax
cmpq 0x38(%rbx), %rax
jae 0x4143e
movq %rbx, %rdi
callq 0x4146a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
incq 0x80(%rbx)
testq %r15, %r15
je 0x413d9
cmpq (%r12), %r13
jb 0x413d9
xorl %ecx, %ecx
jmp 0x41444
movl %r14d, %ecx
andl $0x1, %ecx
addq %r13, 0x8(%rbx)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r14
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: CFilePatternSource::nextBatch(PerThreadReadBuf&, bool, bool)
pair<bool, int> CFilePatternSource::nextBatch(
	PerThreadReadBuf& pt,
	bool batch_a,
	bool lock)
{
	if(lock) {
		// synchronization at this level because both reading and manipulation of
		// current file pointer have to be protected
		ThreadSafe ts(&mutex);
		return nextBatchImpl(pt, batch_a);
	} else {
		return nextBatchImpl(pt, batch_a);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %ecx, %ecx
je 0x417e0
leaq 0x10(%r14), %rdi
movq %rdi, 0x8(%rsp)
callq 0x40dda
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x413ba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a9ee
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x413ba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a9ee
movq %rbx, %rdi
callq 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: VectorPatternSource::nextBatchImpl(PerThreadReadBuf&, bool)
pair<bool, int> VectorPatternSource::nextBatchImpl(
	PerThreadReadBuf& pt,
	bool batch_a)
{
	pt.setReadId(cur_);
	EList<Read>& readbuf = batch_a ? pt.bufa_ : pt.bufb_;
	size_t readi = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movq %rcx, 0x50(%rsi)
xorb $0x1, %dl
movzbl %dl, %r12d
shll $0x5, %r12d
orq $0x8, %r12
movl $0x120, %r13d           # imm = 0x120
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x68(%rbx), %rdx
cmpq (%r14), %rbp
jae 0x41b4e
cmpq %rdx, %rcx
jae 0x41b4e
movq 0x8(%r14,%r12), %rdi
addq %r13, %rdi
movq 0x58(%rbx), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
callq 0x438da
incq %rbp
movq 0x20(%rbx), %rcx
incq %rcx
movq %rcx, 0x20(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r15
addq $0x268, %r13            # imm = 0x268
jmp 0x41b03
addq %rbp, 0x8(%rbx)
xorl %eax, %eax
cmpq %rdx, %rcx
sete %al
addq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: VectorPatternSource::nextBatch(PerThreadReadBuf&, bool, bool)
pair<bool, int> VectorPatternSource::nextBatch(
	PerThreadReadBuf& pt,
	bool batch_a,
	bool lock)
{
	if(lock) {
		ThreadSafe ts(&mutex);
		return nextBatchImpl(pt, batch_a);
	} else {
		return nextBatchImpl(pt, batch_a);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %ecx, %ecx
je 0x41bb6
leaq 0x10(%r14), %rdi
movq %rdi, 0x8(%rsp)
callq 0x40dda
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41ad0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a9ee
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x41ad0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a9ee
movq %rbx, %rdi
callq 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: wrongQualityFormat(SStringExpandable<char, 25, 2, 0> const&)
void wrongQualityFormat(const BTString& read_name) {
	cerr << "Encountered a space parsing the quality string for read " << read_name << endl
	     << "If this is a FASTQ file with integer (non-ASCII-encoded) qualities, please" << endl
	     << "re-run Bowtie with the --integer-quals option." << endl;
	throw 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2012f(%rip), %rdi     # 0x61ff0
leaq 0xa174(%rip), %rsi      # 0x4c03c
callq 0x94e0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1970d
movq %rax, %rdi
callq 0x9210
leaq 0xa18e(%rip), %rsi      # 0x4c075
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
leaq 0xa1c2(%rip), %rsi      # 0x4c0c0
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
pushq $0x4
popq %rdi
callq 0x9220
movl $0x1, (%rax)
movq 0x20035(%rip), %rsi     # 0x61f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x9910
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./qual.h
// Function: charToPhred33(char, bool, bool)
inline static char charToPhred33(char c, bool solQuals, bool phred64Quals) {
	if(c == ' ') {
		cerr << "Saw a space but expected an ASCII-encoded quality value." << endl
		     << "Are quality values formatted as integers?  If so, try --integer-quals." << endl;
		throw 1;
	}
	if (solQuals) {
		// Convert solexa-scaled chars to phred
		// http://maq.sourceforge.net/fastq.shtml
		char cc = solexaToPhred((int)c - 64) + 33;
		if (cc < 33) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 64-based Solexa qual (converts to " << (int)cc << ")." << endl
			     << "Try not specifying --solexa-quals." << endl;
			throw 1;
		}
		c = cc;
	}
	else if(phred64Quals) {
		if (c < 64) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 64-based Phred qual." << endl
			     << "Try not specifying --solexa1.3-quals/--phred64-quals." << endl;
			throw 1;
		}
		// Convert to 33-based phred
		c -= (64-33);
	}
	else {
		// Keep the phred quality
		if (c < 33) {
			cerr << "Saw ASCII character "
			     << ((int)c)
			     << " but expected 33-based Phred qual." << endl;
			throw 1;
		}
	}
	return c;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpb $0x20, %bl
je 0x41fd8
movl %ebx, %eax
testb %sil, %sil
je 0x41fbc
cmpb $0x36, %al
movb $0x21, %al
jl 0x41fd1
movl %ebx, %eax
addl $-0x36, %eax
leaq 0x22cb8(%rip), %rcx     # 0x64c10
movb (%rcx,%rax), %cl
leal 0x21(%rcx), %eax
cmpb $0x5f, %cl
jb 0x41fd1
movsbl %al, %ebp
movq 0x20083(%rip), %rdi     # 0x61ff0
leaq 0xa369(%rip), %rsi      # 0x4c2dd
callq 0x94e0
movq %rax, %rdi
movl %ebx, %esi
callq 0x9930
leaq 0xa368(%rip), %rsi      # 0x4c2f2
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
movl %ebp, %esi
callq 0x9930
leaq 0x9635(%rip), %rsi      # 0x4b5d8
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
leaq 0xa369(%rip), %rsi      # 0x4c323
jmp 0x41ffa
testb %dl, %dl
je 0x41fc9
cmpb $0x3f, %al
jle 0x42029
addl $-0x1f, %eax
jmp 0x41fd1
cmpb $0x20, %al
jle 0x42066
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x20011(%rip), %rdi     # 0x61ff0
leaq 0xa277(%rip), %rsi      # 0x4c25d
callq 0x94e0
movq %rax, %rdi
callq 0x9210
leaq 0xa29c(%rip), %rsi      # 0x4c296
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
pushq $0x4
popq %rdi
callq 0x9220
movl $0x1, (%rax)
movq 0x1ff39(%rip), %rsi     # 0x61f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x9910
movq 0x1ffc0(%rip), %rdi     # 0x61ff0
leaq 0xa2a6(%rip), %rsi      # 0x4c2dd
callq 0x94e0
movq %rax, %rdi
movl %ebx, %esi
callq 0x9930
leaq 0xa2f9(%rip), %rsi      # 0x4c346
movq %rax, %rdi
callq 0x94e0
movq %rax, %rdi
callq 0x9210
leaq 0xa305(%rip), %rsi      # 0x4c369
jmp 0x41ffa
movq 0x1ff83(%rip), %rdi     # 0x61ff0
leaq 0xa269(%rip), %rsi      # 0x4c2dd
callq 0x94e0
movq %rax, %rdi
movl %ebx, %esi
callq 0x9930
leaq 0xa315(%rip), %rsi      # 0x4c39f
jmp 0x41ffa
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: FastaPatternSource::nextBatchFromFile(PerThreadReadBuf&, bool, unsigned long)
pair<bool, int> FastaPatternSource::nextBatchFromFile(
	PerThreadReadBuf& pt,
	bool batch_a,
	size_t readi)
{
	int c;
	EList<Read>& readbuf = batch_a ? pt.bufa_ : pt.bufb_;
	if(first_) {
		c = getc_wrapper();
		if(c == EOF) {
			return make_pair(true, 0);
		}
		while(c == '\r' || c == '\n') {
			c = getc_wrapper();
		}
		if(c != '>') {
			cerr << "Error: reads file does not look like a FASTA file" << endl;
			throw 1;
		}
		first_ = false;
	}
	bool done = false;
	// Read until we run out of input or until we've filled the buffer
	for(; readi < pt.max_buf_ && !done; readi++) {
		readbuf[readi].readOrigBuf.append('>');
		while(true) {
			c = getc_wrapper();
			if(c < 0 || c == '>') {
				done = c < 0;
				break;
			}
			readbuf[readi].readOrigBuf.append(c);
		}
	}
	// Immediate EOF case
	if(done && readbuf[readi-1].readOrigBuf.length() == 1) {
		readi--;
	}
	return make_pair(done, readi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x200a3(%rdi)
jne 0x42197
movq %r15, %rdi
callq 0x4398e
cmpl $-0x1, %eax
je 0x42248
cmpl $0xa, %eax
je 0x4217c
cmpl $0xd, %eax
jne 0x42186
movq %r15, %rdi
callq 0x4398e
jmp 0x42172
cmpl $0x3e, %eax
jne 0x4224d
movb $0x0, 0x200a3(%r15)
xorb $0x1, %bpl
movzbl %bpl, %ebp
shll $0x5, %ebp
orq $0x8, %rbp
xorl %eax, %eax
leaq 0x6(%rsp), %r13
cmpq (%r14), %rbx
jae 0x4220e
testb $0x1, %al
jne 0x4220e
movq 0x8(%r14,%rbp), %rax
imulq $0x268, %rbx, %r12      # imm = 0x268
leaq (%rax,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb $0x3e, 0x7(%rsp)
leaq 0x7(%rsp), %rsi
callq 0x439de
movq %r15, %rdi
callq 0x4398e
testl %eax, %eax
js 0x42206
cmpl $0x3e, %eax
je 0x42206
movq 0x8(%r14,%rbp), %rcx
leaq (%rcx,%r12), %rdi
addq $0x120, %rdi            # imm = 0x120
movb %al, 0x6(%rsp)
movq %r13, %rsi
jmp 0x421d7
shrl $0x1f, %eax
incq %rbx
jmp 0x421ad
testb $0x1, %al
je 0x4222f
leaq -0x1(%rbx), %rcx
movq 0x8(%r14,%rbp), %rdx
imulq $0x268, %rbx, %rsi      # imm = 0x268
cmpq $0x1, -0x128(%rsi,%rdx)
cmoveq %rcx, %rbx
shlq $0x20, %rbx
movzbl %al, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x42239
movq 0x1fd9c(%rip), %rdi     # 0x61ff0
leaq 0x9d7d(%rip), %rsi      # 0x4bfd8
callq 0x94e0
movq %rax, %rdi
callq 0x9210
pushq $0x4
popq %rdi
callq 0x9220
movl $0x1, (%rax)
movq 0x1fcdb(%rip), %rsi     # 0x61f58
movq %rax, %rdi
xorl %edx, %edx
callq 0x9910
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/pat.cpp
// Function: FastaContinuousPatternSource::parse(Read&, Read&, unsigned long) const
bool FastaContinuousPatternSource::parse(
	Read& ra,
	Read& rb,
	TReadId rdid) const
{
	// Light parser (nextBatchFromFile) puts unparsed data
	// into Read& r, even when the read is paired.
	assert(ra.empty());
	assert(rb.empty());
	assert(!ra.readOrigBuf.empty()); // raw data for read/pair is here
	assert(rb.readOrigBuf.empty());
	int c = '\t';
	size_t cur = 0;
	const size_t buflen = ra.readOrigBuf.length();

	// Parse read name
	c = ra.readOrigBuf[cur++];
	while(c != '\t' && cur < buflen) {
		ra.name.append(c);
		c = ra.readOrigBuf[cur++];
	}
	assert_eq('\t', c);
	if(cur >= buflen) {
		return false; // record ended prematurely
	}

	// Parse sequence
	assert(ra.patFw.empty());
	int nchar = 0;
	while(cur < buflen) {
		c = ra.readOrigBuf[cur++];
		if(isalpha(c)) {
			assert_in(toupper(c), "ACGTN");
			if(nchar++ >= this->trim5_) {
				assert_neq(0, asc2dnacat[c]);
				ra.patFw.append(asc2dna[c]); // ascii to int
			}
		}
	}
	// record amt trimmed from 5' end due to --trim5
	ra.trimmed5 = (int)(nchar - ra.patFw.length());
	// record amt trimmed from 3' end due to --trim3
	ra.trimmed3 = (int)(ra.patFw.trimEnd(this->trim3_));

	// Make fake qualities
	assert(ra.qual.empty());
	for(size_t i = 0; i < ra.patFw.length(); i++) {
		ra.qual.append('I');
	}

	ra.parsed = true;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x128(%rsi), %rax
movq 0x140(%rsi), %r14
leaq 0x150(%rsi), %r15
pushq $0x1
popq %r13
leaq 0x7(%rsp), %rbp
movb (%rax), %al
cmpb $0x9, %al
je 0x42777
cmpq %r14, %r13
jae 0x42777
movb %al, 0x7(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x43902
leaq 0x1(%r13), %rcx
addq 0x128(%rbx), %r13
movq %r13, %rax
movq %rcx, %r13
jmp 0x4274a
cmpq %r14, %r13
jae 0x4284b
movq %r12, 0x8(%rsp)
movq %r14, 0x10(%rsp)
xorl %r15d, %r15d
movq %r13, %r12
movq 0x128(%rbx), %r14
cmpq 0x10(%rsp), %r12
jae 0x427e6
movsbl (%r14,%r12), %ebp
incq %r12
movl %ebp, %edi
callq 0x9820
testl %eax, %eax
je 0x42797
leal 0x1(%r15), %r14d
movq 0x8(%rsp), %rax
cmpl 0x18(%rax), %r15d
movl %r14d, %r15d
jl 0x42790
movslq %ebp, %rax
leaq 0x21d93(%rip), %rcx     # 0x64560
movb (%rcx,%rax), %al
movb %al, 0x6(%rsp)
movq %rbx, %rdi
leaq 0x6(%rsp), %rsi
callq 0x43948
movl %r14d, %r15d
jmp 0x42790
movq 0x20(%rbx), %rcx
subl %ecx, %r15d
movl %r15d, 0x1a8(%rbx)
movq 0x8(%rsp), %rax
movslq 0x14(%rax), %rdx
xorl %r12d, %r12d
movq %rcx, %rax
subq %rdx, %rax
cmovbq %r12, %rax
cmovbq %rcx, %rdx
movq %rax, 0x20(%rbx)
movl %edx, 0x1ac(%rbx)
leaq 0x60(%rbx), %r14
leaq 0x5(%rsp), %r15
cmpq %rax, %r12
jae 0x4283f
movb $0x49, 0x5(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x43902
incq %r12
movq 0x20(%rbx), %rax
jmp 0x42821
movb $0x1, 0x190(%rbx)
movq 0x10(%rsp), %r14
cmpq %r14, %r13
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq