// File: /workspace/github_cpp_makefile_star2_O2/ShootMe[P]Klondike-Solver/Solitaire.cpp
// Function: Solitaire::SolveFast(int, int, int)
SolveResult Solitaire::SolveFast(int maxClosedCount, int twoShift, int threeShift) {
	MakeAutoMoves();
	if (movesAvailableCount == 0) { return foundationCount == 52 ? SolvedMinimal : Impossible; }

	int openCount = 1;
	int maxFoundationCount = foundationCount;
	int bestSolutionMoveCount = 512;
	int totalOpenCount = 1;

	int powerOf2 = 1;
	while (maxClosedCount > (1 << (powerOf2 + 2))) {
		powerOf2++;
	}
	HashMap<int> closed(powerOf2);
	stack<shared_ptr<MoveNode>> open[512];
	Move movesToMake[512];
	Move bestSolution[512];
	bestSolution[0].Count = 255;
	int startMoves = MovesMadeNormalizedCount() + MinimumMovesLeft();
	int threeClosed = maxClosedCount >> threeShift;
	int twoClosed = maxClosedCount >> twoShift;
	shared_ptr<MoveNode> firstNode = movesMadeCount > 0 ? make_shared<MoveNode>(movesMade[movesMadeCount - 1]) : NULL;
	shared_ptr<MoveNode> node = firstNode;
	for (int i = movesMadeCount - 2; i >= 0; i--) {
		node->Parent = make_shared<MoveNode>(movesMade[i]);
		node = node->Parent;
	}
	open[startMoves].push(firstNode);
	while (closed.Size() < maxClosedCount) {
		//Check for lowest score length
		int index = startMoves;
		while (index < 512 && open[index].size() == 0) { index++; }

		//End solver if no more states
		if (index >= 512) { break; }

		//Get next state to evaluate
		openCount--;
		firstNode = open[index].top();
		open[index].pop();

		//Initialize game to the found state
		ResetGame(drawCount);
		int movesTotal = 0;
		node = firstNode;
		while (node != NULL) {
			movesToMake[movesTotal++] = node->Value;
			node = node->Parent;
		}
		while (movesTotal > 0) {
			MakeMove(movesToMake[--movesTotal]);
		}

		//Make any auto moves
		UpdateAvailableMoves();
		while (movesAvailableCount == 1) {
			Move move = movesAvailable[0];
			MakeMove(move);
			firstNode = make_shared<MoveNode>(move, firstNode);
			UpdateAvailableMoves();
		}
		movesTotal = MovesMadeNormalizedCount();

		//Check for best solution to foundations
		if (foundationCount > maxFoundationCount || (foundationCount == maxFoundationCount && bestSolutionMoveCount > movesTotal)) {
			bestSolutionMoveCount = movesTotal;
			maxFoundationCount = foundationCount;

			//Save solution
			for (int i = 0; i < movesMadeCount; i++) {
				bestSolution[i] = movesMade[i];
			}
			bestSolution[movesMadeCount].Count = 255;
		} else if (maxFoundationCount == 52) {
			//Dont check state if above or equal to current best solution
			int helper = MinimumMovesLeft();
			helper += movesTotal;
			if (helper >= bestSolutionMoveCount) { continue; }
		}

		//Make available moves and add them to be evaulated
		Move bestMove1, bestMove2, bestMove3;
		int bestMoveAdded1 = 512, bestMoveHelper1 = 512, bestMoveAdded2 = 512, bestMoveHelper2 = 512, bestMoveAdded3 = 512, bestMoveHelper3 = 512;
		for (int i = 0; i < movesAvailableCount; i++) {
			Move move = movesAvailable[i];
			int movesAdded = MovesAdded(move);

			MakeMove(move);

			movesAdded += movesTotal;
			movesAdded += MinimumMovesLeft();
			if (maxFoundationCount < 52 || movesAdded < bestSolutionMoveCount) {
				int helper = movesAdded;
				helper += 52 - foundationCount + roundCount;

				if (helper < bestMoveHelper1) {
					if (bestMoveHelper1 <= bestMoveHelper2) {
						if (bestMoveHelper2 <= bestMoveHelper3) {
							bestMove3 = bestMove2;
							bestMoveAdded3 = bestMoveAdded2;
							bestMoveHelper3 = bestMoveHelper2;
						}
						bestMove2 = bestMove1;
						bestMoveAdded2 = bestMoveAdded1;
						bestMoveHelper2 = bestMoveHelper1;
					} else if (bestMoveHelper1 <= bestMoveHelper3) {
						bestMove3 = bestMove1;
						bestMoveAdded3 = bestMoveAdded1;
						bestMoveHelper3 = bestMoveHelper1;
					}
					bestMove1 = move;
					bestMoveAdded1 = movesAdded;
					bestMoveHelper1 = helper;
				} else if (helper < bestMoveHelper2) {
					if (bestMoveHelper2 <= bestMoveHelper3) {
						bestMove3 = bestMove2;
						bestMoveAdded3 = bestMoveAdded2;
						bestMoveHelper3 = bestMoveHelper2;
					}
					bestMove2 = move;
					bestMoveAdded2 = movesAdded;
					bestMoveHelper2 = helper;
				} else if (helper < bestMoveHelper3) {
					bestMove3 = move;
					bestMoveAdded3 = movesAdded;
					bestMoveHelper3 = helper;
				}
			}

			UndoMove();
		}

		if (bestMoveHelper1 < 512) {
			MakeMove(bestMove1);

			HashKey key = GameState();
			KeyValue<int> * result = closed.Add(key, bestMoveAdded1);
			if (result == NULL || result->Value > bestMoveAdded1) {
				node = make_shared<MoveNode>(bestMove1, firstNode);
				if (result != NULL) { result->Value = bestMoveAdded1; }

				totalOpenCount++;
				openCount++;
				open[bestMoveHelper1].push(node);
			}

			UndoMove();
		}
		if (closed.Size() < twoClosed && bestMoveHelper2 < 512) {
			MakeMove(bestMove2);

			HashKey key = GameState();
			KeyValue<int> * result = closed.Add(key, bestMoveAdded2);
			if (result == NULL || result->Value > bestMoveAdded2) {
				node = make_shared<MoveNode>(bestMove2, firstNode);
				if (result != NULL) { result->Value = bestMoveAdded2; }

				totalOpenCount++;
				openCount++;
				open[bestMoveHelper2].push(node);
			}

			UndoMove();
		}
		if (closed.Size() < threeClosed && bestMoveHelper3 < 512) {
			MakeMove(bestMove3);

			HashKey key = GameState();
			KeyValue<int> * result = closed.Add(key, bestMoveAdded3);
			if (result == NULL || result->Value > bestMoveAdded3) {
				node = make_shared<MoveNode>(bestMove3, firstNode);
				if (result != NULL) { result->Value = bestMoveAdded3; }

				totalOpenCount++;
				openCount++;
				open[bestMoveHelper3].push(node);
			}

			UndoMove();
		}
	}

	//Reset game to best solution found
	ResetGame(drawCount);
	for (int i = 0; bestSolution[i].Count < 255; i++) {
		MakeMove(bestSolution[i]);
	}
	return maxFoundationCount == 52 ? SolvedMayNotBeMinimal : CouldNotComplete;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0c8, %rsp           # imm = 0xB0C8
movl %ecx, %r15d
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x5036
cmpl $0x0, 0x1910(%rbx)
movl 0x190c(%rbx), %eax
je 0x563b
movl %eax, (%rsp)
xorl %ecx, %ecx
pushq $0x4
popq %rax
incl %ecx
movl %eax, %edx
shll %cl, %edx
cmpl %ebp, %edx
jl 0x556e
leaq 0x88(%rsp), %rdi
movl %ecx, %esi
callq 0x806c
xorl %r12d, %r12d
leaq (%rsp,%r12), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x7eb6
addq $0x50, %r12
cmpq $0xa000, %r12           # imm = 0xA000
jne 0x558a
xorl %r12d, %r12d
leaq (%rsp,%r12), %rdi
addq $0x8c0, %rdi            # imm = 0x8C0
callq 0x34b4
addq $0x4, %r12
cmpq $0x800, %r12            # imm = 0x800
jne 0x55aa
xorl %r12d, %r12d
leaq (%rsp,%r12), %rdi
addq $0xc0, %rdi
callq 0x34b4
addq $0x4, %r12
cmpq $0x800, %r12            # imm = 0x800
jne 0x55ca
movb $-0x1, 0xc2(%rsp)
movq %rbx, %rdi
callq 0x46cc
movl %eax, %r13d
movq %rbx, %rdi
callq 0x477e
movl %eax, %r12d
movl %ebp, %eax
movl %r15d, %ecx
sarl %cl, %eax
movl %eax, 0x68(%rsp)
movl %ebp, %eax
movl %r14d, %ecx
sarl %cl, %eax
movl %eax, 0x6c(%rsp)
movl 0x1914(%rbx), %eax
testl %eax, %eax
movl %ebp, 0x38(%rsp)
jle 0x5648
decl %eax
leaq (%rbx,%rax,4), %rsi
leaq 0x40(%rsp), %rdi
callq 0x8267
jmp 0x5650
xorl %ebx, %ebx
cmpl $0x34, %eax
sete %bl
jmp 0x5d30
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
addl %r13d, %r12d
leaq 0x28(%rsp), %r14
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x841e
movl 0x1914(%rbx), %ebp
addl $-0x2, %ebp
leaq 0x78(%rsp), %r15
leaq 0x70(%rsp), %r13
testl %ebp, %ebp
js 0x56b0
movl %ebp, %eax
leaq (%rbx,%rax,4), %rsi
movq %r13, %rdi
callq 0x8267
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x35ee
movq %r15, %rdi
callq 0x350c
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x3588
decl %ebp
jmp 0x5678
movslq %r12d, %r14
imulq $0x50, %r14, %rax
leaq (%rsp,%rax), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
leaq 0x40(%rsp), %rsi
movq %rdi, 0xb8(%rsp)
callq 0x891e
movq %r14, 0xb0(%rsp)
shlq $0x20, %r14
movq %r14, 0xa8(%rsp)
movl $0x200, 0x24(%rsp)      # imm = 0x200
movl 0x38(%rsp), %ebp
cmpl %ebp, 0x90(%rsp)
jge 0x5cb4
movq 0xb8(%rsp), %r12
movq 0xa8(%rsp), %r15
movq 0xb0(%rsp), %r13
cmpq $0x1ff, %r13            # imm = 0x1FF
jg 0x5cb4
movq %r12, %rdi
callq 0x8634
testq %rax, %rax
jne 0x5749
incq %r13
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r15
addq $0x50, %r12
jmp 0x5719
sarq $0x20, %r15
imulq $0x50, %r15, %rax
leaq (%rsp,%rax), %r12
addq $0x10c0, %r12           # imm = 0x10C0
movq 0x30(%r12), %rsi
cmpq 0x38(%r12), %rsi
jne 0x5779
movq 0x48(%r12), %rax
movq -0x8(%rax), %rsi
movl $0x200, %eax            # imm = 0x200
addq %rax, %rsi
addq $-0x10, %rsi
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x3588
movq %r12, %rdi
callq 0x867c
movl 0x1904(%rbx), %esi
movq %rbx, %rdi
callq 0x53c6
movq %r13, %rsi
xorl %r15d, %r15d
movl (%rsp), %r12d
leaq 0x28(%rsp), %rdi
callq 0x3588
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x57e1
movl 0x10(%rsi), %eax
movl %eax, 0x8c0(%rsp,%r15,4)
incq %r15
jmp 0x57aa
movl 0x8bc(%rsp,%r15,4), %esi
decq %r15
movq %rbx, %rdi
callq 0x3e7e
testq %r15, %r15
jg 0x57ce
movq %rbx, %rdi
callq 0x4030
leaq 0x78(%rsp), %r15
cmpl $0x1, 0x1910(%rbx)
jne 0x5840
movl 0x1874(%rbx), %esi
movl %esi, 0x58(%rsp)
movq %rbx, %rdi
callq 0x3e7e
leaq 0x70(%rsp), %r14
movq %r14, %rdi
leaq 0x58(%rsp), %rsi
movq %r13, %rdx
callq 0x7f3a
movq %r13, %rdi
movq %r14, %rsi
callq 0x35ee
movq %r15, %rdi
callq 0x350c
movq %rbx, %rdi
callq 0x4030
jmp 0x57f3
movq %rbx, %rdi
callq 0x46cc
movl 0x190c(%rbx), %ecx
movl %ecx, %edi
cmpl %r12d, %ecx
jg 0x588c
sete %dl
cmpl %eax, 0x24(%rsp)
setg %cl
andb %dl, %cl
cmpb $0x1, %cl
je 0x588c
movl %eax, %r14d
cmpl $0x34, %r12d
jne 0x58ca
movq %rbx, %rdi
callq 0x477e
addl %r14d, %eax
pushq $0x34
popq %rcx
movl %ecx, (%rsp)
cmpl 0x24(%rsp), %eax
jge 0x56f4
jmp 0x58cd
movslq 0x1914(%rbx), %r8
testl %r8d, %r8d
movl $0x0, %ecx
cmovgl %r8d, %ecx
xorl %edx, %edx
movl %eax, %r14d
cmpq %rdx, %rcx
je 0x58b8
movl (%rbx,%rdx,4), %esi
movl %esi, 0xc0(%rsp,%rdx,4)
incq %rdx
jmp 0x58a4
movb $-0x1, 0xc2(%rsp,%r8,4)
movl %r14d, 0x24(%rsp)
movl %edi, %ecx
jmp 0x58cd
movl %r12d, %ecx
movl %ecx, 0x3c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x34b4
leaq 0x1c(%rsp), %rdi
callq 0x34b4
leaq 0x70(%rsp), %r15
leaq 0x18(%rsp), %rdi
callq 0x34b4
movl $0x200, %eax            # imm = 0x200
movl %eax, 0x14(%rsp)
movl %eax, 0x8(%rsp)
movl $0x200, 0x10(%rsp)      # imm = 0x200
movl %eax, 0x4(%rsp)
xorl %ebp, %ebp
movl $0x200, 0xc(%rsp)       # imm = 0x200
movl $0x200, (%rsp)          # imm = 0x200
movslq 0x1910(%rbx), %rax
cmpq %rax, %rbp
jge 0x5a73
movl 0x1874(%rbx,%rbp,4), %r13d
movl %r13d, 0x70(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x48fe
movl %eax, %r12d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3e7e
movq %rbx, %rdi
callq 0x477e
cmpl $0x34, 0x3c(%rsp)
setl %cl
addl %r14d, %r12d
addl %eax, %r12d
cmpl 0x24(%rsp), %r12d
setl %al
orb %cl, %al
cmpb $0x1, %al
jne 0x59c3
movl 0x1908(%rbx), %eax
movl %r12d, %ecx
subl 0x190c(%rbx), %ecx
leal (%rcx,%rax), %r15d
addl $0x34, %r15d
movl 0x10(%rsp), %eax
cmpl %eax, %r15d
jge 0x59c9
movl 0xc(%rsp), %ecx
cmpl %ecx, %eax
movl %eax, %edx
movl (%rsp), %eax
jle 0x5a00
cmpl %eax, %edx
jg 0x5a32
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %eax
jmp 0x5a32
movl (%rsp), %r15d
jmp 0x5a44
movl 0xc(%rsp), %ecx
cmpl %ecx, %r15d
movl (%rsp), %eax
jge 0x5a62
cmpl %eax, %ecx
jg 0x59ef
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl %ecx, %eax
movl %r13d, 0x1c(%rsp)
movl %r12d, 0x8(%rsp)
movl %r15d, 0xc(%rsp)
jmp 0x5a41
cmpl %eax, %ecx
jg 0x5a16
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl %ecx, %eax
movl %eax, %ecx
movl 0x20(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl %ecx, %eax
movl %r13d, 0x20(%rsp)
movl %r12d, 0x14(%rsp)
movl %r15d, 0x10(%rsp)
movl %eax, %r15d
movq %rbx, %rdi
callq 0x4b72
incq %rbp
movl %r15d, (%rsp)
leaq 0x40(%rsp), %r13
leaq 0x70(%rsp), %r15
jmp 0x591e
cmpl %eax, %r15d
jge 0x5a41
movl %r13d, 0x18(%rsp)
movl %r12d, 0x4(%rsp)
jmp 0x5a44
cmpl $0x200, 0x10(%rsp)      # imm = 0x200
movl 0x38(%rsp), %ebp
jge 0x5b29
movl 0x20(%rsp), %esi
movq %rbx, %rdi
callq 0x3e7e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4986
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
leaq 0x14(%rsp), %rdx
callq 0x7f5c
movq %rax, %r12
testq %rax, %rax
je 0x5ac4
movl 0x20(%r12), %eax
cmpl 0x14(%rsp), %eax
jle 0x5b1c
leaq 0x58(%rsp), %r15
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
movq %r13, %rdx
callq 0x7f3a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x35ee
leaq 0x60(%rsp), %rdi
callq 0x350c
testq %r12, %r12
je 0x5afe
movl 0x14(%rsp), %eax
movl %eax, 0x20(%r12)
movslq 0x10(%rsp), %rax
imulq $0x50, %rax, %rax
leaq (%rsp,%rax), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
leaq 0x28(%rsp), %rsi
callq 0x891e
movq %rbx, %rdi
callq 0x4b72
leaq 0x70(%rsp), %r15
movl 0x90(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0x5bee
cmpl $0x1ff, 0xc(%rsp)       # imm = 0x1FF
jg 0x5bee
movl 0x1c(%rsp), %esi
movq %rbx, %rdi
callq 0x3e7e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4986
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %rdx
callq 0x7f5c
movq %rax, %r12
testq %rax, %rax
je 0x5b87
movl 0x20(%r12), %eax
cmpl 0x8(%rsp), %eax
jle 0x5bdf
leaq 0x58(%rsp), %r15
movq %r15, %rdi
leaq 0x1c(%rsp), %rsi
movq %r13, %rdx
callq 0x7f3a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x35ee
leaq 0x60(%rsp), %rdi
callq 0x350c
testq %r12, %r12
je 0x5bc1
movl 0x8(%rsp), %eax
movl %eax, 0x20(%r12)
movslq 0xc(%rsp), %rax
imulq $0x50, %rax, %rax
leaq (%rsp,%rax), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
leaq 0x28(%rsp), %rsi
callq 0x891e
movq %rbx, %rdi
callq 0x4b72
movl 0x90(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x5ca8
cmpl $0x1ff, (%rsp)          # imm = 0x1FF
jg 0x5ca8
movl 0x18(%rsp), %esi
movq %rbx, %rdi
callq 0x3e7e
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4986
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
leaq 0x4(%rsp), %rdx
callq 0x7f5c
movq %rax, %r12
testq %rax, %rax
je 0x5c49
movl 0x20(%r12), %eax
cmpl 0x4(%rsp), %eax
jle 0x5ca0
leaq 0x58(%rsp), %r15
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
movq %r13, %rdx
callq 0x7f3a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x35ee
leaq 0x60(%rsp), %rdi
callq 0x350c
testq %r12, %r12
je 0x5c83
movl 0x4(%rsp), %eax
movl %eax, 0x20(%r12)
movslq (%rsp), %rax
imulq $0x50, %rax, %rax
leaq (%rsp,%rax), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
leaq 0x28(%rsp), %rsi
callq 0x891e
movq %rbx, %rdi
callq 0x4b72
movl 0x3c(%rsp), %eax
movl %eax, (%rsp)
jmp 0x56f4
movl 0x1904(%rbx), %esi
movq %rbx, %rdi
callq 0x53c6
leaq 0xc2(%rsp), %r14
movl (%rsp), %ebp
cmpb $-0x1, (%r14)
je 0x5ce5
movl -0x2(%r14), %esi
movq %rbx, %rdi
callq 0x3e7e
addq $0x4, %r14
jmp 0x5ccd
leaq 0x30(%rsp), %rdi
callq 0x350c
leaq 0x48(%rsp), %rdi
callq 0x350c
movl $0x9fb0, %ebx           # imm = 0x9FB0
leaq (%rsp,%rbx), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x82c0
addq $-0x50, %rbx
cmpq $-0x50, %rbx
jne 0x5cfe
xorl %ebx, %ebx
cmpl $0x34, %ebp
sete %bl
orl $-0x2, %ebx
leaq 0x88(%rsp), %rdi
callq 0x820c
movl %ebx, %eax
addq $0xb0c8, %rsp           # imm = 0xB0C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d76
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d76
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d9c
jmp 0x5d76
movq %rax, %rbx
jmp 0x5db3
movq %rax, %rbx
testq %r12, %r12
je 0x5dd3
leaq 0x1070(%rsp), %r14
leaq (%r14,%r12), %rdi
callq 0x82c0
addq $-0x50, %r12
jne 0x5d8b
jmp 0x5dd3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x350c
leaq 0x48(%rsp), %rdi
callq 0x350c
movl $0x9fb0, %r14d          # imm = 0x9FB0
leaq (%rsp,%r14), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x82c0
addq $-0x50, %r14
cmpq $-0x50, %r14
jne 0x5db9
leaq 0x88(%rsp), %rdi
callq 0x820c
movq %rbx, %rdi
callq 0x2300