// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ref_aligner.h
// Function: OneMMRefAligner::anchor64Find(unsigned int, unsigned long, unsigned char*, SDnaStringExpandable<25, 2> const&, SStringExpandable<char, 25, 2, 0> const&, unsigned int, unsigned int, EList<Range, 128>&, EList<unsigned int, 128>&, std::set<std::pair<unsigned long, unsigned long>, std::less<std::pair<unsigned long, unsigned long>>, std::allocator<std::pair<unsigned long, unsigned long>>>*, unsigned int, bool) const
virtual void anchor64Find(uint32_t numToFind,
						  size_t tidx,
						  uint8_t* ref,
						  const BTDnaString& qry,
						  const BTString& quals,
						  TIndexOffU begin,
						  TIndexOffU end,
						  TRangeVec& ranges,
						  EList<TIndexOffU>& results,
						  TSetPairs* pairs = NULL,
						  TIndexOffU aoff = OFF_MASK,
						  bool seedOnLeft = false) const
			{
				assert_gt(numToFind, 0);
				ASSERT_ONLY(const uint32_t rangesInitSz = (uint32_t)ranges.size());
				ASSERT_ONLY(uint32_t duplicates = 0);
				ASSERT_ONLY(uint32_t r2i = 0);
				const uint32_t qlen = (uint32_t)qry.length();
				assert_geq(end - begin, qlen); // caller should have checked this
				assert_gt(end, begin);
				assert_gt(qlen, 0);
#ifndef NDEBUG
				// Get results from the naive matcher for sanity-checking
				TRangeVec r2; EList<TIndexOffU> re2;
				naiveFind(numToFind, tidx, ref, qry, quals, begin, end, r2,
					  re2, pairs, aoff, seedOnLeft);
#endif
				const uint32_t anchorBitPairs = min<int>(qlen, 32);
				const int lhsShift = ((anchorBitPairs - 1) << 1);
				const uint32_t anchorCushion  = 32 - anchorBitPairs;
				// anchorOverhang = # read bases not included in the anchor
				const size_t anchorOverhang = (qlen <= 32 ? 0 : (qlen - 32));
				const TIndexOffU lim = end - qlen - begin;
				const TIndexOffU halfway = begin + (lim >> 1);
				uint64_t anchor = 0llu;
				uint64_t buffw = 0llu;  // rotating ref sequence buffer
				// OR the 'diff' buffer with this so that we can always count
				// 'N's as mismatches
				uint64_t diffMask = 0llu;
				// Set up a mask that we'll apply to the two bufs every round
				// to discard bits that were rotated out of the anchor area
				uint64_t clearMask = 0xffffffffffffffffllu;
				bool useMask = false;
				if(anchorBitPairs < 32) {
					clearMask >>= ((32-anchorBitPairs) << 1);
					useMask = true;
				}
				int nsInAnchor = 0;
				int nPos = -1;
				size_t skipLeftToRights = 0;
				size_t skipRightToLefts = 0;
				// Construct the 'anchor' 64-bit buffer so that it holds all of
				// the first 'anchorBitPairs' bit pairs of the query.
				for(size_t i = 0; i < anchorBitPairs; i++) {
					int c = (int)qry[i]; // next query character
					int r = (int)ref[halfway - begin + i]; // next reference character
					if(r & 4) {
						r = 0;
						// The right-to-left direction absorbs the candidate
						// alignment based at 'halfway'; so skipLeftToRights is
						// i, not i+1
						skipLeftToRights = max(skipLeftToRights, i);
						skipRightToLefts = max(skipRightToLefts, anchorBitPairs - i);
					}
					assert_leq(c, 4);
					assert_lt(r, 4);
					// Special case: query has an 'N'
					if(c == 4) {
						if(++nsInAnchor > 1) {
							// More than one 'N' in the anchor region; can't
							// possibly have a 1-mismatch hit anywhere
							assert_eq(r2.size(), ranges.size() - rangesInitSz);
							return;   // can't match if query has Ns
						}
						nPos = (int)i;
						// Make it look like an 'A' in the anchor
						c = 0;
						diffMask = (diffMask << 2llu) | 1llu;
					} else {
						diffMask <<= 2llu;
					}
					anchor  = ((anchor  << 2llu) | c);
					buffw = ((buffw << 2llu) | r);
				}
				// Check whether read is disqualified by Ns outside of the anchor
				// region
				for(size_t i = anchorBitPairs; i < qlen; i++) {
					if((int)qry[i] == 4) {
						if(++nsInAnchor > 1) {
							assert_eq(r2.size(), ranges.size() - rangesInitSz);
							return; // can't match if query has Ns
						}
					}
				}
				uint64_t bufbw = buffw;
				// We're moving the right-hand edge of the anchor along until
				// it's 'anchorOverhang' chars from the end of the target region.
				// Note that we're not making a 3'/5' distinction here; if we
				// were, we might need to make the 'anchorOverhang' adjustment on
				// the left end of the range rather than the right.
				bool hi = false;
				TIndexOffU riHi  = halfway;
				TIndexOffU rirHi = halfway - begin;
				TIndexOffU rirHiAnchor = rirHi + anchorBitPairs - 1;
				TIndexOffU riLo  = halfway + 1;
				TIndexOffU rirLo = halfway - begin + 1;
				for(TIndexOffU i = 1; i <= lim + 1; i++) {
					int r;       // new reference char
					uint64_t diff;
					assert_lt(skipLeftToRights, qlen);
					assert_leq(skipRightToLefts, qlen);
					if(hi) {
						hi = false;
						// Moving left-to-right
						riHi++;
						rirHi++;
						rirHiAnchor++;
						r = (int)ref[rirHiAnchor];
						if(r & 4) {
							r = 0;
							skipLeftToRights = anchorBitPairs;
						}
						assert_lt(r, 4);
						// Bring in new base pair at the least significant
						// position
						buffw = ((buffw << 2llu) | r);
						if(useMask) buffw &= clearMask;
						if(skipLeftToRights > 0) {
							skipLeftToRights--;
							continue;
						}
						diff = (buffw ^ anchor) | diffMask;
					} else {
						hi = true;
						// Moving right-to-left
						riLo--;
						rirLo--;
						r = (int)ref[rirLo];
						if(r & 4) {
							r = 0;
							skipRightToLefts = qlen;
						}
						assert_lt(r, 4);
						if(i >= 2) {
							bufbw >>= 2llu;
							// Bring in new base pair at the most significant
							// position
							bufbw |= ((uint64_t)r << lhsShift);
						}
						if(skipRightToLefts > 0) {
							skipRightToLefts--;
							continue;
						}
						diff = (bufbw ^ anchor) | diffMask;
					}
					if((diff & 0xffffffff00000000llu) &&
					   (diff & 0x00000000ffffffffllu)) continue;
					TIndexOffU ri  = hi ? riLo  : riHi;
					TIndexOffU rir = hi ? rirLo : rirHi;
					// Could use pop count
					uint8_t *diff8 = reinterpret_cast<uint8_t*>(&diff);
					// As a first cut, see if there are too many mismatches in
					// the first and last parts of the anchor
					uint32_t diffs = u8toMms[(int)diff8[0]] + u8toMms[(int)diff8[7]];
					if(diffs > 1) continue;
					diffs += u8toMms[(int)diff8[1]] +
						u8toMms[(int)diff8[2]] +
						u8toMms[(int)diff8[3]] +
						u8toMms[(int)diff8[4]] +
						u8toMms[(int)diff8[5]] +
						u8toMms[(int)diff8[6]];
					uint32_t mmpos = 0xffffffff;
					int refc = -1;
					if(diffs > 1) {
						// Too many differences
						continue;
					} else if(diffs == 1 && nPos != -1) {
						// There was one difference, but there was also one N,
						// so we already know where the difference is
						mmpos = nPos;
						refc = "ACGT"[(int)ref[rir + nPos]];
					} else if(diffs == 1) {
						// Figure out which position mismatched
						mmpos = 31;
						if((diff & 0xffffffffllu) == 0) { diff >>= 32llu; mmpos -= 16; }
						assert_neq(0, diff);
						if((diff & 0xffffllu) == 0)     { diff >>= 16llu; mmpos -=  8; }
						assert_neq(0, diff);
						if((diff & 0xffllu) == 0)       { diff >>= 8llu;  mmpos -=  4; }
						assert_neq(0, diff);
						if((diff & 0xfllu) == 0)        { diff >>= 4llu;  mmpos -=  2; }
						assert_neq(0, diff);
						if((diff & 0x3llu) == 0)        { mmpos--; }
						assert_neq(0, diff);
						assert_geq(mmpos, 0);
						assert_lt(mmpos, 32);
						mmpos -= anchorCushion;
						refc = "ACGT"[(int)ref[rir + mmpos]];
					}
					// Now extend the anchor into a longer alignment
					bool foundHit = true;
					if(anchorOverhang > 0) {
						assert_leq(ri + anchorBitPairs + anchorOverhang, end);
						bool skipCandidate = false;
						for(size_t j = 0; j < anchorOverhang; j++) {
							int rc = (int)ref[rir + 32 + j];
							if(rc == 4) {
								// Oops, encountered an N in the reference in
								// the overhang portion of the candidate
								// alignment
								// (Note that we inverted hi earlier)
								if(hi) {
									// Right-to-left
									skipRightToLefts = anchorOverhang - j - 1;
								} else {
									// Left-to-right
									skipLeftToRights = anchorBitPairs + j;
								}
								skipCandidate = true; // Skip this candidate
								break;
							}
							if((int)qry[32 + j] != rc) {
								if(++diffs > 1) {
									foundHit = false;
									break;
								} else {
									mmpos = (uint32_t)(32 + j);
									refc = "ACGT"[(int)ref[rir + 32 + j]];
								}
							}
						}
						if(skipCandidate) continue;
					}
					if(!foundHit) continue;
					if(pairs != NULL) {
						TU64Pair p;
						if(ri < aoff) {
							// By convention, the upstream mate's
							// coordinates go in the 'first' field
							p.first  = ((uint64_t)tidx << 32) | (uint64_t)ri;
							p.second = ((uint64_t)tidx << 32) | (uint64_t)aoff;
						} else {
							p.second = ((uint64_t)tidx << 32) | (uint64_t)ri;
							p.first  = ((uint64_t)tidx << 32) | (uint64_t)aoff;
						}
						if(pairs->find(p) != pairs->end()) {
							// We already found this hit!  Continue.
							ASSERT_ONLY(duplicates++);
							ASSERT_ONLY(r2i++);
							continue;
						} else {
							// Record this hit
							pairs->insert(p);
						}
					}
					assert_leq(diffs, 1);
					assert_lt(r2i, r2.size());
					assert_eq(re2[r2i], ri);
					ranges.resize(ranges.size()+1);
					Range& range = ranges.back();
					assert_eq(diffs, r2[r2i].numMms);
					range.stratum = diffs;
					range.numMms = diffs;
					assert_eq(0, range.mms.size());
					assert_eq(0, range.refcs.size());
					if(diffs == 1) {
						assert_neq(mmpos, 0xffffffff);
						assert_eq(mmpos, r2[r2i].mms[0]);
						assert_neq(-1, refc);
						assert_eq(refc, r2[r2i].refcs[0]);
						range.mms.push_back(mmpos);
						range.refcs.push_back(refc);
					}
					ASSERT_ONLY(r2i++);
					results.push_back(ri);
					if(--numToFind == 0) return;
				}
				assert_leq(duplicates, r2.size());
				assert_geq(r2.size() - duplicates, ranges.size() - rangesInitSz);
				return; // no hit
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %r9
movq %rdx, 0x58(%rsp)
movl %esi, 0xa8(%rsp)
movl 0x158(%rsp), %esi
movl 0x150(%rsp), %eax
movq 0x20(%r8), %rdx
movl $0x20, %ecx
cmpl %ecx, %edx
movl $0x20, %r13d
cmovll %edx, %r13d
subl %r13d, %ecx
leal -0x20(%rdx), %edi
xorl %r14d, %r14d
cmpl $0x21, %edx
cmovbq %r14, %rdi
movq %rdi, 0xa0(%rsp)
addl %edx, %eax
subl %eax, %esi
movq %rcx, 0x100(%rsp)
addl %ecx, %ecx
movq $-0x1, %rax
shrq %cl, %rax
movq %rax, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %esi, %eax
shrl %eax
testl %edx, %edx
setne %cl
movq %r9, 0x38(%rsp)
movq %r8, 0xe0(%rsp)
movq %rax, 0x68(%rsp)
je 0x43756
movq 0x8(%r8), %rdi
leaq (%r9,%rax), %r8
cmpq $0x1, %r13
movq %r13, %r9
adcq $0x0, %r9
xorl %ebx, %ebx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x60(%rsp)
movq %r13, %r10
xorl %r12d, %r12d
movq $0x0, 0x48(%rsp)
xorl %esi, %esi
xorl %r11d, %r11d
movq $0x0, 0x40(%rsp)
xorl %r14d, %r14d
movzbl (%r8,%r11), %r15d
testb $0x4, %r15b
je 0x436e0
movq 0x40(%rsp), %rax
cmpq %r11, %rax
cmovbeq %r11, %rax
movq %rax, 0x40(%rsp)
cmpq %r10, %r14
cmovbeq %r10, %r14
xorl %r15d, %r15d
movq %r13, %rbp
movsbq (%rdi,%r11), %rax
cmpb $0x4, %al
jne 0x436f9
leal 0x1(%rsi), %r13d
testl %esi, %esi
jle 0x43704
xorl %r15d, %r15d
jmp 0x43734
shlq $0x2, 0x48(%rsp)
movl %esi, %r13d
jmp 0x43720
movq 0x48(%rsp), %rax
leaq 0x1(,%rax,4), %rax
movq %rax, 0x48(%rsp)
movl %r11d, %eax
movq %rax, 0x60(%rsp)
xorl %eax, %eax
shlq $0x2, %rbx
orq %rax, %rbx
shlq $0x2, %r12
movl %r15d, %eax
orq %rax, %r12
movb $0x1, %r15b
movl %r13d, %esi
testb %r15b, %r15b
movq %rbp, %r13
je 0x43779
incq %r11
cmpq %r13, %r11
setb %cl
decq %r10
cmpq %r11, %r9
jne 0x436ba
jmp 0x43779
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x60(%rsp)
movq $0x0, 0x40(%rsp)
xorl %esi, %esi
movq $0x0, 0x48(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
testb $0x1, %cl
movq 0x38(%rsp), %r11
movl 0x4(%rsp), %r10d
movl 0x150(%rsp), %r8d
jne 0x43e91
movl %edx, %r9d
cmpq %r13, %r9
jbe 0x437c3
movq 0xe0(%rsp), %rax
movq 0x8(%rax), %rcx
movq %r13, %rdx
cmpb $0x4, (%rcx,%rdx)
jne 0x437bb
testl %esi, %esi
jg 0x43e91
incl %esi
incq %rdx
cmpq %rdx, %r9
jne 0x437ab
incl %r10d
je 0x43e91
movq 0x170(%rsp), %rdx
leal -0x2(,%r13,2), %eax
movq 0x68(%rsp), %rcx
addl %ecx, %r8d
leal 0x1(%rcx), %esi
movq %rsi, 0x98(%rsp)
leal 0x1(%r8), %esi
movl %esi, 0x54(%rsp)
cmpl $0x20, %r13d
leal -0x1(%r13,%rcx), %ecx
movl %eax, %eax
movq %rax, 0x110(%rsp)
movq $-0x1, %rax
cmovbq 0x8(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x58(%rsp), %rax
shlq $0x20, %rax
movl 0x178(%rsp), %esi
movq %rax, 0x58(%rsp)
orq %rax, %rsi
movq %rsi, 0xb0(%rsp)
leaq 0x8(%rdx), %rax
movq %rax, 0xb8(%rsp)
movq %rcx, %rdx
movq 0xa0(%rsp), %rax
decq %rax
movq %rax, 0xe8(%rsp)
movl $0x1, %r15d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movq %r12, %rbp
movq %r9, 0x28(%rsp)
movl %r10d, 0x4(%rsp)
movq %r13, 0x30(%rsp)
testb $0x1, %cl
je 0x438d6
incl %r8d
movq 0x68(%rsp), %rax
incl %eax
movq %rax, 0x68(%rsp)
incl %edx
movzbl (%r11,%rdx), %esi
xorl %ecx, %ecx
testb $0x4, %sil
movq 0x40(%rsp), %rax
cmovneq %r13, %rax
cmovnel %ecx, %esi
shlq $0x2, %r12
orq %r12, %rsi
andq 0x108(%rsp), %rsi
testq %rax, %rax
je 0x43935
decq %rax
movq %rax, 0x40(%rsp)
movl $0xa, %edi
xorl %ecx, %ecx
movq %rsi, %r12
jmp 0x43e7c
decl 0x54(%rsp)
movq 0x98(%rsp), %rax
decl %eax
movq %rax, 0x98(%rsp)
movzbl (%r11,%rax), %esi
testb $0x4, %sil
cmovneq %r9, %r14
movl $0x0, %eax
cmovnel %eax, %esi
movq %rbp, %rax
shrq $0x2, %rax
movq 0x110(%rsp), %rcx
shlq %cl, %rsi
orq %rax, %rsi
cmpl $0x2, %r15d
cmovbq %rbp, %rsi
testq %r14, %r14
je 0x4394c
decq %r14
movb $0x1, %cl
movl $0xa, %edi
movq %rsi, %rbp
jmp 0x43e7c
movl $0x0, 0x8(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movq %rsi, %r12
jmp 0x4395a
movq %rdx, 0x18(%rsp)
movb $0x1, %al
movl %eax, 0x8(%rsp)
movq %rsi, %rbp
xorq %rbx, %rsi
orq 0x48(%rsp), %rsi
movq %rsi, %r9
shrq $0x20, %r9
setne %cl
testl %esi, %esi
setne %dl
movl $0xa, %edi
testb %dl, %cl
jne 0x439e3
movq %rsi, %r11
shrq $0x38, %r11
cmpb $0x0, 0x8(%rsp)
movl %r8d, %eax
cmovnel 0x54(%rsp), %eax
movl %eax, 0x90(%rsp)
movl %eax, 0xac(%rsp)
movq 0x68(%rsp), %rdx
cmovnel 0x98(%rsp), %edx
movzbl %sil, %eax
leaq 0x2a35c(%rip), %rcx     # 0x6dd10
movzbl (%rcx,%rax), %eax
movzbl (%rcx,%r11), %r13d
addl %eax, %r13d
cmpl $0x1, %r13d
jbe 0x439f2
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rdx
movl 0x8(%rsp), %ecx
movq 0x38(%rsp), %r11
jmp 0x43e7c
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rdx
jmp 0x43e78
movq %rdx, 0xd8(%rsp)
movq %rbp, 0x88(%rsp)
movq %r8, 0x20(%rsp)
movq %rsi, %rax
shrq $0x8, %rax
movq %rsi, %r8
shrq $0x10, %r8
movq %rsi, %r10
shrq $0x18, %r10
movq %rsi, %rdx
shrq $0x28, %rdx
movl %r13d, 0x14(%rsp)
movq %rsi, %r13
shrq $0x30, %r13
movq %rax, 0xc8(%rsp)
movl $0xff, %edi
andq %rdi, %rax
movzbl (%rcx,%rax), %eax
movq %rcx, %rbp
movq %r8, 0xd0(%rsp)
movq %r8, %rcx
andq %rdi, %rcx
movzbl (%rbp,%rcx), %ecx
movq %r10, 0xc0(%rsp)
andq %rdi, %r10
movzbl (%rbp,%r10), %r10d
addl %ecx, %r10d
movq %r9, %rcx
andq %rdi, %rcx
movzbl (%rbp,%rcx), %ecx
movq %rdx, 0xf8(%rsp)
andq %rdi, %rdx
movzbl (%rbp,%rdx), %r8d
addl %ecx, %r8d
movq %r13, 0xf0(%rsp)
movq %r13, %rcx
movl 0x14(%rsp), %r13d
andq %rdi, %rcx
movzbl (%rbp,%rcx), %ecx
addl %r8d, %ecx
addl %eax, %r13d
addl %r10d, %r13d
addl %ecx, %r13d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0xa, %edi
cmpl $0x1, %r13d
jbe 0x43ad6
movq 0x38(%rsp), %r11
movl 0x4(%rsp), %r10d
movq 0x20(%rsp), %r8
jmp 0x43cba
movq 0x38(%rsp), %r10
movq 0x20(%rsp), %r8
jne 0x43b0a
cmpl $-0x1, 0x60(%rsp)
je 0x43b0a
movq 0x60(%rsp), %rcx
movl %ecx, (%rsp)
movq 0xd8(%rsp), %rdx
addl %edx, %ecx
leaq 0xf973(%rip), %rbp      # 0x53475
movq %r10, %rax
jmp 0x43bde
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x1, %r13d
leaq 0xf95b(%rip), %rbp      # 0x53475
movq 0xd8(%rsp), %rdx
jne 0x43be8
movl $0x1f, %eax
testl %esi, %esi
jne 0x43b61
movl $0xf, %eax
movq %r11, 0xc0(%rsp)
movq 0xf0(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
movq 0xf8(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movq %r9, %rsi
movq 0xc8(%rsp), %r9
movl %r9d, %ecx
shll $0x8, %ecx
movzbl %sil, %r8d
movq %rax, %r11
movzwl %cx, %eax
leal -0x8(%r11), %ecx
orq %r8, %rax
cmovnel %r11d, %ecx
movq 0xd0(%rsp), %r8
cmovneq %rsi, %r8
movq %r8, %rsi
movl %ecx, (%rsp)
testb %sil, %sil
jne 0x43bae
testq %rax, %rax
cmoveq 0xc0(%rsp), %r9
addl $-0x4, (%rsp)
movq %r9, %rsi
testb $0xf, %sil
movq %r10, %rax
jne 0x43bc1
shrl $0x4, %esi
andl $0xf, %esi
addl $-0x2, (%rsp)
movq 0x20(%rsp), %r8
testb $0x3, %sil
jne 0x43bcf
decl (%rsp)
movl (%rsp), %ecx
subl 0x100(%rsp), %ecx
movl %ecx, (%rsp)
addl %edx, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %ecx
movzbl (%rcx,%rbp), %ecx
movl %ecx, 0x14(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0x43cd6
addl $0x20, %edx
addq %r10, %rdx
movq 0xe0(%rsp), %rcx
movq 0x8(%rcx), %rax
movb $0x1, %bpl
xorl %r8d, %r8d
movq 0xe8(%rsp), %r10
xorl %r9d, %r9d
movzbl (%rdx,%r8), %ecx
cmpl $0x4, %ecx
jne 0x43c3a
movb $0x1, %r9b
cmpb $0x0, 0x8(%rsp)
je 0x43c57
xorl %r11d, %r11d
movq %r10, %r14
jmp 0x43c81
movsbl 0x20(%rax,%r8), %esi
movb $0x1, %r11b
cmpl %ecx, %esi
je 0x43c81
incl %r13d
cmpl $0x1, %r13d
jbe 0x43c69
xorl %r11d, %r11d
xorl %ebp, %ebp
jmp 0x43c81
movq 0x30(%rsp), %rcx
addq %r8, %rcx
movq %rcx, 0x40(%rsp)
xorl %r11d, %r11d
jmp 0x43c81
leal 0x20(%r8), %esi
movl %esi, (%rsp)
movl %ecx, %ecx
leaq 0xf7fc(%rip), %rsi      # 0x53475
movzbl (%rcx,%rsi), %ecx
movl %ecx, 0x14(%rsp)
testb %r11b, %r11b
je 0x43c96
incq %r8
decq %r10
cmpq 0xa0(%rsp), %r8
jb 0x43c1e
movl $0x0, %ecx
testb $0x1, %r9b
movl $0xa, %edx
cmovnel %edx, %ecx
movq 0x38(%rsp), %r11
movq 0x20(%rsp), %r8
je 0x43cdc
movl %ecx, %edi
movl 0x4(%rsp), %r10d
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rdx
movq 0x88(%rsp), %rbp
jmp 0x43e78
movb $0x1, %bpl
movq %r10, %r11
testb $0x1, %bpl
movl 0x4(%rsp), %r10d
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rdx
movq 0x88(%rsp), %rbp
je 0x43dc4
cmpq $0x0, 0x170(%rsp)
je 0x43dce
movaps %xmm0, 0x70(%rsp)
movl 0x90(%rsp), %ecx
movl %ecx, %eax
cmpl 0x178(%rsp), %ecx
jae 0x43d3c
orq 0x58(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x43d53
orq 0x58(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x170(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x383e8
movl $0xa, %edi
movq 0xb8(%rsp), %rcx
cmpq %rcx, %rax
jne 0x43da3
movq 0x170(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %rax, 0x90(%rsp)
callq 0x38458
movq 0x90(%rsp), %rax
movq 0xb8(%rsp), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
movq 0x38(%rsp), %r11
movl 0x4(%rsp), %r10d
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rdx
xorps %xmm0, %xmm0
je 0x43dce
movq 0x30(%rsp), %r13
jmp 0x43e78
movq 0x160(%rsp), %rdi
movq 0x18(%rdi), %rsi
incq %rsi
callq 0x38382
movq 0x160(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
movl %r13d, -0x54(%rcx,%rax)
movl %r13d, -0x50(%rcx,%rax)
cmpl $0x1, %r13d
jne 0x43e35
addq %rax, %rcx
movq %rcx, %r13
leaq -0x48(%rcx), %rdi
movq %rsp, %rsi
callq 0x22e84
addq $-0x28, %r13
movl 0x14(%rsp), %eax
movb %al, 0x70(%rsp)
movq %r13, %rdi
leaq 0x70(%rsp), %rsi
callq 0x2b9ac
movq 0x168(%rsp), %rdi
leaq 0xac(%rsp), %rsi
callq 0x22e84
xorl %edi, %edi
decl 0xa8(%rsp)
sete %dil
movq 0x38(%rsp), %r11
movl 0x4(%rsp), %r10d
movq 0x20(%rsp), %r8
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %r9
movq 0x18(%rsp), %rdx
xorps %xmm0, %xmm0
movl 0x8(%rsp), %ecx
cmpl $0xa, %edi
je 0x43e85
testl %edi, %edi
jne 0x43e91
incl %r15d
cmpl %r10d, %r15d
jbe 0x4387e
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop