// File: /workspace/github_cpp_makefile_star2_O3/BenLangmead[P]bowtie/./ebwt_search_backtrack.h
// Function: EbwtRangeSource::advanceBranch(int, unsigned short, PathManager&)
virtual void
	advanceBranch(int until, uint16_t minCost, PathManager& pm) {
		assert(curEbwt_ != NULL);

		// Let this->foundRange = false; we'll set it to true iff this call
		// to advance yielded a new valid-alignment range.
		this->foundRange = false;

		// Can't have already exceeded weighted hamming distance threshold
		assert_gt(qry_->length(), 0);
		assert_leq(qlen_, qry_->length());
		assert_geq(qual_->length(), qry_->length());
		assert(!pm.empty());

		do {
			assert(pm.repOk());
			// Get the highest-priority branch according to the priority
			// queue in 'pm'
			Branch* br = pm.front();
			// Shouldn't be curtailed or exhausted
			assert(!br->exhausted_);
			assert(!br->curtailed_);
			assert_gt(br->depth3_, 0);
			assert_leq(br->ham_, qualLim_);
			if(verbose_) {
				br->print(*qry_, *qual_, minCost, cout, (halfAndHalf_>0), partial_, fw_, ebwt_->fw());
				if(!br->edits_.empty()) {
					cout << "Edit: ";
					for(size_t i = 0; i < br->edits_.size(); i++) {
						Edit e = br->edits_.get(i);
						cout << (curEbwt_->fw() ? (qlen_ - e.pos - 1) : e.pos)
							 << (char)e.chr;
						if(i < br->edits_.size()-1) cout << " ";
					}
					cout << endl;
				}

			}
			assert(br->repOk((uint32_t)qlen_));

			ASSERT_ONLY(int stratum = br->cost_ >> 14); // shift the stratum over
			assert_lt(stratum, 4);
			// Not necessarily true with rounding
			uint32_t depth = br->tipDepth();

			const Ebwt& ebwt = *ebwt_;

			if(halfAndHalf_ > 0) assert_gt(depth3_, depth5_);

			bool reportedPartial = false;
			bool invalidExact = false;
			bool empty = false;
			bool hit = false;
			uint16_t cost = br->cost_;
			uint32_t cur = 0;
			uint32_t nedits = 0;

			if(halfAndHalf_ && !hhCheckTop(br, depth, 0)) {
				// Stop extending this branch because it violates a half-
				// and-half constraint
				if(metrics_ != NULL) metrics_->curBacktracks_++;
				pm.curtail(br, (uint32_t)qlen_, depth3_, qualOrder_);
				goto bail;
			}

			cur = (uint32_t)(qlen_ - depth - 1); // current offset into qry_
			if(depth < qlen_) {
				// Determine whether ranges at this location are candidates
				// for backtracking
				int c = (int)(*qry_)[cur]; // get char at this position
				int nextc = -1;
				if(cur < qlen_-1) nextc = (int)(*qry_)[cur+1];
				assert_leq(c, 4);
				// If any uncalled base's penalty is still under
				// the ceiling, then this position is an alternative
				uint8_t q[4] = {'!', '!', '!', '!'};
				uint8_t bestq;
				// get unrounded penalties at this position
				bestq = q[0] = q[1] = q[2] = q[3] =
					mmPenalty(maqPenalty_, qualAt(cur));

				// The current query position is a legit alternative if it a) is
				// not in the unrevisitable region, and b) its selection would
				// not necessarily cause the quality ceiling (if one exists) to
				// be exceeded
				bool curIsAlternative = (depth >= br->depth0_) &&
				                        (br->ham_ + bestq <= qualLim_);
				ASSERT_ONLY(TIndexOffU obot = br->bot_);
				TIndexOffU otop = br->top_;

				// If c is 'N', then it's a mismatch
				if(c == 4 && depth > 0) {
					// Force the 'else if(curIsAlternative)' or 'else'
					// branches below
					br->top_ = br->bot_ = 1;
				} else if(c == 4) {
					// We'll take the 'if(br->top == 0 && br->bot == 0)'
					// branch below
					assert_eq(0, br->top_);
					assert_eq(0, br->bot_);
				}

				// Get the range state for the current position
				RangeState *rs = br->rangeState();
				assert(rs != NULL);
				// Calculate the ranges for this position
				if(br->top_ == 0 && br->bot_ == 0) {
					// Calculate first quartet of ranges using the _fchr[]
					// array
								  rs->tops[0] = ebwt._fchr[0];
					rs->bots[0] = rs->tops[1] = ebwt._fchr[1];
					rs->bots[1] = rs->tops[2] = ebwt._fchr[2];
					rs->bots[2] = rs->tops[3] = ebwt._fchr[3];
					rs->bots[3]               = ebwt._fchr[4];
					ASSERT_ONLY(int r =)
					br->installRanges(c, nextc, qualLim_ - br->ham_, q);
					assert(r < 4 || c == 4);
					// Update top and bot
					if(c < 4) {
						br->top_ = rs->tops[c];
						br->bot_ = rs->bots[c];
					}
				} else if(curIsAlternative && (br->bot_ > br->top_ || c == 4)) {
					// Calculate next quartet of ranges.  We hope that the
					// appropriate cache lines are prefetched.
					assert(br->ltop_.valid());
								  rs->tops[0] =
					rs->bots[0] = rs->tops[1] =
					rs->bots[1] = rs->tops[2] =
					rs->bots[2] = rs->tops[3] =
					rs->bots[3]               = 0;
					if(br->lbot_.valid()) {
						if(metrics_ != NULL) metrics_->curBwtOps_++;
						ebwt.mapLFEx(br->ltop_, br->lbot_, (TIndexOffU*)rs->tops, (TIndexOffU*)rs->bots);
					} else {
#ifndef NDEBUG
						TIndexOffU tmptops[] = {0, 0, 0, 0};
						TIndexOffU tmpbots[] = {0, 0, 0, 0};
						SideLocus ltop, lbot;
						ltop.initFromRow(otop, ebwt_->_eh, ebwt_->_ebwt);
						lbot.initFromRow(obot, ebwt_->_eh, ebwt_->_ebwt);
						ebwt.mapLFEx(ltop, lbot, tmptops, tmpbots);
#endif
						if(metrics_ != NULL) metrics_->curBwtOps_++;
						int cc = ebwt.mapLF1((TIndexOffU&)otop, br->ltop_);
						br->top_ = otop;
						assert(cc == -1 || (cc >= 0 && cc < 4));
						if(cc >= 0) {
							assert_lt(cc, 4);
							rs->tops[cc] = br->top_;
							rs->bots[cc] = (br->top_ + 1);
						}
#ifndef NDEBUG
						for(int i = 0; i < 4; i++) {
							assert_eq(tmpbots[i] - tmptops[i],
							          rs->bots[i] - rs->tops[i]);
						}
#endif
					}
					ASSERT_ONLY(int r =)
					br->installRanges(c, nextc, qualLim_ - br->ham_, q);
					assert(r < 4 || c == 4);
					// Update top and bot
					if(c < 4) {
						br->top_ = rs->tops[c];
						br->bot_ = rs->bots[c];
					} else {
						br->top_ = br->bot_ = 1;
					}
				} else if(br->bot_ > br->top_) {
					// This read position is not a legitimate backtracking
					// alternative.  No need to do the bookkeeping for the
					// entire quartet, just do c.  We hope that the
					// appropriate cache lines are prefetched before now;
					// otherwise, we're about to take an expensive cache
					// miss.
					assert(br->ltop_.valid());
					rs->eliminated_ = true; // eliminate all alternatives leaving this node
					assert(br->eliminated(br->len_));
					if(c < 4) {
						if(br->top_ + 1 == br->bot_) {
							if(metrics_ != NULL) metrics_->curBwtOps_++;
							br->bot_ = br->top_ = ebwt.mapLF1(br->top_, br->ltop_, c);
							if(br->bot_ != OFF_MASK) br->bot_++;
						} else {
							if(metrics_ != NULL) metrics_->curBwtOps_++;
							br->top_ = ebwt.mapLF(br->ltop_, c);
							assert(br->lbot_.valid());
							if(metrics_ != NULL) metrics_->curBwtOps_++;
							br->bot_ = ebwt.mapLF(br->lbot_, c);
						}
					}
				} else {
					rs->eliminated_ = true;
				}
				assert(rs->repOk());
				// br->top_ and br->bot_ now contain the next top and bot
			} else {
				// The continuation had already processed the whole read
				assert_eq(qlen_, depth);
				cur = 0;
			}
			empty = (br->top_ == br->bot_);
			hit = (cur == 0 && !empty);

			// Check whether we've obtained an exact alignment when
			// we've been instructed not to report exact alignments
			nedits = (uint32_t)br->edits_.size();
			invalidExact = (hit && nedits == 0 && !reportExacts_);
			assert_leq(br->ham_, qualLim_);

			// Set this to true if the only way to make legal progress
			// is via one or more additional backtracks.
			if(halfAndHalf_ && !hhCheck(br, depth, empty)) {
				// This alignment doesn't satisfy the half-and-half
				// requirements; reject it
				if(metrics_ != NULL) metrics_->curBacktracks_++;
				pm.curtail(br, (uint32_t)qlen_, depth3_, qualOrder_);
				goto bail;
			}

			if(hit &&            // there is a range to report
			   !invalidExact &&  // not disqualified by no-exact-hits setting
			   !reportedPartial) // not an already-reported partial alignment
			{
				if(verbose_) {
					if(partial_) {
						cout << " Partial alignment:" << endl;
					} else {
						cout << " Final alignment:" << endl;
					}
					br->len_++;
					br->print((*qry_), (*qual_), minCost, cout, halfAndHalf_ > 0, partial_, fw_, ebwt_->fw());
					br->len_--;
					cout << endl;
				}
				assert_gt(br->bot_, br->top_);
				assert_leq(br->ham_, qualLim_);
				assert_leq((uint32_t)(br->cost_ & ~0xc000), qualLim_);
				if(metrics_ != NULL) metrics_->setReadHasRange();
				curRange_.top     = br->top_;
				curRange_.bot     = br->bot_;
				curRange_.cost    = br->cost_;
				curRange_.stratum = (br->cost_ >> 14);
				curRange_.numMms  = nedits;
				curRange_.fw      = fw_;
				curRange_.mms.clear();
				curRange_.refcs.clear();
				for(size_t i = 0; i < nedits; i++) {
					curRange_.mms.push_back((uint32_t)(qlen_ - br->edits_.get(i).pos - 1));
					curRange_.refcs.push_back((char)br->edits_.get(i).chr);
				}
				addPartialEdits();
				curRange_.ebwt    = ebwt_;
				this->foundRange  = true;
	#ifndef NDEBUG
				TIndexOff top2 = (TIndexOff)br->top_;
				top2++; // ensure it's not 0
				if(ebwt_->fw()) top2 = -top2;
				assert(allTops_.find(top2) == allTops_.end());
				allTops_.insert(top2);
	#endif
				assert(curRange_.repOk());
				// Must curtail because we've consumed the whole pattern
				if(metrics_ != NULL) metrics_->curBacktracks_++;
				pm.curtail(br, (uint32_t)qlen_, depth3_, qualOrder_);
			} else if(empty || cur == 0) {
				// The branch couldn't be extended further
				if(metrics_ != NULL) metrics_->curBacktracks_++;
				pm.curtail(br, (uint32_t)qlen_, depth3_, qualOrder_);
			} else {
				// Extend the branch by one position; no change to its cost
				// so there's no need to reconsider where it lies in the
				// priority queue
				assert_neq(0, cur);
				br->extend();
			}
		bail:
			// Make sure the front element of the priority queue is
			// extendable (i.e. not curtailed) and then prep it.
			if(!pm.splitAndPrep(rand_, (uint32_t)qlen_, qualLim_, depth3_,
			                    qualOrder_,
			                    ebwt_->_eh, ebwt_->_ebwt, ebwt_->_fw))
			{
				pm.reset(0);
				assert(pm.empty());
			}
			if(pm.empty()) {
				// No more branches
				break;
			}
			assert(!pm.front()->curtailed_);
			assert(!pm.front()->exhausted_);

			if(until == ADV_COST_CHANGES && pm.front()->cost_ != cost) break;
			else if(until == ADV_STEP) break;

		} while(!this->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
subq $0x58, %rsp
movq %rcx, %rbp
movl %esi, 0x38(%rsp)
movq %rdi, %r14
movb $0x0, 0x9(%rdi)
leaq 0xd0(%rdi), %rax
movq %rax, 0x50(%rsp)
leaq 0xf0(%rdi), %rax
movq %rax, 0x48(%rsp)
leaq 0xa0(%rdi), %rax
movq %rax, 0x40(%rsp)
movzwl %dx, %eax
movl %eax, 0x1c(%rsp)
movq 0x3f9f6(%rip), %rbx     # 0x69fb0
movq %rcx, 0x20(%rsp)
movq %rbp, %rdi
callq 0x2c500
movq %rax, %r13
cmpb $0x1, 0xb4(%r14)
movq %rax, (%rsp)
jne 0x2a741
movq 0x18(%r14), %rsi
movq 0x58(%r14), %rdx
xorl %r9d, %r9d
cmpl $0x0, 0x90(%r14)
setg %r9b
movzbl 0x94(%r14), %eax
movzbl 0x70(%r14), %r10d
movq 0x68(%r14), %rcx
movzbl 0x10(%rcx), %r11d
subq $0x8, %rsp
movq %r13, %rdi
movl 0x24(%rsp), %ecx
movq %rbx, %r8
pushq %r11
pushq %r10
pushq %rax
callq 0x2c92c
addq $0x20, %rsp
cmpq $0x0, 0x50(%r13)
je 0x2a741
movl $0x6, %edx
movq %rbx, %rdi
leaq 0x2b425(%rip), %rsi     # 0x55a64
callq 0x9560
cmpq $0x0, 0x50(%r13)
je 0x2a713
leaq 0x58(%r13), %rbx
movq $-0x58, %r15
xorl %r12d, %r12d
cmpq $0x5, %r12
ja 0x2a669
leaq (%rbx,%r12,4), %rax
jmp 0x2a684
cmpq $0x15, %r12
ja 0x2a67d
movq 0x70(%r13), %rax
leaq (%rax,%r12,4), %rax
addq $-0x18, %rax
jmp 0x2a684
movq 0x78(%r13), %rax
addq %r15, %rax
movl (%rax), %r13d
movq 0x10(%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0x2a6a7
movl %r13d, %eax
notl %eax
shrl $0x14, %eax
orl $0xfffffc00, %eax       # imm = 0xFFFFFC00
movslq %eax, %rsi
addq 0x50(%r14), %rsi
jmp 0x2a6b3
movl %r13d, %esi
shrl $0x14, %esi
andl $0x3ff, %esi            # imm = 0x3FF
movq 0x3f8f6(%rip), %rdi     # 0x69fb0
callq 0x92e0
movb %r13b, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xf(%rsp), %rsi
callq 0x9560
movq (%rsp), %r13
movq 0x50(%r13), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r12
jae 0x2a703
movl $0x1, %edx
movq 0x3f8bd(%rip), %rdi     # 0x69fb0
leaq 0x2b7a3(%rip), %rsi     # 0x55e9d
callq 0x9560
movq 0x50(%r13), %rax
incq %r12
addq $0x4, %r15
cmpq %rax, %r12
jb 0x2a65d
movq 0x3f896(%rip), %rbx     # 0x69fb0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
movzwl 0xe(%r13), %eax
movzwl 0xc(%r13), %ecx
addw %ax, %cx
movzwl %cx, %r10d
movq 0x68(%r14), %r11
movl 0x90(%r14), %edx
movzwl 0x10(%r13), %esi
movw %si, 0x1a(%rsp)
testl %edx, %edx
je 0x2a784
movl 0x50(%r13), %esi
cmpl %r10d, 0x98(%r14)
jne 0x2a81f
testl %esi, %esi
je 0x2a83d
movq 0x50(%r14), %rsi
movl %r10d, %edi
movb $0x1, %r8b
cmpq %rdi, %rsi
jbe 0x2ac42
movl %edi, %r13d
notl %r13d
addl %esi, %r13d
movq 0x18(%r14), %rdx
movq 0x8(%rdx), %r9
leaq -0x1(%rsi), %r8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %r8, %r13
jae 0x2a7bd
subl %edi, %esi
movsbl (%r9,%rsi), %edx
movsbl (%r9,%r13), %ebp
movl $0x21212121, 0x14(%rsp) # imm = 0x21212121
movq 0x58(%r14), %rsi
movq 0x8(%rsi), %rsi
movb (%rsi,%r13), %dil
leal -0x21(%rdi), %esi
cmpb $0x21, %dil
movzbl %sil, %edi
movl $0x0, %esi
cmovbl %esi, %edi
cmpb $0x1, 0x84(%r14)
jne 0x2a802
movzbl %dil, %edi
leaq 0x42302(%rip), %rsi     # 0x6cb00
movb (%rsi,%rdi), %dil
movzbl %dil, %edi
imull $0x1010101, %edi, %esi  # imm = 0x1010101
movl %esi, 0x14(%rsp)
movq (%rsp), %rsi
cmpw 0x4(%rsi), %cx
jae 0x2a86e
xorl %r15d, %r15d
jmp 0x2a87f
cmpl %r10d, 0x9c(%r14)
sete %dil
cmpl %esi, %edx
seta %sil
andb %dil, %sil
cmpb $0x1, %sil
jne 0x2a784
movq 0x180(%r14), %rax
testq %rax, %rax
je 0x2a84b
incl (%rax)
movl 0x50(%r14), %edx
movl 0x9c(%r14), %ecx
movzbl 0x85(%r14), %r8d
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2d050
jmp 0x2af99
movzwl 0x12(%rsi), %ecx
addl %edi, %ecx
cmpl 0x88(%r14), %ecx
setbe %r15b
movslq %ebp, %r12
movl 0x24(%rsi), %ecx
testl %r10d, %r10d
je 0x2a8b4
cmpb $0x4, %r12b
jne 0x2a8b4
movabsq $0x100000001, %rsi      # imm = 0x100000001
movq (%rsp), %rdi
movq %rsi, 0x24(%rdi)
leaq (%rax,%rax,2), %rbx
shll $0x4, %ebx
addq 0x18(%rdi), %rbx
movl $0x1, %eax
jmp 0x2a8d7
leaq (%rax,%rax,2), %rbx
shll $0x4, %ebx
movq (%rsp), %rdi
addq 0x18(%rdi), %rbx
testl %ecx, %ecx
je 0x2a8cb
movl %ecx, %eax
jmp 0x2a8d7
xorl %eax, %eax
cmpl $0x0, 0x28(%rdi)
je 0x2aa90
cmpb $0x4, %r12b
sete %r9b
movl 0x28(%rdi), %esi
cmpl %eax, %esi
seta %r8b
orb %r9b, %r8b
andb %r8b, %r15b
cmpb $0x1, %r15b
jne 0x2a942
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpb $-0x1, 0x4a(%rdi)
movq 0x180(%r14), %rax
movl %ebp, 0x28(%rsp)
movl %edx, 0x10(%rsp)
je 0x2a9e2
movl %r10d, %ebp
testq %rax, %rax
je 0x2a922
incl 0x4(%rax)
leaq 0x10(%rbx), %r8
movq (%rsp), %r15
leaq 0x3c(%r15), %rdx
leaq 0x2c(%r15), %rsi
movq %r11, %rdi
movq %rbx, %rcx
callq 0x2d200
jmp 0x2abe3
movb $0x1, 0x28(%rbx)
cmpl %eax, %esi
jbe 0x2ac30
cmpb $0x3, %bpl
jg 0x2ac30
movq (%rsp), %rsi
movl 0x24(%rsi), %eax
leal 0x1(%rax), %edx
movq 0x180(%r14), %rcx
cmpl 0x28(%rsi), %edx
jne 0x2aa00
testq %rcx, %rcx
movq (%rsp), %rsi
je 0x2a981
incl 0x4(%rcx)
movl 0x24(%rsi), %eax
movl 0x2c(%rsi), %ecx
addq 0xb8(%r11), %rcx
movswq 0x38(%rsi), %rdx
movzbl (%rdx,%rcx), %edx
movb 0x3a(%rsi), %cl
addb %cl, %cl
shrl %cl, %edx
andl $0x3, %edx
cmpl %ebp, %edx
jne 0x2ab17
cmpl %eax, 0x68(%r11)
je 0x2ab17
movq (%rsp), %rax
leaq 0x2c(%rax), %rsi
cmpb $0x1, 0x36(%rax)
jne 0x2abae
movl %r10d, %ebx
cmpb $0x0, 0x17d(%r11)
je 0x2b02a
movq %r11, %rdi
movl %ebp, %edx
callq 0x1d45a
jmp 0x2b034
testq %rax, %rax
je 0x2a9ea
incl 0x4(%rax)
cmpl 0x68(%r11), %ecx
jne 0x2aa3d
movl %r10d, %ebp
movq (%rsp), %r15
movl %ecx, 0x24(%r15)
jmp 0x2abe3
testq %rcx, %rcx
je 0x2aa08
incl 0x4(%rcx)
movq (%rsp), %rax
leaq 0x2c(%rax), %rsi
cmpb $0x1, 0x36(%rax)
jne 0x2ab28
movl %r10d, %ebx
cmpb $0x0, 0x17d(%r11)
je 0x2ab49
movq %r11, %r15
movq %r11, %rdi
movl %ebp, %edx
callq 0x1d45a
jmp 0x2ab56
movq (%rsp), %rdi
movl 0x2c(%rdi), %eax
addq 0xb8(%r11), %rax
movswq 0x38(%rdi), %rcx
movzbl (%rcx,%rax), %eax
movb 0x3a(%rdi), %cl
addb %cl, %cl
shrl %cl, %eax
leaq 0x2c(%rdi), %rsi
andl $0x3, %eax
cmpb $0x1, 0x36(%rdi)
movl %eax, 0x34(%rsp)
movl %r10d, %ebp
jne 0x2ab3a
cmpb $0x0, 0x17d(%r11)
je 0x2abc0
movq %r11, %rdi
movl %eax, %edx
callq 0x1d45a
jmp 0x2abca
movq 0x90(%r11), %rax
movl (%rax), %eax
movl %eax, (%rbx)
movq 0x90(%r11), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rbx)
movl %eax, 0x10(%rbx)
movq 0x90(%r11), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x14(%rbx)
movq 0x90(%r11), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rbx)
movl %eax, 0x18(%rbx)
movq 0x90(%r11), %rax
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rbx)
movl 0x88(%r14), %ecx
movzwl 0x12(%rdi), %eax
subl %eax, %ecx
movl %r12d, %esi
leaq 0x14(%rsp), %r8
movl %r10d, %ebp
callq 0x2d110
movl %ebp, %r10d
cmpb $0x3, %r12b
jg 0x2ac30
movl (%rbx,%r12,4), %eax
movq (%rsp), %rcx
movl %eax, 0x24(%rcx)
movl 0x10(%rbx,%r12,4), %eax
jmp 0x2b050
movq (%rsp), %rax
movq $-0x1, 0x24(%rax)
jmp 0x2ac30
movl %r10d, %ebx
movq %r11, %r15
movq %r11, %rdi
movl %ebp, %edx
callq 0x1d61a
jmp 0x2ab56
movq %r11, %rdi
movl %eax, %edx
callq 0x1d61a
jmp 0x2abca
movq %r11, %r15
movq %r11, %rdi
movl %ebp, %edx
callq 0x1d276
movq (%rsp), %rcx
movl %eax, 0x24(%rcx)
movq 0x180(%r14), %rax
testq %rax, %rax
je 0x2ab6c
incl 0x4(%rax)
movq (%rsp), %rax
leaq 0x3c(%rax), %rsi
cmpb $0x1, 0x46(%rax)
movq %r15, %rdi
jne 0x2ab8f
cmpb $0x0, 0x17d(%rdi)
je 0x2ab98
movl %ebp, %edx
callq 0x1d45a
jmp 0x2ab9f
movl %ebp, %edx
callq 0x1d61a
jmp 0x2ab9f
movl %ebp, %edx
callq 0x1d276
movq (%rsp), %rcx
movl %eax, 0x28(%rcx)
movl %ebx, %r10d
jmp 0x2ac30
movl %r10d, %ebx
movq %r11, %rdi
movl %ebp, %edx
callq 0x1d61a
jmp 0x2b034
movq %r11, %rdi
movl %eax, %edx
callq 0x1d276
movq (%rsp), %r15
movl %eax, 0x24(%r15)
movl 0x34(%rsp), %ecx
movl %eax, (%rbx,%rcx,4)
movl 0x24(%r15), %eax
incl %eax
movl %eax, 0x10(%rbx,%rcx,4)
movl 0x88(%r14), %ecx
movzwl 0x12(%r15), %eax
subl %eax, %ecx
movq %r15, %rdi
movl 0x28(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x14(%rsp), %r8
callq 0x2d110
cmpb $0x3, %r12b
jg 0x2ac1f
movl (%rbx,%r12,4), %eax
movl %eax, 0x24(%r15)
movl 0x10(%rbx,%r12,4), %eax
movl %eax, 0x28(%r15)
jmp 0x2ac2d
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x24(%r15)
movl %ebp, %r10d
testq %r13, %r13
sete %r8b
movl 0x90(%r14), %edx
movq (%rsp), %r13
movl 0x24(%r13), %edi
movl 0x28(%r13), %r15d
cmpl %r15d, %edi
setne %bl
movq 0x50(%r13), %rax
movq %rax, 0x28(%rsp)
testl %eax, %eax
sete %r12b
movb 0x8c(%r14), %bpl
testl %edx, %edx
je 0x2ac96
xorl %ecx, %ecx
cmpl %r15d, %edi
sete %cl
movl %edi, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movl %r10d, %edx
movl %r8d, %r13d
callq 0x2d624
movl 0x10(%rsp), %edi
movl %r13d, %r8d
testb %al, %al
je 0x2ad2a
andb %r8b, %bl
xorb $0x1, %bpl
andb %bpl, %r12b
andb %bl, %r12b
notb %bl
orb %r12b, %bl
testb $0x1, %bl
je 0x2acf1
cmpl %r15d, %edi
setne %al
notb %r8b
testb %al, %r8b
movq 0x20(%rsp), %rbp
jne 0x2ad55
movq 0x180(%r14), %rax
testq %rax, %rax
movq (%rsp), %rsi
je 0x2acd6
incl (%rax)
movl 0x50(%r14), %edx
movl 0x9c(%r14), %ecx
movzbl 0x85(%r14), %r8d
movq %rbp, %rdi
jmp 0x2af8d
cmpb $0x1, 0xb4(%r14)
movq 0x20(%rsp), %rbp
movq (%rsp), %r12
jne 0x2ae20
cmpb $0x1, 0x94(%r14)
movq 0x3f299(%rip), %rbx     # 0x69fb0
jne 0x2ad69
movl $0x13, %edx
movq %rbx, %rdi
leaq 0x2ad43(%rip), %rsi     # 0x55a6b
jmp 0x2ad78
movq 0x180(%r14), %rax
testq %rax, %rax
je 0x2ad38
incl (%rax)
movl 0x50(%r14), %edx
movl 0x9c(%r14), %ecx
movzbl 0x85(%r14), %r8d
movq 0x20(%rsp), %rbp
jmp 0x2af86
movq (%rsp), %rax
movb $0x0, 0x84(%rax)
incw 0xe(%rax)
jmp 0x2af92
movl $0x11, %edx
movq %rbx, %rdi
leaq 0x2ad07(%rip), %rsi     # 0x55a7f
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
incw 0xe(%r12)
movq 0x18(%r14), %rsi
movq 0x58(%r14), %rdx
xorl %r9d, %r9d
cmpl $0x0, 0x90(%r14)
setg %r9b
movzbl 0x94(%r14), %eax
movzbl 0x70(%r14), %r10d
movq 0x68(%r14), %rcx
movzbl 0x10(%rcx), %r11d
subq $0x8, %rsp
movq %r12, %rdi
movl 0x24(%rsp), %ecx
movq %rbx, %r8
pushq %r11
pushq %r10
pushq %rax
callq 0x2c92c
addq $0x20, %rsp
decw 0xe(%r12)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x92f0
movq 0x180(%r14), %rax
testq %rax, %rax
je 0x2ae30
movb $0x1, 0xb(%rax)
movq 0x28(%rsp), %rcx
movl %ecx, %r15d
movl 0x24(%r12), %eax
movl %eax, 0xb8(%r14)
movl 0x28(%r12), %eax
movl %eax, 0xbc(%r14)
movzwl 0x10(%r12), %eax
movw %ax, 0xc0(%r14)
shrl $0xe, %eax
movl %eax, 0xc4(%r14)
movl %ecx, 0xc8(%r14)
movb 0x70(%r14), %al
movb %al, 0xcc(%r14)
xorl %eax, %eax
movq %rax, 0xe8(%r14)
movq %rax, 0x108(%r14)
testq %r15, %r15
je 0x2af4d
movq (%rsp), %rbx
addq $0x58, %rbx
movq $-0x58, %r12
xorl %r13d, %r13d
cmpq $0x5, %r13
ja 0x2aeb1
leaq (%rbx,%r13,4), %rax
jmp 0x2aed4
cmpq $0x15, %r13
ja 0x2aec9
movq (%rsp), %rax
movq 0x70(%rax), %rax
leaq (%rax,%r13,4), %rax
addq $-0x18, %rax
jmp 0x2aed4
movq (%rsp), %rax
movq 0x78(%rax), %rax
addq %r12, %rax
movq 0x50(%r14), %rcx
movl (%rax), %eax
notl %eax
shrl $0x14, %eax
orl $0xfffffc00, %eax       # imm = 0xFFFFFC00
addl %eax, %ecx
movl %ecx, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x22bde
cmpq $0x5, %r13
ja 0x2af05
leaq (%rbx,%r13,4), %rax
jmp 0x2af28
cmpq $0x15, %r13
ja 0x2af1d
movq (%rsp), %rax
movq 0x70(%rax), %rax
leaq (%rax,%r13,4), %rax
addq $-0x18, %rax
jmp 0x2af28
movq (%rsp), %rax
movq 0x78(%rax), %rax
addq %r12, %rax
movb (%rax), %al
movb %al, 0xe(%rsp)
movq 0x48(%rsp), %rdi
leaq 0xe(%rsp), %rsi
callq 0x2b5fc
incq %r13
addq $0x4, %r12
cmpq %r13, %r15
jne 0x2aea5
movq %r14, %rdi
callq 0x2b316
movq 0x68(%r14), %rcx
movq 0x180(%r14), %rax
movq %rcx, 0x110(%r14)
movb $0x1, 0x9(%r14)
testq %rax, %rax
je 0x2af73
incl (%rax)
movl 0x50(%r14), %edx
movl 0x9c(%r14), %ecx
movzbl 0x85(%r14), %r8d
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0x2d050
movq 0x3f017(%rip), %rbx     # 0x69fb0
movl 0x50(%r14), %edx
movl 0x88(%r14), %ecx
movl 0x9c(%r14), %r8d
movzbl 0x85(%r14), %r9d
movq 0x68(%r14), %rax
leaq 0xf8(%rax), %r10
movzbl 0x10(%rax), %r11d
subq $0x8, %rsp
movq %rbp, %rdi
movq 0x48(%rsp), %rsi
pushq %r11
pushq 0xb8(%rax)
pushq %r10
callq 0x2d706
addq $0x20, %rsp
testb %al, %al
jne 0x2aff0
movq %rbp, %rdi
xorl %esi, %esi
callq 0x2d90c
movq 0x8(%rbp), %rax
cmpq 0x10(%rbp), %rax
je 0x2b058
movl 0x38(%rsp), %eax
cmpl $0x2, %eax
je 0x2b00a
cmpl $0x3, %eax
jne 0x2b01d
jmp 0x2b058
movq %rbp, %rdi
callq 0x2c500
movzwl 0x1a(%rsp), %ecx
cmpw %cx, 0x10(%rax)
jne 0x2b058
cmpb $0x1, 0x9(%r14)
jne 0x2a5bf
jmp 0x2b058
movq %r11, %rdi
movl %ebp, %edx
callq 0x1d276
movq (%rsp), %rcx
movl %eax, 0x24(%rcx)
movl %eax, 0x28(%rcx)
cmpl $-0x1, %eax
movl %ebx, %r10d
je 0x2ac30
incl %eax
movq (%rsp), %rcx
movl %eax, 0x28(%rcx)
jmp 0x2ac30
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop