LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b890
movq %rax, (%rsp)
testq %rax, %rax
je 0x2b7fb
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x2ba00
leaq 0x38(%rbx), %rdi
leaq 0x5c(%rbx), %rsi
callq 0x22bde
incl 0x30(%rbx)
movl $0x0, 0x5c(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x9200
movq 0x3e77c(%rip), %rcx     # 0x69f88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3e79e(%rip), %rsi     # 0x69fb8
movq 0x3e747(%rip), %rdx     # 0x69f68
movq %rax, %rdi
callq 0x98f0
movq %rax, %r14
cmpl $0x1, %edx
jne 0x2b87f
movq %r14, %rdi
callq 0x91a0
leaq 0x419b8(%rip), %rdi     # 0x6d1f8
callq 0x4ac58
movq (%rbx), %rdi
callq 0x2777c
leaq 0x419a4(%rip), %rdi     # 0x6d1f8
callq 0x4ac94
callq 0x9840
xorl %eax, %eax
jmp 0x2b7f3
jmp 0x2b887
movq %rax, %r14
leaq 0x4198a(%rip), %rdi     # 0x6d1f8
callq 0x4ac94
jmp 0x2b87a
jmp 0x2b887
movq %rax, %r14
callq 0x9840
movq %r14, %rdi
callq 0x9930
movq %rax, %rdi
callq 0x1afa3
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b8e0
incl %r15d
cmpl %esi, %r15d
cmovael %ebx, %r15d
cmpl %edx, %r15d
jne 0x2b8b0
jmp 0x2b9a2
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 0x2b905
leal 0x1(%r15), %eax
movl %eax, 0x28(%r14)
cmpb $0x1, (%r14)
jne 0x2b99e
leaq 0x20(%rsp), %rdi
callq 0x9310
leaq 0x30(%rsp), %rdi
movl 0x4(%r14), %esi
callq 0x92e0
movq %rax, %r12
leaq 0x2a0de(%rip), %rsi     # 0x55a0f
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 0x41cc4(%rip), %rdi     # 0x6d621
movq %rsp, %rsi
callq 0x2ba90
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b980
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3e5c1(%rip), %rsi     # 0x69f48
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 0x2b9d9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2b9d9
jmp 0x2b9d6
movq %rax, %rbx
movq 0x3e568(%rip), %rsi     # 0x69f48
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0xa0(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b036
movl %ebp, %ecx
subl %r13d, %ecx
movzwl 0x8(%r15), %eax
addl %ecx, %eax
cmpl %r12d, %eax
jae 0x2bc2e
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 0x2bc1f
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 0x1b036
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2bc71
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movl (%r14), %ecx
movl %ecx, 0x8(%rbx,%rax,4)
jmp 0x2bcd2
cmpq $0x6, %rax
jne 0x2bc94
movq %rdx, %rdi
movl $0x10, %esi
callq 0x2bff8
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x2bcc0
movl (%r14), %ecx
movl %ecx, (%rax)
jmp 0x2bccf
cmpq $0x15, %rax
ja 0x2bca7
movq 0x20(%rbx), %rcx
movl (%r14), %edx
movl %edx, -0x18(%rcx,%rax,4)
jmp 0x2bccf
cmpq $0x16, %rax
jne 0x2bcc4
addl $-0xc, %ecx
movq %rdx, %rdi
movl %ecx, %esi
callq 0x2bff8
movq %rax, 0x28(%rbx)
jmp 0x2bc88
xorl %eax, %eax
jmp 0x2bcd4
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_O3/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::alloc(unsigned int)
T* alloc(uint32_t num) {
		if(!lazyInit()) return NULL;
		if(cur_ + num >= lim_) {
			if(!allocNextPool()) return NULL;
			assert_eq(0, cur_);
		}
		assert_leq(num, lim_);
		cur_ += num;
		return &pools_[curPool_][cur_ - num];
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x2bd34
testb %al, %al
je 0x2bd2a
movl 0x5c(%rbx), %eax
leal (%rax,%r14), %ecx
cmpl 0x58(%rbx), %ecx
jb 0x2bd10
movq %rbx, %rdi
callq 0x2be12
testb %al, %al
je 0x2bd2a
movl 0x5c(%rbx), %eax
addl %eax, %r14d
movl %r14d, %ecx
movl %ecx, 0x5c(%rbx)
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq (%rdx,%rcx,8), %rax
jmp 0x2bd2c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movq %rsi, (%rsp)
cmpb $0x1, 0x2c(%rdi)
jne 0x2c49a
movq %rsi, %r14
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movl 0x28(%rbx), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x296df(%rip), %rsi     # 0x55a30
movl $0xa, %edx
movq %rax, %rdi
callq 0x9560
movl (%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x26c73(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movq %r14, %rsi
callq 0x9390
movq %rax, %r15
leaq 0x26c51(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzwl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x26c2d(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x83(%r14), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x26c06(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x82(%r14), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r14
leaq 0x26bdf(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
movq %r14, %rdi
callq 0x92e0
movq %rax, %r14
leaq 0x29613(%rip), %rsi     # 0x55a3b
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
incl %esi
movq %r14, %rdi
callq 0x92e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x411ca(%rip), %rdi     # 0x6d621
leaq 0x8(%rsp), %rsi
callq 0x2ba90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c47c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3dac5(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
leaq 0x8(%rbx), %rdi
movq %rsp, %rsi
callq 0x2c6e4
incl (%rbx)
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 0x2c4da
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2c4da
jmp 0x2c4d7
movq %rax, %rbx
movq 0x3da67(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c689
movq %rdi, %r14
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movl 0x28(%r14), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x29516(%rip), %rsi     # 0x55a58
movl $0xb, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x26a83(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9390
movq %rax, %r15
leaq 0x26a61(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzwl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x26a3e(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x83(%rbx), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x26a18(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x82(%rbx), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x269f2(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x29425(%rip), %rsi     # 0x55a3b
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 0x40fdb(%rip), %rdi     # 0x6d621
leaq 0x8(%rsp), %rsi
callq 0x2ba90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c66b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3d8d6(%rip), %rsi     # 0x69f48
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 0x2c6be
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2c6be
jmp 0x2c6bb
movq %rax, %rbx
movq 0x3d883(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c8d1
movb 0x83(%rsi), %cl
cmpb $0x0, 0x82(%rdx)
jne 0x2c8e0
movb 0x83(%rdx), %al
movzwl 0x10(%rsi), %edi
movzwl 0x10(%rdx), %r8d
cmpw %r8w, %di
jne 0x2c925
movl %eax, %edi
notb %dil
orb %cl, %dil
testb $0x1, %dil
je 0x2c929
notb %cl
orb %al, %cl
movb $0x1, %al
testb $0x1, %cl
je 0x2c924
movzwl 0xe(%rsi), %eax
addw 0xc(%rsi), %ax
movzwl 0xe(%rdx), %ecx
addw 0xc(%rdx), %cx
cmpw %cx, %ax
jne 0x2c921
movl (%rdx), %eax
cmpl (%rsi), %eax
setb %al
retq
seta %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d98e
cmpb $0x1, 0x83(%r14)
jne 0x2d0c4
movq %rbx, %rdi
callq 0x2dfd2
movq %rbx, %rdi
callq 0x2c500
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 0x2db08
cmpw %r12w, 0x10(%r14)
je 0x2d107
movq %rbx, %rdi
callq 0x2dfd2
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c500
movzwl 0x10(%rax), %eax
movw %ax, 0x158(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c310
movq %rbx, %rdi
callq 0x2c500
movzwl 0x10(%rax), %eax
movw %ax, 0x158(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: PathManager::reset(unsigned int)
void reset(uint32_t patid) {
		branchQ_.reset(patid); // reset the priority queue
		assert(branchQ_.empty());
		bpool.reset();    // reset the Branch pool
		epool.reset();    // reset the Edit pool
		rpool.reset();    // reset the RangeState pool
		assert(bpool.empty());
		assert(epool.empty());
		assert(rpool.empty());
		ASSERT_ONLY(branchSet_.clear());
		assert_eq(0, branchSet_.size());
		assert_eq(0, branchQ_.size());
		minCost = 0;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x28(%rdi)
movq 0x8(%rdi), %rdi
movq 0x18(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
testq %rdi, %rdi
je 0x2d937
subq %rdi, %rsi
callq 0x94c0
xorl %eax, %eax
movl %eax, (%rbx)
movq %rax, 0x60(%rbx)
movq %rax, 0x88(%rbx)
movl %eax, 0x94(%rbx)
movl %eax, 0x68(%rbx)
movq %rax, 0x120(%rbx)
movq %rax, 0x148(%rbx)
movl %eax, 0x154(%rbx)
movl %eax, 0x128(%rbx)
movq %rax, 0xc0(%rbx)
movq %rax, 0xe8(%rbx)
movl %eax, 0xf4(%rbx)
movl %eax, 0xc8(%rbx)
movw $0x0, 0x158(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: Branch::free(unsigned int, AllocOnlyPool<RangeState>&, AllocOnlyPool<Edit>&, AllocOnlyPool<Branch>&)
void free(uint32_t qlen,
	          AllocOnlyPool<RangeState>& rpool,
	          AllocOnlyPool<Edit>& epool,
	          AllocOnlyPool<Branch>& bpool)
	{
		edits_.free(epool, qlen);
		if(ranges_ != NULL) {
			assert_gt(rangesSz_, 0);
			rpool.free(ranges_, rangesSz_);
			ranges_ = NULL;
			rangesSz_ = 0;
		}
		bpool.free(this);
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x2dc77
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x27f08(%rip), %rsi     # 0x55aa9
movl $0xa, %edx
movq %rax, %rdi
callq 0x9560
movl %ebp, %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x282db(%rip), %rsi     # 0x55e9d
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x2dbf0
movq %r12, %rdi
callq 0x91b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x2dc0a
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x98c0
leaq 0x285a1(%rip), %rsi     # 0x561b2
movl $0x1, %edx
movq %r15, %rdi
callq 0x9560
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x3f9ed(%rip), %rdi     # 0x6d621
leaq 0x8(%rsp), %rsi
callq 0x2ba90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dc59
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3c2e8(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movl 0x5c(%rbx), %eax
movl %eax, %ecx
subl %ebp, %ecx
jb 0x2dc98
movl 0x30(%rbx), %edx
movq 0x18(%rbx), %rsi
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq (%rsi,%rdx,8), %rdi
cmpq %r14, %rdi
je 0x2dcac
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, 0x5c(%rbx)
cmpl %ebp, %eax
setne %al
testl %edx, %edx
sete %cl
orb %al, %cl
movb $0x1, %bpl
jne 0x2dc9a
movq %rbx, %rdi
callq 0x2dd16
jmp 0x2dc9a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dcef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2dcef
jmp 0x2dcec
movq %rax, %rbx
movq 0x3c252(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::rewindPool()
void rewindPool() {
		assert_eq(curPool_+1, pools_.size());
		assert_eq(curPool_, lastCurInPool_.size());
		if(pool_->verbose) {
			stringstream ss;
			ss << pool_->patid << ": Freeing a " << name_ << " pool";
			glog.msg(ss.str());
		}
		pool_->free(pools_.back());
		pools_.pop_back();
		curPool_--;
		assert_gt(lastCurInPool_.size(), 0);
		cur_ = lastCurInPool_.back();
		lastCurInPool_.pop_back();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x1, (%rdi)
jne 0x2de0d
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x92e0
movq %rax, %r14
leaq 0x27d5f(%rip), %rsi     # 0x55ab4
movl $0xc, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x2dd83
movq %r15, %rdi
callq 0x91b0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x2dd9d
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x98c0
leaq 0x27d1d(%rip), %rsi     # 0x55ac1
movl $0x5, %edx
movq %r14, %rdi
callq 0x9560
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x3f85a(%rip), %rdi     # 0x6d621
leaq 0x8(%rsp), %rsi
callq 0x2ba90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ddec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3c155(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq (%rbx), %rdi
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rsi
callq 0x2de94
decq 0x28(%rbx)
decl 0x30(%rbx)
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
movl -0x4(%rax,%rcx,4), %eax
movl %eax, 0x5c(%rbx)
decq %rcx
movq %rcx, 0x50(%rbx)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2de6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2de6e
jmp 0x2de6b
movq %rax, %rbx
movq 0x3c0d3(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::free(void*)
void free(void *ptr) {
		uint32_t off = (uint32_t)((int8_t*)ptr - pool_);
		assert_eq(0, off % chunkSz_);
		off /= chunkSz_;
		if(verbose) {
			stringstream ss;
			ss << patid << ": Freeing chunk with offset: " << cur_;
			glog.msg(ss.str());
		}
		bits_.clear(off);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movl 0x14(%rdi), %ebp
cmpb $0x1, (%rdi)
jne 0x2df4b
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movl 0x4(%rbx), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x27bed(%rip), %rsi     # 0x55ac7
movl $0x1d, %edx
movq %rax, %rdi
callq 0x9560
movl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x92e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x3f719(%rip), %rdi     # 0x6d621
leaq 0x8(%rsp), %rsi
callq 0x2ba90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2df2d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3c014(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
subl %r12d, %r14d
movl %r14d, %eax
xorl %edx, %edx
divl %ebp
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl %eax, %ecx
roll %cl, %edx
movq 0x30(%rbx), %rcx
movl %eax, %esi
shrl $0x5, %esi
andl %edx, (%rcx,%rsi,4)
decl 0x24(%rbx)
cmpl %eax, 0x28(%rbx)
ja 0x2df77
incl %eax
movl %eax, 0x28(%rbx)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dfac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2dfac
jmp 0x2dfa9
movq %rax, %rbx
movq 0x3bf95(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: BranchQueue::pop()
Branch *pop() {
		Branch *b = branchQ_.top(); // get it
		branchQ_.pop(); // remove it
		if(verbose_) {
			stringstream ss;
			ss << patid_ << ": Popping " << b->id_ << ", " << b << ", " << b->cost_ << ", " << b->exhausted_ << ", " << b->curtailed_ << ", " << sz_ << "->" << (sz_-1);
			glog.msg(ss.str());
		}
		sz_--;
		return b;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rbx), %rax
movq (%rax), %r14
callq 0x2e1c2
cmpb $0x1, 0x2c(%rbx)
jne 0x2e165
leaq 0x28(%rsp), %rdi
callq 0x9310
leaq 0x38(%rsp), %rdi
movl 0x28(%rbx), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x27ac9(%rip), %rsi     # 0x55ae5
movl $0xa, %edx
movq %rax, %rdi
callq 0x9560
movl (%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x24fa8(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movq %r14, %rsi
callq 0x9390
movq %rax, %r15
leaq 0x24f86(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzwl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x24f62(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x83(%r14), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x24f3b(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movzbl 0x82(%r14), %esi
movq %r15, %rdi
callq 0x9850
movq %rax, %r15
leaq 0x24f14(%rip), %rsi     # 0x52fe6
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
movq %r15, %rdi
callq 0x92e0
movq %rax, %r15
leaq 0x27948(%rip), %rsi     # 0x55a3b
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movl (%rbx), %esi
decl %esi
movq %r15, %rdi
callq 0x92e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x97e0
leaq 0x3f4ff(%rip), %rdi     # 0x6d621
leaq 0x8(%rsp), %rsi
callq 0x2ba90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e147
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3bdfa(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
decl (%rbx)
movq %r14, %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 0x2e19c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2e19c
jmp 0x2e199
movq %rax, %rbx
movq 0x3bda5(%rip), %rsi     # 0x69f48
leaq 0x28(%rsp), %rdi
callq 0x9340
leaq 0xa8(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: EditList::free(AllocOnlyPool<Edit>&, unsigned long)
void free(AllocOnlyPool<Edit>& epool, size_t qlen) {
		if(yetMoreEdits_ != NULL)
			epool.free(yetMoreEdits_, (uint32_t)qlen + 10 - numMoreEdits - numEdits);
		if(moreEdits_ != NULL)
			epool.free(moreEdits_, numMoreEdits);
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x2e42f
leaq 0x20(%rsp), %rdi
callq 0x9310
leaq 0x30(%rsp), %rdi
movq (%rbx), %rax
movl 0x4(%rax), %esi
callq 0x92e0
movq %rax, %r15
leaq 0x27722(%rip), %rsi     # 0x55ab4
movl $0xc, %edx
movq %rax, %rdi
callq 0x9560
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x2e3c0
movq %r12, %rdi
callq 0x91b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x2e3da
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x98c0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x97e0
leaq 0x3f233(%rip), %rdi     # 0x6d621
movq %rsp, %rsi
callq 0x2ba90
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e411
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3bb30(%rip), %rsi     # 0x69f48
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0xa0(%rsp), %rdi
callq 0x9180
movl 0x5c(%rbx), %eax
testl %eax, %eax
je 0x2e46c
movl 0x30(%rbx), %ecx
movq 0x18(%rbx), %rdx
decl %eax
movq %rax, %rsi
shlq $0x7, %rsi
leaq (%rsi,%rax,8), %rsi
addq (%rdx,%rcx,8), %rsi
cmpq %r14, %rsi
jne 0x2e46c
movl %eax, 0x5c(%rbx)
testl %eax, %eax
setne %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
jne 0x2e46c
movq %rbx, %rdi
callq 0x2e800
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 0x2e4a0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x2e4a0
jmp 0x2e49d
movq %rax, %rbx
movq 0x3baa1(%rip), %rsi     # 0x69f48
leaq 0x20(%rsp), %rdi
callq 0x9340
leaq 0xa0(%rsp), %rdi
callq 0x9180
movq %rbx, %rdi
callq 0x9930
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: Branch::prep(EbwtParams const&, unsigned char const*)
void prep(const EbwtParams& ep, const uint8_t* ebwt) {
		if(bot_ > top_+1) {
			SideLocus::initFromTopBot(top_, bot_, ep, ebwt, ltop_, lbot_);
		} else if(bot_ > top_) {
			ltop_.initFromRow(top_, ep, ebwt);
			lbot_.invalidate();
		}
		prepped_ = true;
	}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movl 0x24(%rdi), %eax
movl 0x28(%rdi), %esi
leal 0x1(%rax), %edi
cmpl %edi, %esi
jbe 0x2f354
leaq 0x2c(%rbx), %r8
leaq 0x3c(%rbx), %r9
movl %eax, %edi
callq 0x2bb86
jmp 0x2f367
cmpl %eax, %esi
jbe 0x2f367
leaq 0x2c(%rbx), %rdi
movl %eax, %esi
callq 0x1b036
movb $-0x1, 0x4a(%rbx)
movb $0x1, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: SingleRangeSourceDriver<EbwtRangeSource>::setQueryImpl(PatternSourcePerThread*, Range*)
virtual void setQueryImpl(PatternSourcePerThread* patsrc, Range *r) {
		this->done = false;
		pm_.reset((uint32_t)patsrc->rdid());
		Read* buf = mate1_ ? &patsrc->bufa() : &patsrc->bufb();
		len_ = buf->length();
		rs_->setQuery(*buf, r);
		initRangeSource((fw_ == ebwtFw_) ? buf->qual : buf->qualRev);
		assert_gt(len_, 0);
		if(this->done) return;
		ASSERT_ONLY(allTops_.clear());
		if(!rs_->done) {
			rs_->initBranch(pm_); // set up initial branch
		}
		uint16_t icost = (r != NULL) ? r->cost : 0;
		this->minCost = max<uint16_t>(icost, this->minCostAdjustment_);
		this->done = rs_->done;
		this->foundRange = rs_->foundRange;
		if(!pm_.empty()) {
			assert(!pm_.front()->curtailed_);
			assert(!pm_.front()->exhausted_);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, 0x9(%rdi)
leaq 0x40(%rdi), %r15
movl 0x50(%rsi), %esi
addl 0x58(%r12), %esi
movq %r15, %rdi
callq 0x2d90c
movzbl 0x14(%rbx), %eax
xorl $0x1, %eax
shll $0x5, %eax
movq 0x18(%r12,%rax), %r13
imulq $0x268, 0x50(%r12), %r12 # imm = 0x268
leaq (%r12,%r13), %rsi
leaq (%r12,%r13), %rbp
addq $0x60, %rbp
movl -0x40(%rbp), %eax
movl %eax, 0x10(%rbx)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rdx
callq *0x10(%rax)
movb 0x28(%rbx), %al
cmpb 0x38(%rbx), %al
leaq 0xf0(%r13,%r12), %rsi
cmoveq %rbp, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
cmpb $0x0, 0x9(%rbx)
jne 0x2f4aa
movq 0x30(%rbx), %rdi
cmpb $0x0, 0x8(%rdi)
jne 0x2f47f
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
testq %r14, %r14
je 0x2f48b
movzwl 0x8(%r14), %eax
jmp 0x2f48d
xorl %eax, %eax
movl 0xc(%rbx), %ecx
cmpw %cx, %ax
cmovbel %ecx, %eax
movw %ax, 0xa(%rbx)
movq 0x30(%rbx), %rax
movb 0x8(%rax), %cl
movb %cl, 0x9(%rbx)
movb 0x9(%rax), %al
movb %al, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::~CostAwareRangeSourceDriver()
virtual ~CostAwareRangeSourceDriver() {
		const size_t rssSz = rss_.size();
		for(size_t i = 0; i < rssSz; i++) {
			delete rss_[i];
		}
		rss_.clear();
		active_.clear();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x391df(%rip), %rax     # 0x69170
movq %rax, (%rdi)
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x2ffbb
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x2ffb3
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
cmpq %r15, %r14
jne 0x2ffa0
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %rax, 0x48(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2ffe6
leaq 0x38(%rbx), %r14
callq 0x95e0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x30006
addq $0x18, %rbx
callq 0x95e0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::setQueryImpl(PatternSourcePerThread*, Range*)
virtual void setQueryImpl(PatternSourcePerThread* patsrc, Range *r) {
		this->done = false;
		this->foundRange = false;
		lastRange_ = NULL;
		delayedRange_ = NULL;
		ASSERT_ONLY(allTopsRc_.clear());
		patsrc_ = patsrc;
		rand_.init(patsrc->bufa().seed);
		const size_t rssSz = rss_.size();
		if(rssSz == 0) return;
		for(size_t i = 0; i < rssSz; i++) {
			// Assuming that all
			rss_[i]->setQuery(patsrc, r);
		}
		active_ = rss_;
		this->minCost = 0;
		sortActives();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movw $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movq %rsi, 0x80(%rdi)
movq 0x18(%rsi), %rax
imulq $0x268, 0x50(%rsi), %rcx # imm = 0x268
movl 0x18c(%rax,%rcx), %eax
movl %eax, 0x60(%rdi)
movb $0x1, 0x68(%rdi)
movl $0x1e, 0x64(%rdi)
movq 0x28(%rdi), %r13
testq %r13, %r13
je 0x300c0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
xorl %ebp, %ebp
movq 0x18(%rbx), %rax
movq (%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
incq %rbp
cmpq %rbp, %r13
jne 0x3007c
leaq 0x30(%rbx), %rdi
movq %r12, %rsi
callq 0x30264
movw $0x0, 0xa(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3031a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::advanceImpl(int)
virtual void advanceImpl(int until) {
		lastRange_ = NULL;
		ASSERT_ONLY(uint16_t iminCost = this->minCost);
		const size_t actSz = active_.size();
		assert(sortedActives());
		if(delayedRange_ != NULL) {
			assert_eq(iminCost, delayedRange_->cost);
			lastRange_ = delayedRange_;
			delayedRange_ = NULL;
			this->foundRange = true;
			assert_eq(range().cost, iminCost);
			if(!active_.empty()) {
				assert_geq(active_[0]->minCost, this->minCost);
				this->minCost = max(active_[0]->minCost, this->minCost);
			} else {
				this->done = true;
			}
			return; // found a range
		}
		assert(delayedRange_ == NULL);
		if(mateEliminated() || actSz == 0) {
			// No more alternatoves; clear the active set and signal
			// we're done
			active_.clear();
			this->done = true;
			return;
		}
		// Advance lowest-cost RangeSourceDriver
		TRangeSrcDrPtr p = active_[0];
		uint16_t precost = p->minCost;
		assert(!p->done || p->foundRange);
		if(!p->foundRange) {
			p->advance(until);
		}
		bool needsSort = false;
		if(p->foundRange) {
			Range *r = &p->range();
			assert_eq(r->cost, iminCost);
			needsSort = foundFirstRange(r); // may set delayedRange_; re-sorts active_
			assert_eq(lastRange_->cost, iminCost);
			if(delayedRange_ != NULL) assert_eq(delayedRange_->cost, iminCost);
			p->foundRange = false;
		}
		if(p->done || (precost != p->minCost) || needsSort) {
			sortActives();
			if(mateEliminated() || active_.empty()) {
				active_.clear();
				this->done = (delayedRange_ == NULL);
			}
		}
		assert(sortedActives());
		assert(lastRange_ == NULL || lastRange_->cost == iminCost);
		assert(delayedRange_ == NULL || delayedRange_->cost == iminCost);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x70(%rdi)
movq 0x48(%rdi), %r14
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0x30133
movq %rax, 0x70(%rbx)
movq $0x0, 0x78(%rbx)
movb $0x1, 0x8(%rbx)
testq %r14, %r14
je 0x30151
movq 0x38(%rbx), %rax
movq (%rax), %rax
movzwl 0xa(%rax), %eax
movzwl 0xa(%rbx), %ecx
cmpw %cx, %ax
cmoval %eax, %ecx
movw %cx, 0xa(%rbx)
jmp 0x30155
movl %esi, %ebp
movq %rbx, %rdi
callq 0x304b6
xorb $0x1, %al
testq %r14, %r14
setne %cl
testb %al, %cl
jne 0x30160
movq $0x0, 0x48(%rbx)
movb $0x1, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rbx), %rax
movq (%rax), %r14
movzwl 0xa(%r14), %r15d
movb 0x8(%r14), %al
testb %al, %al
jne 0x30183
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *0x20(%rax)
movb 0x8(%r14), %al
testb $0x1, %al
je 0x301a2
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3051a
movb $0x0, 0x8(%r14)
jmp 0x301a4
xorl %eax, %eax
cmpb $0x0, 0x9(%r14)
jne 0x301b9
cmpw 0xa(%r14), %r15w
sete %cl
notb %al
testb %cl, %al
jne 0x30155
movq %rbx, %rdi
callq 0x3031a
movq %rbx, %rdi
callq 0x304b6
testb %al, %al
jne 0x301d4
cmpq $0x0, 0x48(%rbx)
jne 0x30155
movq $0x0, 0x48(%rbx)
cmpq $0x0, 0x78(%rbx)
sete 0x9(%rbx)
jmp 0x30155
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::removeMate(int)
virtual void removeMate(int m) {
		bool qmate1 = (m == 1);
		assert(paired_);
		for(size_t i = 0; i < active_.size(); i++) {
			if(active_[i]->mate1() == qmate1) {
				active_[i]->done = true;
			}
		}
		sortActives();
		assert(mateEliminated());
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x30251
movl %esi, %ebp
xorl %r14d, %r14d
cmpl $0x1, %ebp
setne %r15b
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpb %al, %r15b
je 0x30248
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rax
movb $0x1, 0x9(%rax)
incq %r14
cmpq 0x48(%rbx), %r14
jb 0x30222
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3031a
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::mateEliminated()
bool mateEliminated() {
		if(!paired_) return false;
		bool mate1sLeft = false;
		bool mate2sLeft = false;
		// If this RangeSourceDriver is done, shift everyone else
		// up and delete it
		const size_t rssSz = active_.size();
		for(size_t i = 0; i < rssSz; i++) {
			if(!active_[i]->done) {
				if(active_[i]->mate1()) mate1sLeft = true;
				else mate2sLeft = true;
			}
		}
		return !mate1sLeft || !mate2sLeft;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x30504
movq %rdi, %r14
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x30508
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x38(%r14), %rax
movq (%rax,%r12,8), %rdi
cmpb $0x0, 0x9(%rdi)
jne 0x304f4
movq (%rdi), %rax
callq *0x38(%rax)
orb %al, %bl
xorb $0x1, %al
orb %al, %r13b
incq %r12
cmpq %r12, %r15
jne 0x304d9
andb %r13b, %bl
xorb $0x1, %bl
jmp 0x3050a
xorl %ebx, %ebx
jmp 0x3050a
movb $0x1, %bl
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::addSource(RangeSourceDriver<EbwtRangeSource>*, Range*)
void addSource(TRangeSrcDrPtr p, Range *r) {
		assert(!this->foundRange);
		this->lastRange_ = NULL;
		this->delayedRange_ = NULL;
		this->done = false;
		if(patsrc_ != NULL) {
			p->setQuery(patsrc_, r);
		}
		rss_.push_back(p);
		active_.push_back(p);
		calcPaired();
		this->minCost = 0;
		sortActives();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movb $0x0, 0x9(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x30816
movq (%rsi), %rcx
movq %rsi, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x10(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x29aec
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x29aec
movq %rbx, %rdi
callq 0x308d8
movw $0x0, 0xa(%rbx)
movq %rbx, %rdi
callq 0x3031a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_source.h
// Function: CostAwareRangeSourceDriver<EbwtRangeSource>::calcPaired()
void calcPaired() {
		const size_t rssSz = rss_.size();
		bool saw1 = false;
		bool saw2 = false;
		for(size_t i = 0; i < rssSz; i++) {
			if(rss_[i]->mate1()) saw1 = true;
			else saw2 = true;
		}
		assert(saw1 || saw2);
		paired_ = saw1 && saw2;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x30929
xorl %r12d, %r12d
movl $0x1, %r13d
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
orb %al, %r14b
movzbl %bpl, %ebp
testb %al, %al
cmovel %r13d, %ebp
incq %r12
cmpq %r12, %r15
jne 0x308fd
andb %bpl, %r14b
andb $0x1, %r14b
jmp 0x3092c
xorl %r14d, %r14d
movb %r14b, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./aligner.h
// Function: UnpairedAlignerV2<EbwtRangeSource>::~UnpairedAlignerV2()
virtual ~UnpairedAlignerV2() {
		delete driver_;  driver_  = NULL;
		delete params_;  params_  = NULL;
		delete rchase_;  rchase_  = NULL;
		delete[] btCnt_; btCnt_   = NULL;
		sinkPtFactory_.destroy(sinkPt_); sinkPt_ = NULL;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3889a(%rip), %rax     # 0x691e8
movq %rax, (%rdi)
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x30963
movq (%rdi), %rax
callq *0x8(%rax)
xorl %r14d, %r14d
movq %r14, 0x80(%rbx)
movq 0x70(%rbx), %rdi
movl $0x18, %esi
callq 0x94c0
movq %r14, 0x70(%rbx)
movq 0x78(%rbx), %rdi
movl $0xc8, %esi
callq 0x94c0
movq %r14, 0x78(%rbx)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x309a2
callq 0x95e0
movq $0x0, 0x98(%rbx)
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x1afa3
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./aligner.h
// Function: Aligner::setQuery(PatternSourcePerThread*)
virtual void setQuery(PatternSourcePerThread *patsrc) {
		assert(patsrc != NULL);
		patsrc_ = patsrc;
		bufa_ = &patsrc->bufa();
		assert(bufa_ != NULL);
		bufb_ = &patsrc->bufb();
		alen_ = bufa_->length();
		blen_ = (bufb_ != NULL) ? bufb_->length() : 0;
		rand_.init(bufa_->seed);
	}

// Assembly:
movq %rsi, 0x10(%rdi)
movq 0x18(%rsi), %rdx
imulq $0x268, 0x50(%rsi), %r8 # imm = 0x268
leaq (%rdx,%r8), %rax
movq %rax, 0x18(%rdi)
movq 0x38(%rsi), %r9
imulq $0x268, 0x50(%rsi), %rcx # imm = 0x268
addq %r9, %rcx
movq %rcx, 0x28(%rdi)
movl 0x20(%rdx,%r8), %edx
movl %edx, 0x20(%rdi)
testq %r9, %r9
je 0x31081
movl 0x20(%rcx), %ecx
jmp 0x31083
xorl %ecx, %ecx
movl %ecx, 0x30(%rdi)
movl 0x18c(%rax), %eax
movl %eax, 0x40(%rdi)
movb $0x1, 0x48(%rdi)
movl $0x1e, 0x44(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./range_chaser.h
// Function: RangeChaser::advance()
void advance() {
		assert(!done);
		assert(chaser_.prepped_ || chaser_.done);
		reset();
		if(chaser_.done) {
			// chaser finished with this row
			row_++;
			if(row_ == bot_) {
				row_ = top_;
			}
			if(row_ == irow_) {
				// Exhausted all possible rows
				done = true;
				assert_eq(OFF_MASK, off_.first);
				return;
			}
			setRow(row_);
			assert(chaser_.prepped_ || foundOff() || done);
		} else {
			chaser_.advance();
			assert(chaser_.prepped_ || chaser_.done);
			if(chaser_.done) {
				// We're done immediately
				off_ = chaser_.off();
				if(off_.first != OFF_MASK) {
					if(cached_) {
						// Install the result in the cache
						assert(cacheEnt_.valid());
						cacheEnt_.install(row_ - top_, chaser_.flatOff());
						//if(ebwt_->fw()) assert(cacheFw_->repOk());
						//else            assert(cacheBw_->repOk());
					}
					// Found a reference position
					tlen_ = chaser_.tlen();
					assert(foundOff());
				}
			}
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
cmpb $0x1, 0x38(%rdi)
jne 0x310cd
movl 0x24(%rbx), %esi
incl %esi
movl %esi, 0x24(%rbx)
cmpl 0x1c(%rbx), %esi
jne 0x310c3
movl 0x18(%rbx), %esi
movl %esi, 0x24(%rbx)
cmpl 0x20(%rbx), %esi
jne 0x3111c
movb $0x1, (%rbx)
jmp 0x31114
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x312e4
cmpb $0x1, (%r14)
jne 0x31114
movq %r14, %rdi
callq 0x313a4
movq %rax, 0x28(%rbx)
cmpl $-0x1, %eax
je 0x31114
cmpb $0x1, 0xa8(%rbx)
jne 0x3110e
leaq 0x80(%rbx), %rdi
movl 0x24(%rbx), %esi
movl 0x70(%rbx), %edx
subl 0x18(%rbx), %esi
callq 0x313e6
movl 0x74(%rbx), %eax
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31202
nop