LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::alloc()
T* alloc() {
		if(!lazyInit()) return NULL;
		if(cur_ + 1 >= lim_) {
			if(!allocNextPool()) return NULL;
		}
		cur_ ++;
		return &pools_[curPool_][cur_ - 1];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x41180
testb $0x1, %al
jne 0x40bc7
movq $0x0, -0x8(%rbp)
jmp 0x40c2a
movq -0x18(%rbp), %rcx
movl 0x5c(%rcx), %eax
addl $0x1, %eax
cmpl 0x58(%rcx), %eax
jb 0x40bef
movq -0x18(%rbp), %rdi
callq 0x412d0
testb $0x1, %al
jne 0x40bed
movq $0x0, -0x8(%rbp)
jmp 0x40c2a
jmp 0x40bef
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movq %rax, %rdi
addq $0x10, %rdi
movl 0x30(%rax), %eax
movl %eax, %esi
callq 0x41420
movq -0x18(%rbp), %rcx
movq (%rax), %rax
movl 0x5c(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<Branch>::lazyInit()
bool lazyInit() {
		if(cur_ == 0 && pools_.empty()) {
			T *pool;
			try {
				if((pool = (T*)pool_->alloc()) == NULL) {
					throw std::bad_alloc();
				}
			} catch(std::bad_alloc& e) {
				ThreadSafe _ts(&gLock);
				pool_->exhausted();
				return false;
			}
			pools_.push_back(pool);
			assert_eq(1, pools_.size());
		}
		assert(!pools_.empty());
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, 0x5c(%rax)
jne 0x412a6
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
callq 0x41450
testb $0x1, %al
jne 0x411b4
jmp 0x412a6
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x41470
movq %rax, -0x48(%rbp)
jmp 0x411c6
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x41267
movl $0x8, %edi
callq 0xa290
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x32260
movq -0x50(%rbp), %rdi
movq 0x66dc7(%rip), %rsi     # 0xa7fc0
movq 0x66d88(%rip), %rdx     # 0xa7f88
callq 0xab10
jmp 0x412c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x412b5
movq -0x20(%rbp), %rdi
callq 0xa200
movq %rax, -0x30(%rbp)
leaq 0x6a11e(%rip), %rsi     # 0xab358
leaq -0x38(%rbp), %rdi
callq 0x2f3b0
jmp 0x41245
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x399e0
jmp 0x41253
movb $0x0, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2f3e0
callq 0xaa60
jmp 0x412aa
jmp 0x41295
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4128c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2f3e0
callq 0xaa60
jmp 0x41293
jmp 0x412b5
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x41630
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xab60
movq %rax, %rdi
callq 0x24d00
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rdi
callq 0x41470
movq %rax, -0x40(%rbp)
jmp 0x412f2
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x41393
movl $0x8, %edi
callq 0xa290
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x32260
movq -0x50(%rbp), %rdi
movq 0x66c9b(%rip), %rsi     # 0xa7fc0
movq 0x66c5c(%rip), %rdx     # 0xa7f88
callq 0xab10
jmp 0x4141a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x41409
movq -0x20(%rbp), %rdi
callq 0xa200
movq %rax, -0x30(%rbp)
leaq 0x69ff2(%rip), %rsi     # 0xab358
leaq -0x38(%rbp), %rdi
callq 0x2f3b0
jmp 0x41371
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x399e0
jmp 0x4137f
movb $0x0, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2f3e0
callq 0xaa60
jmp 0x413fe
jmp 0x413c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x413b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2f3e0
callq 0xaa60
jmp 0x413bf
jmp 0x41409
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x41630
movq -0x48(%rbp), %rsi
movq %rsi, %rdi
addq $0x38, %rdi
addq $0x5c, %rsi
callq 0x32160
movq -0x48(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movl $0x0, 0x5c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xab60
movq %rax, %rdi
callq 0x24d00
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./pool.h
// Function: ChunkPool::alloc()
void* alloc() {
		assert_lt(cur_, lim_);
		uint32_t cur = cur_;
		while(bits_.test(cur)) {
			cur++;
			if(cur >= lim_) {
				cur = 0;
			}
			if(cur == cur_) {
				// Wrapped all the way around without finding a free
				// chunk
				return NULL;
			}
		}
		void * ptr = (void *)(&pool_[cur * chunkSz_]);
		assert(!bits_.test(cur));
		bits_.set(cur);
		assert(bits_.test(cur));
		if(verbose) {
			stringstream ss;
			ss << patid << ": Allocating chunk with offset: " << cur;
			glog.msg(ss.str());
		}
		cur_ = cur;
		return ptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x1e0(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x416a0
testb $0x1, %al
jne 0x414a9
jmp 0x414e6
movq -0x1e0(%rbp), %rcx
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jb 0x414c8
movl $0x0, -0x14(%rbp)
movq -0x1e0(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jne 0x414e4
movq $0x0, -0x8(%rbp)
jmp 0x4160e
jmp 0x41490
movq -0x1e0(%rbp), %rdi
movq 0x8(%rdi), %rax
movl -0x14(%rbp), %ecx
imull 0x14(%rdi), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x416e0
movq -0x1e0(%rbp), %rax
testb $0x1, (%rax)
je 0x415f9
leaq -0x1a8(%rbp), %rdi
callq 0xa3f0
movq -0x1e0(%rbp), %rax
leaq -0x198(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0xa810
movq %rax, -0x1e8(%rbp)
jmp 0x41548
movq -0x1e8(%rbp), %rdi
leaq 0x4b720(%rip), %rsi     # 0x8cc76
callq 0xa5d0
movq %rax, -0x1f0(%rbp)
jmp 0x41564
movq -0x1f0(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa810
jmp 0x41575
leaq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xa5c0
jmp 0x4158a
leaq 0x6a240(%rip), %rdi     # 0xab7d1
leaq -0x1d8(%rbp), %rsi
callq 0x41740
jmp 0x4159f
leaq -0x1d8(%rbp), %rdi
callq 0xacd8
leaq -0x1a8(%rbp), %rdi
callq 0xa440
jmp 0x415f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x415eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xacd8
leaq -0x1a8(%rbp), %rdi
callq 0xa440
jmp 0x4161b
movq -0x1e0(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0xab60
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset2::test(unsigned int) const
bool test(TIndexOffU i) const {
		bool ret = false;
		assert_lt(i, len_);
		ret = ((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) != 0;
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0xd(%rbp)
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
andl $0x1f, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./bitset.h
// Function: FixedBitset2::set(unsigned int)
void set(TIndexOffU i) {
		// Fast path
		assert_lt(i, len_);
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 0);
		_words[i / WORD_SIZE] |= ((TIndexOffU)1 << (i & BITSET_MASK));
		_cnt++;
		if(i >= _size) {
			_size = i+1;
		}
		assert(((_words[i / WORD_SIZE] >> (i & BITSET_MASK)) & 1) == 1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
andl $0x1f, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rax
movl -0xc(%rbp), %edx
shrl $0x5, %edx
movl %edx, %edx
orl (%rax,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jb 0x41734
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x24f80
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x8(%rax), %eax
addl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x41b07
movq -0x20(%rbp), %rax
movzwl 0x8(%rax), %eax
addl -0x34(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x85(%rax)
je 0x41a87
movb $0x1, %al
movb %al, -0x35(%rbp)
jmp 0x41a91
movq -0x20(%rbp), %rax
movb 0xa(%rax), %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0xa(%rax)
movq -0x28(%rbp), %rax
movzwl 0x8(%rax), %eax
sarl $0x2, %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0xc(%rax)
movq -0x28(%rbp), %rax
testb $0x1, 0xa(%rax)
jne 0x41ad9
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movswl 0xc(%rcx), %ecx
subl %ecx, %eax
subl $0x1, %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0xc(%rax)
movq -0x28(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0xe(%rax)
movq -0x28(%rbp), %rax
testb $0x1, 0xa(%rax)
jne 0x41b05
movq -0x28(%rbp), %rax
movsbl 0xe(%rax), %ecx
xorl $0x3, %ecx
movb %cl, 0xe(%rax)
jmp 0x41b1b
movq -0x28(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x24f80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::allocC(unsigned int)
T* allocC(uint32_t num) {
		T* t = alloc(num);
		if(t != NULL) {
			memset(t, 0, sizeof(T) * num);
		}
		return t;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x41dd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x41b88
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
imulq $0x30, %rax, %rdx
xorl %esi, %esi
callq 0xa2c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x6, (%rax)
jae 0x41c36
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rax)
movl (%rdx), %edx
movl %edx, 0x8(%rax,%rcx,4)
jmp 0x41d3f
movq -0x30(%rbp), %rax
cmpq $0x6, (%rax)
jne 0x41c88
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x423f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x41c69
movb $0x0, -0x1(%rbp)
jmp 0x41d43
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x20(%rax), %rcx
movl (%rdx), %edx
movl %edx, (%rcx)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x41d3d
movq -0x30(%rbp), %rax
cmpq $0x16, (%rax)
jae 0x41cb9
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x20(%rax), %rcx
movq (%rax), %rdx
subq $0x6, %rdx
movl (%rsi), %esi
movl %esi, (%rcx,%rdx,4)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x41d3b
movq -0x30(%rbp), %rax
cmpq $0x16, (%rax)
jne 0x41d13
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
addl $0xa, %eax
movl %eax, %eax
subq $0x10, %rax
subq $0x6, %rax
movl %eax, %esi
callq 0x423f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
jne 0x41cf7
movb $0x0, -0x1(%rbp)
jmp 0x41d43
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x28(%rax), %rcx
movl (%rdx), %edx
movl %edx, (%rcx)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x41d39
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x28(%rax), %rcx
movq (%rax), %rdx
subq $0x6, %rdx
subq $0x10, %rdx
movl (%rsi), %esi
movl %esi, (%rcx,%rdx,4)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x41d3b
jmp 0x41d3d
jmp 0x41d3f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./range_source.h
// Function: EditList::get(unsigned long) const
const Edit& get(size_t i) const {
		assert_lt(i, sz_);
		if(i < numEdits) {
			return edits_[i];
		} else if(i < (numEdits + numMoreEdits)) {
			assert(moreEdits_ != NULL);
			return moreEdits_[i-numEdits];
		} else {
			assert(moreEdits_ != NULL);
			assert(yetMoreEdits_ != NULL);
			return yetMoreEdits_[i-numEdits-numMoreEdits];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x6, -0x18(%rbp)
jae 0x41d84
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x41dc7
cmpq $0x16, -0x18(%rbp)
jae 0x41da8
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x6, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x41dc7
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x6, %rcx
subq $0x10, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./pool.h
// Function: AllocOnlyPool<RangeState>::alloc(unsigned int)
T* alloc(uint32_t num) {
		if(!lazyInit()) return NULL;
		if(cur_ + num >= lim_) {
			if(!allocNextPool()) return NULL;
			assert_eq(0, cur_);
		}
		assert_leq(num, lim_);
		cur_ += num;
		return &pools_[curPool_][cur_ - num];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x41e70
testb $0x1, %al
jne 0x41dfa
movq $0x0, -0x8(%rbp)
jmp 0x41e5a
movq -0x20(%rbp), %rcx
movl 0x5c(%rcx), %eax
addl -0x14(%rbp), %eax
cmpl 0x58(%rcx), %eax
jb 0x41e22
movq -0x20(%rbp), %rdi
callq 0x41fc0
testb $0x1, %al
jne 0x41e20
movq $0x0, -0x8(%rbp)
jmp 0x41e5a
jmp 0x41e22
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl 0x5c(%rax), %ecx
movl %ecx, 0x5c(%rax)
movq %rax, %rdi
addq $0x10, %rdi
movl 0x30(%rax), %eax
movl %eax, %esi
callq 0x42110
movq -0x20(%rbp), %rcx
movq (%rax), %rax
movl 0x5c(%rcx), %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./range_source.h
// Function: BranchQueue::front()
Branch *front() {
		Branch *b = branchQ_.top();
		if(verbose_) {
			stringstream ss;
			ss << patid_ << ": Fronting " << b->id_ << ", " << b << ", " << b->cost_ << ", " << b->exhausted_ << ", " << b->curtailed_ << ", " << sz_ << "->" << (sz_-1);
			glog.msg(ss.str());
		}
		return b;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
addq $0x8, %rdi
callq 0x43be0
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
testb $0x1, 0x2c(%rax)
je 0x42f2f
leaq -0x198(%rbp), %rdi
callq 0xa3f0
movq -0x1d0(%rbp), %rax
leaq -0x188(%rbp), %rdi
movl 0x28(%rax), %esi
callq 0xa810
movq %rax, -0x1d8(%rbp)
jmp 0x42d19
movq -0x1d8(%rbp), %rdi
leaq 0x49f98(%rip), %rsi     # 0x8ccbf
callq 0xa5d0
movq %rax, -0x1e0(%rbp)
jmp 0x42d35
movq -0x1e0(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xa810
movq %rax, -0x1e8(%rbp)
jmp 0x42d50
movq -0x1e8(%rbp), %rdi
leaq 0x474f3(%rip), %rsi     # 0x8a251
callq 0xa5d0
movq %rax, -0x1f0(%rbp)
jmp 0x42d6c
movq -0x1f0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa490
movq %rax, -0x1f8(%rbp)
jmp 0x42d85
movq -0x1f8(%rbp), %rdi
leaq 0x474be(%rip), %rsi     # 0x8a251
callq 0xa5d0
movq %rax, -0x200(%rbp)
jmp 0x42da1
movq -0x200(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %esi
callq 0xaab0
movq %rax, -0x208(%rbp)
jmp 0x42dbe
movq -0x208(%rbp), %rdi
leaq 0x47485(%rip), %rsi     # 0x8a251
callq 0xa5d0
movq %rax, -0x210(%rbp)
jmp 0x42dda
movq -0x210(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x83(%rax), %esi
andl $0x1, %esi
callq 0xab80
movq %rax, -0x218(%rbp)
jmp 0x42dfd
movq -0x218(%rbp), %rdi
leaq 0x47446(%rip), %rsi     # 0x8a251
callq 0xa5d0
movq %rax, -0x220(%rbp)
jmp 0x42e19
movq -0x220(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x82(%rax), %esi
andl $0x1, %esi
callq 0xab80
movq %rax, -0x228(%rbp)
jmp 0x42e3c
movq -0x228(%rbp), %rdi
leaq 0x47407(%rip), %rsi     # 0x8a251
callq 0xa5d0
movq %rax, -0x230(%rbp)
jmp 0x42e58
movq -0x230(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movl (%rax), %esi
callq 0xa810
movq %rax, -0x238(%rbp)
jmp 0x42e76
movq -0x238(%rbp), %rdi
leaq 0x49e1e(%rip), %rsi     # 0x8cca2
callq 0xa5d0
movq %rax, -0x240(%rbp)
jmp 0x42e92
movq -0x240(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movl (%rax), %esi
decl %esi
callq 0xa810
jmp 0x42eab
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa5c0
jmp 0x42ec0
leaq 0x6890a(%rip), %rdi     # 0xab7d1
leaq -0x1c8(%rbp), %rsi
callq 0x41740
jmp 0x42ed5
leaq -0x1c8(%rbp), %rdi
callq 0xacd8
leaq -0x198(%rbp), %rdi
callq 0xa440
jmp 0x42f2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x42f21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xacd8
leaq -0x198(%rbp), %rdi
callq 0xa440
jmp 0x42f3c
movq -0x10(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0xab60
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x82(%rcx)
movb %al, -0x23(%rbp)
jne 0x43ab3
movq -0x18(%rbp), %rax
movb 0x83(%rax), %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x82(%rcx)
movb %al, -0x24(%rbp)
jne 0x43ada
movq -0x20(%rbp), %rax
movb 0x83(%rax), %al
movb %al, -0x24(%rbp)
movb -0x24(%rbp), %al
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0x43b8c
testb $0x1, -0x22(%rbp)
je 0x43b0f
testb $0x1, -0x21(%rbp)
jne 0x43b0f
movb $0x0, -0x1(%rbp)
jmp 0x43ba6
testb $0x1, -0x21(%rbp)
je 0x43b24
testb $0x1, -0x22(%rbp)
jne 0x43b24
movb $0x1, -0x1(%rbp)
jmp 0x43ba6
movq -0x18(%rbp), %rdi
callq 0x43bc0
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x43bc0
movw %ax, %cx
movl -0x28(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
je 0x43b76
movq -0x18(%rbp), %rdi
callq 0x43bc0
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x43bc0
movw %ax, %cx
movl -0x2c(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43ba6
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43ba6
movq -0x20(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::hhCheckTop(Branch*, unsigned int, unsigned int, unsigned long)
bool hhCheckTop(Branch* b,
	                uint32_t d,
	                uint32_t iham,
	                uint64_t prehits = 0xffffffffffffffffllu)
	{
		// Crossing from the hi-half into the lo-half
		ASSERT_ONLY(uint32_t lim3 = (offRev3_ == offRev2_)? 2 : 3);
		ASSERT_ONLY(uint32_t lim5 = (offRev1_ == offRev0_)? 2 : 1);
		const uint32_t nedits = (uint32_t)b->edits_.size();
		if(d == depth5_) {
			assert_leq(nedits, lim5);
			if(nedits == 0) {
				return false;
			}
		} else if(d == depth3_) {
			assert_leq(nedits, lim3);
			if(nedits < (uint32_t)halfAndHalf_) {
				return false;
			}
		}
#ifndef NDEBUG
		else {
			// We didn't just cross a boundary, so do an in-between check
			if(d >= depth5_) {
				assert_geq(nedits, 1);
			} else if(d >= depth3_) {
				assert_geq(nedits, lim3);
			}
		}
#endif
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x41bd0
movq -0x38(%rbp), %rcx
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x98(%rcx), %eax
jne 0x4451f
cmpl $0x0, -0x2c(%rbp)
jne 0x4451d
movb $0x0, -0x1(%rbp)
jmp 0x4454b
jmp 0x44547
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x9c(%rcx), %eax
jne 0x44545
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x90(%rcx), %eax
jae 0x44543
movb $0x0, -0x1(%rbp)
jmp 0x4454b
jmp 0x44545
jmp 0x44547
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movw 0x10(%rax), %ax
movw %ax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x98, %rsi
movl -0x18(%rbp), %edx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x452e0
movq -0x10(%rbp), %rax
testb $0x1, 0x83(%rax)
je 0x445ed
movq -0x30(%rbp), %rdi
callq 0x45530
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq %r8, %rdx
addq $0x98, %rdx
movq %r8, %rcx
addq $0xf8, %rcx
addq $0x38, %r8
callq 0x45580
jmp 0x44619
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
movzwl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
je 0x44617
movq -0x30(%rbp), %rdi
callq 0x45530
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x40ec0
jmp 0x44619
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::mapLFEx(SideLocus const&, SideLocus const&, unsigned int*, unsigned int*) const
inline void Ebwt::mapLFEx(const SideLocus& ltop,
                                const SideLocus& lbot,
                                TIndexOffU *tops,
                                TIndexOffU *bots
                                ASSERT_ONLY(, bool overrideSanity)
                                ) const
{
	// TODO: Where there's overlap, reuse the count for the overlapping
	// portion
#ifdef EBWT_STATS
	const_cast<Ebwt*>(this)->mapLFExs_++;
#endif
	assert_eq(0, tops[0]); assert_eq(0, bots[0]);
	assert_eq(0, tops[1]); assert_eq(0, bots[1]);
	assert_eq(0, tops[2]); assert_eq(0, bots[2]);
	assert_eq(0, tops[3]); assert_eq(0, bots[3]);
	if(ltop._fw) {
		 // Forward side
		!_eh._isBt2Index ? countFwSideEx(ltop, tops)
		                 : countBt2SideEx(ltop, tops);
	} else {
		countBwSideEx(ltop, tops); // Backward side
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0xa(%rax)
je 0x449d1
movq -0x30(%rbp), %rax
testb $0x1, 0x17d(%rax)
jne 0x449be
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x46c40
jmp 0x449cf
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x46d90
jmp 0x449e2
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x46f00
movq -0x18(%rbp), %rax
testb $0x1, 0xa(%rax)
je 0x44a1f
movq -0x30(%rbp), %rax
testb $0x1, 0x17d(%rax)
jne 0x44a0c
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x46c40
jmp 0x44a1d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x46d90
jmp 0x44a30
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x46f00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::mapLF1(unsigned int&, SideLocus const&) const
inline int Ebwt::mapLF1(TIndexOffU& row, const SideLocus& l
                              ASSERT_ONLY(, bool overrideSanity)
                              ) const
{
#ifdef EBWT_STATS
	const_cast<Ebwt*>(this)->mapLF1s_++;
#endif
	if(row == _zOff) return -1;
	int c = rowL(l);
	assert_lt(c, 4);
	assert_geq(c, 0);
	if(l._fw) {
		// Forward side
		row = !_eh._isBt2Index ? countFwSide(l, c)
		                       : countBt2Side(l, c);
	} else {
		row = countBwSide(l, c); // Backward side
	}
	assert_lt(row, this->_eh._bwtLen);
#ifndef NDEBUG
	if(_sanity && !overrideSanity) {
		// Make sure results match up with results from mapLFEx;
		// be sure to override sanity-checking in the callee, or we'll
		// have infinite recursion
		TIndexOffU arrs[] = { 0, 0, 0, 0 };
		mapLFEx(l, arrs, true);
		assert_eq(arrs[c], row);
	}
#endif
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl 0x68(%rcx), %eax
jne 0x44a70
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44ae8
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x24f10
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0xa(%rax)
je 0x44aca
movq -0x30(%rbp), %rax
testb $0x1, 0x17d(%rax)
jne 0x44aac
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x27510
movl %eax, -0x34(%rbp)
jmp 0x44abf
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x27650
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x44ae2
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x27770
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/./ebwt.h
// Function: Ebwt::mapLF1(unsigned int, SideLocus const&, int) const
inline TIndexOffU Ebwt::mapLF1(TIndexOffU row, const SideLocus& l, int c
                                   ASSERT_ONLY(, bool overrideSanity)
                                   ) const
{
#ifdef EBWT_STATS
	const_cast<Ebwt*>(this)->mapLF1cs_++;
#endif
	if(rowL(l) != c || row == _zOff) return OFF_MASK;
	TIndexOffU ret;
	assert_lt(c, 4);
	assert_geq(c, 0);
	if(l._fw) {
		// Forward side
		ret = !_eh._isBt2Index ? countFwSide(l, c)
		                       : countBt2Side(l, c);
	} else {
		ret = countBwSide(l, c); // Backward side
	}
	assert_lt(ret, this->_eh._bwtLen);
#ifndef NDEBUG
	if(_sanity && !overrideSanity) {
		// Make sure results match up with results from mapLFEx;
		// be sure to override sanity-checking in the callee, or we'll
		// have infinite recursion
		TIndexOffU arrs[] = { 0, 0, 0, 0 };
		mapLFEx(l, arrs, true);
		assert_eq(arrs[c], ret);
	}
#endif
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x20(%rbp), %rsi
callq 0x24f10
cmpl -0x24(%rbp), %eax
jne 0x44b38
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x68(%rcx), %eax
jne 0x44b41
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44ba1
movq -0x20(%rbp), %rax
testb $0x1, 0xa(%rax)
je 0x44b88
movq -0x30(%rbp), %rax
testb $0x1, 0x17d(%rax)
jne 0x44b6d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x27510
movl %eax, -0x34(%rbp)
jmp 0x44b80
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x27650
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x44b9b
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x27770
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x48280
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x482d0
movq -0x18(%rbp), %rdi
addq $0xf8, %rdi
callq 0x48320
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
callq 0x48370
movq -0x18(%rbp), %rax
movw $0x0, 0x158(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./range_source.h
// Function: PathManager::pop()
Branch* pop() {
		Branch* b = branchQ_.pop();
		assert_gt(b->depth3_, 0);
#ifndef NDEBUG
		// Also remove it from the set
		assert(branchSet_.find(b) != branchSet_.end());
		ASSERT_ONLY(size_t setSz = branchSet_.size());
		branchSet_.erase(branchSet_.find(b));
		assert_eq(setSz-1, branchSet_.size());
		if(!branchQ_.empty()) {
			// Top shouldn't be b any more
			Branch *newtop = branchQ_.front();
			assert(b != newtop);
		}
#endif
		// Update this PathManager's cost
		minCost = branchQ_.front()->cost_;
		assert(repOk());
		return b;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x45c90
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x42cb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movw 0x10(%rcx), %cx
movw %cx, 0x158(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x50, %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x46370
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x455e7
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x18(%rax), %rsi
movzwl 0x20(%rax), %edx
callq 0x45660
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movw $0x0, 0x20(%rax)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x463e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./range_source.h
// Function: Branch::eliminated(int) const
inline bool eliminated(int i) const {
		assert(!exhausted_);
		if(i <= len_ && i < rangesSz_) {
			assert(ranges_ != NULL);
#ifndef NDEBUG
			if(!ranges_[i].eliminated_) {
				// Someone must be as-yet-uneliminated
				assert(!ranges_[i].eq.flags.mmA ||
				       !ranges_[i].eq.flags.mmC ||
				       !ranges_[i].eq.flags.mmG ||
				       !ranges_[i].eq.flags.mmT);
				assert_lt(ranges_[i].eq.flags.quallo, 127);
			}
#endif
			return ranges_[i].eliminated_;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movzwl 0xe(%rcx), %ecx
cmpl %ecx, %eax
jg 0x4564a
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movzwl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4564a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x28(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4564e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq (%rax), %rax
testb $0x1, (%rax)
je 0x457c7
leaq -0x1a8(%rbp), %rdi
callq 0xa3f0
movq -0x1e0(%rbp), %rax
leaq -0x198(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0xa810
movq %rax, -0x1e8(%rbp)
jmp 0x456bb
movq -0x1e8(%rbp), %rdi
leaq 0x47647(%rip), %rsi     # 0x8cd10
callq 0xa5d0
movq %rax, -0x1f0(%rbp)
jmp 0x456d7
movq -0x1f0(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xa810
movq %rax, -0x1f8(%rbp)
jmp 0x456ef
movq -0x1f8(%rbp), %rdi
leaq 0x47a07(%rip), %rsi     # 0x8d104
callq 0xa5d0
movq %rax, -0x200(%rbp)
jmp 0x4570b
movq -0x200(%rbp), %rdi
movq -0x1e0(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa5d0
movq %rax, -0x208(%rbp)
jmp 0x4572b
movq -0x208(%rbp), %rdi
leaq 0x47ce0(%rip), %rsi     # 0x8d419
callq 0xa5d0
jmp 0x45740
leaq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xa5c0
jmp 0x45755
leaq 0x66075(%rip), %rdi     # 0xab7d1
leaq -0x1d8(%rbp), %rsi
callq 0x41740
jmp 0x4576a
leaq -0x1d8(%rbp), %rdi
callq 0xacd8
leaq -0x1a8(%rbp), %rdi
callq 0xa440
jmp 0x457c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x457b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xacd8
leaq -0x1a8(%rbp), %rdi
callq 0xa440
jmp 0x4586e
movq -0x1e0(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x5c(%rcx), %eax
ja 0x4585c
movq -0x1e0(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x210(%rbp)
movq %rax, %rdi
addq $0x10, %rdi
movl 0x30(%rax), %eax
movl %eax, %esi
callq 0x42110
movq -0x1e0(%rbp), %rdx
movq %rax, %rcx
movq -0x210(%rbp), %rax
movq (%rcx), %rcx
movl 0x5c(%rdx), %edx
subl -0x1c(%rbp), %edx
movl %edx, %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x4585c
movq -0x1e0(%rbp), %rax
movl -0x1c(%rbp), %edx
movl 0x5c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x5c(%rax)
cmpl $0x0, 0x5c(%rax)
jne 0x45856
movq -0x1e0(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jbe 0x45856
movq -0x1e0(%rbp), %rdi
callq 0x45880
movb $0x1, -0x1(%rbp)
jmp 0x45860
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0xab60
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq (%rax), %rax
testb $0x1, (%rax)
je 0x459a9
leaq -0x190(%rbp), %rdi
callq 0xa3f0
movq -0x1c8(%rbp), %rax
leaq -0x180(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0xa810
movq %rax, -0x1d0(%rbp)
jmp 0x458d4
movq -0x1d0(%rbp), %rdi
leaq 0x47439(%rip), %rsi     # 0x8cd1b
callq 0xa5d0
movq %rax, -0x1d8(%rbp)
jmp 0x458f0
movq -0x1d8(%rbp), %rdi
movq -0x1c8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa5d0
movq %rax, -0x1e0(%rbp)
jmp 0x45910
movq -0x1e0(%rbp), %rdi
leaq 0x4740a(%rip), %rsi     # 0x8cd28
callq 0xa5d0
jmp 0x45925
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xa5c0
jmp 0x4593a
leaq 0x65e90(%rip), %rdi     # 0xab7d1
leaq -0x1c0(%rbp), %rsi
callq 0x41740
jmp 0x4594f
leaq -0x1c0(%rbp), %rdi
callq 0xacd8
leaq -0x190(%rbp), %rdi
callq 0xa440
jmp 0x459a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x4599b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xacd8
leaq -0x190(%rbp), %rdi
callq 0xa440
jmp 0x45a19
movq -0x1c8(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x1e8(%rbp)
addq $0x10, %rdi
callq 0x45b90
movq -0x1e8(%rbp), %rdi
movq (%rax), %rsi
callq 0x45a30
movq -0x1c8(%rbp), %rdi
addq $0x10, %rdi
callq 0x45bc0
movq -0x1c8(%rbp), %rdi
movl 0x30(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x30(%rdi)
addq $0x38, %rdi
callq 0x45be0
movq -0x1c8(%rbp), %rdi
movl (%rax), %eax
movl %eax, 0x5c(%rdi)
addq $0x38, %rdi
callq 0x45c10
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rax), %rdx
subq %rdx, %rcx
movl %ecx, -0x14(%rbp)
movl 0x14(%rax), %ecx
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x1d8(%rbp), %rax
movl %ecx, -0x14(%rbp)
testb $0x1, (%rax)
je 0x45b5e
leaq -0x1a0(%rbp), %rdi
callq 0xa3f0
movq -0x1d8(%rbp), %rax
leaq -0x190(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0xa810
movq %rax, -0x1e0(%rbp)
jmp 0x45aa6
movq -0x1e0(%rbp), %rdi
leaq 0x4727a(%rip), %rsi     # 0x8cd2e
callq 0xa5d0
movq %rax, -0x1e8(%rbp)
jmp 0x45ac2
movq -0x1e8(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xa810
jmp 0x45ada
leaq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xa5c0
jmp 0x45aef
leaq 0x65cdb(%rip), %rdi     # 0xab7d1
leaq -0x1d0(%rbp), %rsi
callq 0x41740
jmp 0x45b04
leaq -0x1d0(%rbp), %rdi
callq 0xacd8
leaq -0x1a0(%rbp), %rdi
callq 0xa440
jmp 0x45b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x45b50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xacd8
leaq -0x1a0(%rbp), %rdi
callq 0xa440
jmp 0x45b7a
movq -0x1d8(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x45c30
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x463b7
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
addl $0xa, %eax
movl %eax, %eax
subq $0x10, %rax
subq $0x6, %rax
movl %eax, %edx
callq 0x465a0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x463d8
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rsi
movl $0x10, %edx
callq 0x465a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq (%rax), %rax
testb $0x1, (%rax)
je 0x464f4
leaq -0x198(%rbp), %rdi
callq 0xa3f0
movq -0x1d0(%rbp), %rax
leaq -0x188(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0xa810
movq %rax, -0x1d8(%rbp)
jmp 0x46438
movq -0x1d8(%rbp), %rdi
leaq 0x468d5(%rip), %rsi     # 0x8cd1b
callq 0xa5d0
movq %rax, -0x1e0(%rbp)
jmp 0x46454
movq -0x1e0(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa5d0
jmp 0x4646d
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa5c0
jmp 0x46482
leaq 0x65348(%rip), %rdi     # 0xab7d1
leaq -0x1c8(%rbp), %rsi
callq 0x41740
jmp 0x46497
leaq -0x1c8(%rbp), %rdi
callq 0xacd8
leaq -0x198(%rbp), %rdi
callq 0xa440
jmp 0x464f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x464e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xacd8
leaq -0x198(%rbp), %rdi
callq 0xa440
jmp 0x46589
movq -0x1d0(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jbe 0x46580
movq -0x1d0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x1e8(%rbp)
movq %rax, %rdi
addq $0x10, %rdi
movl 0x30(%rax), %eax
movl %eax, %esi
callq 0x41420
movq -0x1d0(%rbp), %rdx
movq %rax, %rcx
movq -0x1e8(%rbp), %rax
movq (%rcx), %rcx
movl 0x5c(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x88, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x46580
movq -0x1d0(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x5c(%rax)
cmpl $0x0, 0x5c(%rax)
jne 0x4657e
movq -0x1d0(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jbe 0x4657e
movq -0x1d0(%rbp), %rdi
callq 0x469c0
jmp 0x46580
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
nop