// File: /workspace/github_cpp_makefile_star2_O1/lrq3000[P]rfrb/./src/fileHandler.cpp
// Function: FileHandler::estimateStripeMap(bool)
std::vector<std::vector<mapEntry>> FileHandler::estimateStripeMap(bool isRaid5)
{
	//Lambda function, which is done by threads
	auto lambda = [&] (size_t id) -> std::vector<Block>
	{
		//Initialization
		std::vector<Block> blocks;
		FileReader *me = inFiles.at(id);
		const size_t CHECKS = 400;
		me->reset();
		const int checkSize=1;
		bool checkGapSize = false;
		size_t startBlock=0,endBlock=0;
		bool zeroStart=false, zeroEnd=false;
		size_t blockSize = mStripeSize;
		size_t gap = mStripeSize - (checkSize * me->getBlockSize());
		gap -= (checkSize * me->getBlockSize());
		Block pushMe;
		size_t outputCounter = 0;
		while (true)
		{
			//Output
			if (outputCounter == 0)
			{
				std::string wr = "Thread ";
				wr += std::to_string(id);
				wr += " working \t";
				wr += me->getRelativePos();
				printf("\r%s\t%6lu",wr.c_str(), blocks.size());
				fflush(stdout);
			}
			outputCounter = (outputCounter + 1) % 25000;
			if (blocks.size() > CHECKS)
				break;

			//Error
			if (me->findFirstNonemptyBlock() == -1)
			{
				break;
			}

			//Get adress and check the gap
			size_t adress = me->getCurrentAdress();
			if (checkGapSize == true)
			{
				size_t tmp = adress;
				if (tmp >= endBlock-checkSize*me->getBlockSize())
				{
					pushMe.zeroFirst = zeroStart;
					pushMe.zeroLast = zeroEnd;
					pushMe.startAdress = startBlock/blockSize;
					pushMe.endAdress = endBlock/blockSize;
					blocks.push_back(pushMe);
					startBlock = adress;
				}
				if (startBlock % blockSize != 0)
				{
					startBlock -= me->getBlockSize();
					zeroStart=true;
				}
				else
				{
					zeroStart=false;
				}
			}
			else
			{
				startBlock = adress;
				if (startBlock % blockSize != 0)
				{
					startBlock -= me->getBlockSize();
					zeroStart=true;
				}
				else
				{
					zeroStart=false;
				}
			}

			//Calculate entropy and check if it's relevant
			pushMe.entropies.clear();
			pushMe.entropies.push_back(me->calcEntropyOfCurrentBlock());
			while (me->newBlock()==true)
			{
				//Output
				if (outputCounter == 0)
				{
					std::string wr = "Thread ";
					wr += std::to_string(id);
					wr += " working \t";
					wr += me->getRelativePos();
					printf("\r%s\t%6lu",wr.c_str(), blocks.size());
					fflush(stdout);
				}
				outputCounter = (outputCounter + 1) % 25000;
				if (blocks.size() > CHECKS)
					break;
				float f = me->calcEntropyOfCurrentBlock();
				if (f == 0.0f)
					break;
				pushMe.entropies.push_back(f);
			}

			endBlock = me->getCurrentAdress();
			if (endBlock % blockSize != 0)
			{
				endBlock += me->getBlockSize();
				zeroEnd=true;
			}
			else
			{
				zeroEnd=false;
			}
			if (endBlock - startBlock < checkSize*me->getBlockSize())
			{
				checkGapSize = false;
			}
			else
			{
				checkGapSize = true;
			}
		}
		me->reset();
		return blocks;
	}; //lambda function end

	//Initialization to start threads
	unsigned int NUM_THREADS = inFiles.size();
	std::vector<std::pair<size_t, float>> entropies;
	std::vector<std::future<std::vector<Block>>> futureResults(inFiles.size());
	std::vector<std::vector<Block>> results(inFiles.size());
	for (size_t i = 0; i < NUM_THREADS; ++i)
	{
		inFiles.at(i)->setBlockSize(mStripeSize);
		futureResults[i] = std::async(std::launch::async, lambda, i);
	}
	for (size_t i = 0; i < NUM_THREADS; ++i)
	{
		results.at(i) = futureResults.at(i).get();
		inFiles.at(i)->setBlockSize(mStripeSize);
	}
	std::cout << std::endl;
	std::cout << "\tEntropie calculation finished" << std::endl;

	std::vector<std::vector<std::pair<bool, std::vector<size_t>>>> map;
	map.resize(results.size());

	//Build the heuristic with the modulo operation and the block begins and ends
	std::vector<size_t> parityDist;
	std::vector<std::vector<std::pair<bool, std::vector<size_t>>>> entropyMat = buildMapHeuristic(results, parityDist);

	//Initializing the resulting stripingMap
	std::vector<std::vector<mapEntry>> stripingMap;
	std::vector<std::pair<size_t, size_t>> referenceCounters;
	std::pair<size_t,size_t> c;
	size_t revC = results.size()-2;
	if (isRaid5==false)
		revC++;
	for (size_t i = 0; i < results.size(); ++i)
	{
		referenceCounters.push_back(std::pair<size_t,size_t>(0,revC));
	}
	for (size_t j = 0; j < results.size(); ++j)
	{
		std::vector<mapEntry> b;
		for (size_t i = 0; i < results.size(); ++i)
		{
			if (isRaid5 == true)
			{
				if (parityDist.at(j) == i)
				{
					b.push_back(mapEntry(true,-2));
				}
				else
				{
					b.push_back(mapEntry(false, -1));
				}
			}
			else
			{
				b.push_back(mapEntry(false, -1));
			}
		}
		stripingMap.push_back(b);
		if (isRaid5==false)
			break;

	}

	std::vector<size_t> posValues;
	if (isRaid5 == true)
	{
		posValues = std::vector<size_t>(results.size(), results.size()-1);
	}
	else
	{
		posValues = std::vector<size_t>(1, results.size());
	}

	//Sort, if it is Raid0 for the later algorithm
	if (isRaid5 == false)
	{
		for (size_t i = 1; i < entropyMat.size();)
		{
			for (size_t j = 0; j < entropyMat.at(i).size(); ++j)
			{
				entropyMat.at(0).push_back(entropyMat.at(i).at(j));
			}
			entropyMat.erase(entropyMat.begin()+i);
		}
	}

	//*
	// * DEBUG OUTPUT - do not delete me
	// *
/*	std::cout << std::endl;
	for (auto in : entropyMat)
	{
		std::cout << "Begin" << std::endl;
		for (auto in2 : in)
		{
			if (in2.first == true)
			{
				for (auto in3 : in2.second)
				{
					std::cout << in3 << ";";
				}
				std::cout << " ";
			}
		}
		std::cout << std::endl;
		std::cout << "End" << std::endl;
		for (auto in2 : in)
		{
			if (in2.first == false)
			{
				for (auto in3 : in2.second)
				{
					std::cout << in3 << ";";
				}
				std::cout << " ";
			}
		}
		std::cout << std::endl;
	}
	std::cout << std::endl;
*/

	float probability = 1.0f;
	//left = 1, right = 2
	int leftRight = 0;
	//asymm = 1, symm = 2
	int asymm_symm = 0;

	//In this loop we determine the striping map out of the map heuristic, we built earlier
	while (probability > 0.5f)
	{
		size_t entropyMatRunner=0;
		//*
		// * DEBUG OUTPUT - do not delete me
		// *
/*		for (auto &in : stripingMap)
		{
			std::cout << std::setw(10) << " ";
			for (auto &it : in)
			{
				if (it.isParity)
				{
					std::cout << std::setw(4) << "P";
				}
				else
				{
					std::cout << std::setw(4) << std::to_string(it.dataBlock);
				}
			}
			std::cout << std::endl;
		}
		std::cout << std::endl << std::endl;
		std::cout << std::to_string(probability) << std::endl;
*/		//Debug output -end

		size_t lineC=0;
		for (auto &in : entropyMat)
		{
			//We have to rerun each vec at least all images times
			//Possible-vec is size of all images, each entry representing one image
			//pair.first for begin-block, pair.second for end-block
			std::vector<std::pair<size_t, size_t>> possible(results.size(), std::pair<size_t,size_t>(0,0));
			std::pair<size_t, size_t> occCounter(0,0);
			for (auto &moduloEntry : in)
			{
				if (moduloEntry.second.size()>0)
				{
					if (moduloEntry.first == true)
					{
						++occCounter.first;
					}
					else
					{
						++occCounter.second;
					}
				}
				for (auto &modVecEntry : moduloEntry.second)
				{
					if (moduloEntry.first == true)
					{
						++possible.at(modVecEntry).first;
					}
					else
					{
						++possible.at(modVecEntry).second;
					}
				}
			}

			//Check if the probability is high enough to determine the entry
			for (size_t entry = 0; entry < results.size(); ++entry)
			{
				short begin=-1;
				if (possible.at(entry).first == 0 && possible.at(entry).second == 0)
					continue;
				if (occCounter.second > occCounter.first)
				{
					if ((float)possible.at(entry).second/(float)occCounter.second >= probability)
					{
						begin = 0;
					}
				}
				else if (begin == -1 && occCounter.first>0)
				{
					if ((float)possible.at(entry).first/(float)occCounter.first >= probability)
					{
						begin = 1;
					}
				}
				if (begin != -1)
				{
					//We found something
					possible.at(entry).first = 0;
					possible.at(entry).second = 0;
					stripingMap.at(entropyMatRunner).at(entry).isParity = false;
					if (begin == 1)
					{
						stripingMap.at(entropyMatRunner).at(entry).dataBlock = referenceCounters.at(entropyMatRunner).first++;
					}
					else
					{
						stripingMap.at(entropyMatRunner).at(entry).dataBlock = referenceCounters.at(entropyMatRunner).second--;
					}
					--posValues.at(entropyMatRunner);

					//Evrything fine, kill each entry in line because we found an entry
					for (auto &moduloEntry : in)
					{
						if (posValues.at(entropyMatRunner) == 0)
						{
							moduloEntry.second.clear();
						}
						for (size_t burn = 0; burn < moduloEntry.second.size();)
						{
							if (moduloEntry.second.at(burn) == entry)
							{
								moduloEntry.second.erase(moduloEntry.second.begin()+burn);
							}
							else
							{
								++burn;
							}
						}
					}
					probability = 1.0f;
					break;
				}
			}
			if (posValues.at(entropyMatRunner) == 1)
			{
				for (size_t i = 0; i < stripingMap.at(entropyMatRunner).size(); ++i)
				{
					if (stripingMap.at(entropyMatRunner).at(i).dataBlock == -1)
					{
						stripingMap.at(entropyMatRunner).at(i).dataBlock = referenceCounters.at(entropyMatRunner).first++;
						posValues.at(entropyMatRunner) = 0;
						for (auto &moduloEntry : in)
							moduloEntry.second.clear();
						break;
					}
				}
			}
			++lineC;
			++entropyMatRunner;
		}
		probability -= 0.05f;

		//Another approach, only for Raid5; Depends on left-right and symm-asymm builds
		if (isRaid5 == true)
		{
			int curNum = -1;
			for (size_t i = 1; i < stripingMap.size(); ++i)
			{
				for (size_t j = 0; j < stripingMap.at(i).size(); ++j)
				{
					if (stripingMap.at(i).at(j).isParity == true)
					{
						//Get upper datablocknum
						int tmp = stripingMap.at(i-1).at(j).dataBlock;
						if (tmp != -1)
						{
							if (curNum == -1)
							{
								curNum = tmp;
							}
							else //we found a block
							{
								if (tmp > curNum)
								{
									asymm_symm = 1;
									leftRight = 2;
								}
								else if (tmp < curNum)
								{
									asymm_symm = 1;
									leftRight = 1;
								}
								else
								{
									asymm_symm = 2;
									if (tmp == 0)
									{
										leftRight = 2;
									}
									else if (tmp == (int)(inFiles.size()-1))
									{
										leftRight = 1;
									}
									else
									{
										std::cerr << "Error in stripingMap building algorithm" << std::endl;
										return std::vector<std::vector<mapEntry>>();
									}
								}
							}
						}
					}
				}
			}
		}
		if (leftRight != 0 && asymm_symm != 0)
			break;
	}

	//Error, should not happen
	if (leftRight == 0 && asymm_symm == 0 && isRaid5 == true)
	{
		std::cerr << "Couldnt determine stripemap type" << std::endl;
		return std::vector<std::vector<mapEntry>>();
	}

	//Build resulting Stripemap from the found information
	if (isRaid5 == true)
	{
		std::vector<size_t> order;
		if (leftRight == 2)
		{
			for (size_t i = 0; i < parityDist.size(); ++i)
			{
				order.push_back(parityDist.at(i));
			}
		}
		else
		{
			for (size_t i = 0; i < parityDist.size(); ++i)
			{
				order.push_back(parityDist.at(parityDist.size()-(i+1)));
			}
		}

		//Fill the stripemap
		for (size_t i = 0; i < stripingMap.size(); ++i)
		{
			size_t counter;
			if (asymm_symm == 1)
			{
				counter = 0;
			}
			else
			{
				if (leftRight == 1)
				{
					counter = i;
				}
				else
				{
					counter = inFiles.size()-(i-1);
				}
			}
			for (size_t j = 0; j < stripingMap.at(i).size(); ++j)
			{
				if (stripingMap.at(i).at(order.at(j)).isParity == false)
				{
					stripingMap.at(i).at(order.at(j)).dataBlock = counter;
					counter = (counter+1)%(inFiles.size()-1);
				}
			}
		}
	}
	//Else, ask user
	userStripeMapInteraction(stripingMap);
	return stripingMap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movl %edx, 0xc(%rsp)
movq %rsi, %rbx
movq %rdi, 0x100(%rsp)
movq 0x48(%rsi), %r14
subq 0x40(%rsi), %r14
sarq $0x3, %r14
leaq 0x140(%rsp), %rdi
leaq 0x80(%rsp), %rdx
movq %r14, %rsi
callq 0xdf84
movq 0x48(%rbx), %rsi
movq %rbx, 0x18(%rsp)
subq 0x40(%rbx), %rsi
sarq $0x3, %rsi
leaq 0x48(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0xdffc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
andq %rax, %r14
je 0x9caf
movq %r14, 0x40(%rsp)
movl $0x8, %ebp
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x18(%rsp), %r14
movq 0x40(%r14), %rax
movq 0x48(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0xacc6
movq (%rax,%r15,8), %rdi
movq 0x60(%r14), %rsi
callq 0x1135a
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movl $0x58, %edi
callq 0x53d0
movq %rax, %r12
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r12)
leaq 0x14d92(%rip), %rax     # 0x1e700
movq %rax, (%r12)
leaq 0x10(%r12), %r13
movl %ebx, 0x28(%r12)
movq %rbx, 0x18(%r12)
movq %rbx, 0x1d(%r12)
movq %rbx, 0x30(%r12)
movl %ebx, 0x38(%r12)
leaq 0x14db9(%rip), %rax     # 0x1e750
movq %rax, 0x10(%r12)
movl $0x30, %edi
callq 0x53d0
movq %rax, %r14
movq %rax, %rdi
callq 0xf95e
movq %r14, 0x40(%r12)
movq %r15, 0x48(%r12)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%r12)
movq $0x0, 0xa0(%rsp)
movl $0x20, %edi
callq 0x53d0
leaq 0x14dc6(%rip), %rcx     # 0x1e7a8
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
leaq 0x38c6(%rip), %rcx      # 0xd2b6
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rax, 0x60(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
xorl %edx, %edx
callq 0x5340
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x9a25
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x30(%r12)
jne 0xacd7
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%r12)
movq %r13, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %r12, 0x88(%rsp)
testq %rdi, %rdi
je 0x9a60
callq 0xe634
cmpq $0x0, 0x80(%rsp)
jne 0x9b07
movl $0x48, %edi
callq 0x53d0
movq %rax, %r12
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r12)
leaq 0x14d56(%rip), %rax     # 0x1e7e8
movq %rax, (%r12)
movq %r12, %r13
addq $0x10, %r13
movl $0x0, 0x28(%r12)
movq %rbx, 0x18(%r12)
movq %rbx, 0x1d(%r12)
leaq 0x14d81(%rip), %rax     # 0x1e838
movq %rax, 0x10(%r12)
movl $0x30, %edi
callq 0x53d0
movq %rax, %r14
movq %rax, %rdi
callq 0xf95e
movq %r14, 0x30(%r12)
movq %r15, 0x38(%r12)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%r12)
movq %r13, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %r12, 0x88(%rsp)
testq %rdi, %rdi
je 0x9b07
callq 0xe634
leaq 0xe0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xfed8
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
movq 0x18(%rsp), %r14
je 0x9b33
callq 0xe634
movq 0x140(%rsp), %rax
movaps 0xe0(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0xe0(%rsp)
movq (%rax,%rbp), %rdi
movups %xmm0, -0x8(%rax,%rbp)
testq %rdi, %rdi
je 0x9b61
callq 0xe634
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0x9b73
callq 0xe634
incq %r15
addq $0x10, %rbp
cmpq %r15, 0x40(%rsp)
jne 0x991b
movl $0x10, %ebx
xorl %r13d, %r13d
leaq 0xa0(%rsp), %r15
leaq 0x80(%rsp), %r12
xorl %r14d, %r14d
movq 0x40(%rsp), %rbp
movq 0x140(%rsp), %rsi
movq 0x148(%rsp), %rdx
subq %rsi, %rdx
sarq $0x4, %rdx
cmpq %r14, %rdx
jbe 0xacdc
addq %r13, %rsi
movq %r15, %rdi
callq 0xe084
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r14, %rdx
jbe 0xaced
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
movups -0x10(%rax,%rbx), %xmm0
movq (%rax,%rbx), %rcx
movaps 0xa0(%rsp), %xmm1
movups %xmm1, -0x10(%rax,%rbx)
movq 0xb0(%rsp), %rdx
movq %rdx, (%rax,%rbx)
movq 0x90(%rsp), %rax
movq %rcx, 0x90(%rsp)
movaps 0x80(%rsp), %xmm1
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0xa0(%rsp)
movq %rax, 0xb0(%rsp)
movq %r12, %rdi
callq 0xe0f2
movq %r15, %rdi
callq 0xe0f2
movq 0x18(%rsp), %rcx
movq 0x40(%rcx), %rax
movq 0x48(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0xacfe
movq (%rax,%r14,8), %rdi
movq 0x60(%rcx), %rsi
callq 0x1135a
incq %r14
addq $0x10, %r13
addq $0x18, %rbx
cmpq %r14, %rbp
jne 0x9ba5
movq 0x152fa(%rip), %rdi     # 0x1efb0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x53b0
movsbl %al, %esi
movq 0x152df(%rip), %rdi     # 0x1efb0
callq 0x5040
movq %rax, %rdi
callq 0x5260
movq 0x152cb(%rip), %rbx     # 0x1efb0
leaq 0xc0f4(%rip), %rsi      # 0x15de0
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x5450
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x53b0
movsbl %al, %esi
movq 0x15299(%rip), %rdi     # 0x1efb0
callq 0x5040
movq %rax, %rdi
callq 0x5260
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x50(%rsp), %rsi
subq 0x48(%rsp), %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
callq 0xe132
movq 0x18(%rsp), %r13
leaq 0xa0(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0xe0(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r13, %rsi
callq 0xaf4e
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movq %rdx, 0x70(%rsp)
movq %rdx, 0x120(%rsp)
movaps %xmm0, 0x110(%rsp)
subq %rcx, %rax
je 0x9e4d
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movzbl 0xc(%rsp), %r15d
notq %r15
addq %rax, %r15
xorl %r12d, %r12d
leaq 0x110(%rsp), %rbx
leaq 0x20(%rsp), %r14
movq $0x0, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq 0x118(%rsp), %rsi
cmpq 0x120(%rsp), %rsi
je 0x9e1e
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x118(%rsp)
jmp 0x9e29
movq %rbx, %rdi
movq %r14, %rdx
callq 0x101c2
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
incq %r12
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %r12
jb 0x9deb
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rax
subq %rax, %rsi
je 0x9fd4
xorl %ebx, %ebx
leaq 0x60(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0xc0(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x9f84
xorl %r13d, %r13d
cmpb $0x0, 0xc(%rsp)
je 0x9ef1
movq 0xa0(%rsp), %rax
movq 0xa8(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
jbe 0xac9c
cmpq (%rax,%rbx,8), %r13
jne 0x9f1d
movb $0x1, 0xc0(%rsp)
movl $0xfffffffe, 0xc4(%rsp) # imm = 0xFFFFFFFE
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
jne 0x9f3c
movq %r15, %rdi
movq %r12, %rdx
callq 0x102fa
jmp 0x9f4d
movb $0x0, 0xc0(%rsp)
movl $0xffffffff, 0xc4(%rsp) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
jne 0x9f3c
movq %r15, %rdi
movq %r12, %rdx
callq 0x102fa
jmp 0x9f4d
movb $0x0, 0xc0(%rsp)
movl $0xffffffff, 0xc4(%rsp) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x9f77
movq 0xc0(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x28(%rsp)
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
incq %r13
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %r13
jb 0x9e98
jmp 0x9f84
movq %r15, %rdi
movq %r12, %rdx
callq 0x102fa
jmp 0x9f4d
movq %r14, %rdi
movq %r15, %rsi
callq 0xe1ae
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x9f9e
callq 0x5390
cmpb $0x0, 0xc(%rsp)
movq 0x18(%rsp), %r13
je 0xa021
movq 0x50(%rsp), %rsi
subq 0x48(%rsp), %rsi
incq %rbx
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
cmpq %rsi, %rbx
jb 0x9e74
jmp 0x9fe6
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
cmpb $0x0, 0xc(%rsp)
je 0xa021
leaq -0x1(%rsi), %rax
leaq 0xc0(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x17(%rsp), %rcx
callq 0xe1da
movq 0x20(%rsp), %rbp
movq 0x28(%rsp), %r12
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
jmp 0xa057
movq 0x48(%rsp), %r14
movq 0x50(%rsp), %rbx
movl $0x8, %edi
callq 0x53d0
movq %rax, %rbp
subq %r14, %rbx
sarq $0x3, %rbx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r15, %rbx
movq %rbx, (%rax)
addq $0x8, %rax
movq %rax, %r12
cmpb $0x0, 0xc(%rsp)
je 0xa87f
subq %rbp, %r12
sarq $0x3, %r12
movq %r12, 0x108(%rsp)
movss 0xb9d7(%rip), %xmm0     # 0x15a50
movl $0x0, 0x3c(%rsp)
movl $0x0, 0x8(%rsp)
movss %xmm0, 0x10(%rsp)
movq %rbp, 0x40(%rsp)
movss 0x10(%rsp), %xmm0
ucomiss 0xb9b3(%rip), %xmm0     # 0x15a54
jbe 0xa813
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rcx
movq %rax, 0x78(%rsp)
movq %rcx, 0x138(%rsp)
cmpq %rcx, %rax
je 0xa5bf
xorl %r13d, %r13d
movq 0x50(%rsp), %rsi
subq 0x48(%rsp), %rsi
sarq $0x3, %rsi
imulq %r15, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0xc0(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
leaq 0x17(%rsp), %rcx
callq 0xe32a
movq 0x78(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0xa193
xorl %r12d, %r12d
xorl %r11d, %r11d
movq 0x8(%rax), %rdi
movq 0x10(%rax), %r8
cmpq %rdi, %r8
je 0xa135
cmpb $0x1, (%rax)
jne 0xa132
incq %r11
jmp 0xa135
incq %r12
cmpq %r8, %rdi
je 0xa188
movb (%rax), %r9b
movq 0x20(%rsp), %r10
movq 0x28(%rsp), %rdx
subq %r10, %rdx
sarq $0x4, %rdx
movq (%rdi), %rsi
testb %r9b, %r9b
je 0xa168
cmpq %rsi, %rdx
jbe 0xac06
shlq $0x4, %rsi
addq %r10, %rsi
jmp 0xa17c
cmpq %rsi, %rdx
jbe 0xac06
shlq $0x4, %rsi
addq %r10, %rsi
addq $0x8, %rsi
incq (%rsi)
addq $0x8, %rdi
cmpq %r8, %rdi
jne 0xa14e
addq $0x20, %rax
cmpq %rcx, %rax
jne 0xa11b
jmp 0xa199
xorl %r11d, %r11d
xorl %r12d, %r12d
movq 0x50(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0xa4be
testq %r11, %r11
js 0xa1b8
xorps %xmm0, %xmm0
cvtsi2ss %r11, %xmm0
jmp 0xa1d3
movq %r11, %rax
shrq %rax
movl %r11d, %ecx
andl $0x1, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss %xmm0, 0xd8(%rsp)
testq %r12, %r12
js 0xa1eb
xorps %xmm0, %xmm0
cvtsi2ss %r12, %xmm0
jmp 0xa206
movq %r12, %rax
shrq %rax
movl %r12d, %ecx
andl $0x1, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss %xmm0, 0xdc(%rsp)
xorl %ebx, %ebx
movq %r11, 0x130(%rsp)
movq %r12, 0x128(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rbx, %rdx
jbe 0xac35
movq %rbx, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
testq %rdx, %rdx
jne 0xa256
cmpq $0x0, 0x8(%rax)
je 0xa2b4
cmpq %r11, %r12
jbe 0xa26e
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0xa284
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
jmp 0xa29c
movb $0x1, %cl
testq %r11, %r11
je 0xa2eb
testq %rdx, %rdx
js 0xa2bf
xorps %xmm0, %xmm0
cvtsi2ss %rdx, %xmm0
jmp 0xa2d7
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
divss 0xdc(%rsp), %xmm0
ucomiss 0x10(%rsp), %xmm0
jae 0xa2b0
movb $0x1, %cl
jmp 0xa2eb
xorl %ecx, %ecx
jmp 0xa2eb
movl $0x20, %r14d
jmp 0xa48e
movq %rdx, %rsi
shrq %rsi
andl $0x1, %edx
orq %rsi, %rdx
xorps %xmm0, %xmm0
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
divss 0xd8(%rsp), %xmm0
ucomiss 0x10(%rsp), %xmm0
jae 0xa4b4
xorl %esi, %esi
xorl %r14d, %r14d
testb %cl, %cl
jne 0xa48e
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq %r13, %rdx
jbe 0xac14
leaq (,%r13,2), %rdx
addq %r13, %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
jbe 0xac35
movb $0x0, (%rax,%rbx,8)
movq 0x110(%rsp), %rcx
testb %sil, %sil
je 0xa37a
movq 0x118(%rsp), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %r13, %rdx
jbe 0xac14
movq %r13, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl $0x1, %edx
jmp 0xa3a7
movq 0x118(%rsp), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %r13, %rdx
jbe 0xac14
movq %r13, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addq $0x8, %rcx
movq $-0x1, %rdx
movq (%rcx), %rsi
addq %rsi, %rdx
movq %rdx, (%rcx)
movl %esi, 0x4(%rax,%rbx,8)
cmpq %r13, 0x108(%rsp)
jbe 0xac2a
decq (%rbp,%r13,8)
movq 0x78(%rsp), %rax
movq (%rax), %rbp
movq 0x8(%rax), %r12
movl $0x1e, %r14d
cmpq %r12, %rbp
je 0xa46b
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax,%r13,8)
jne 0xa3fc
movq 0x8(%rbp), %rax
cmpq %rax, 0x10(%rbp)
je 0xa3fc
movq %rax, 0x10(%rbp)
movq 0x8(%rbp), %rax
movq 0x10(%rbp), %rdx
cmpq %rax, %rdx
je 0xa448
xorl %r15d, %r15d
cmpq %rbx, (%rax,%r15,8)
jne 0xa42e
leaq (%rax,%r15,8), %rdi
leaq 0x8(%rdi), %rsi
cmpq %rdx, %rsi
je 0xa427
subq %rsi, %rdx
callq 0x55d0
addq $-0x8, 0x10(%rbp)
jmp 0xa431
incq %r15
movq 0x8(%rbp), %rax
movq 0x10(%rbp), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0xa40c
addq $0x20, %rbp
cmpq %r12, %rbp
jne 0xa3e2
movss 0xb5f7(%rip), %xmm0     # 0x15a50
movss %xmm0, 0x10(%rsp)
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
jmp 0xa479
movss 0xb5dd(%rip), %xmm0     # 0x15a50
movss %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rbp
movq 0x130(%rsp), %r11
movq 0x128(%rsp), %r12
testb $0x1f, %r14b
jne 0xa4be
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
incq %rbx
sarq $0x3, %rax
imulq %r15, %rax
cmpq %rax, %rbx
jb 0xa221
jmp 0xa4be
movb $0x1, %sil
xorl %ecx, %ecx
jmp 0xa2ed
cmpq 0x108(%rsp), %r13
je 0xac83
cmpq $0x1, (%rbp,%r13,8)
jne 0xa591
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq %r13, %rdx
jbe 0xac19
leaq (,%r13,2), %rsi
addq %r13, %rsi
movq (%rcx,%rsi,8), %rax
movq 0x8(%rcx,%rsi,8), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0xa591
cmpl $-0x1, 0x4(%rax,%rcx,8)
je 0xa52c
incq %rcx
cmpq %r13, %rdx
ja 0xa513
jmp 0xac19
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
subq %rsi, %rdx
sarq $0x4, %rdx
cmpq %r13, %rdx
jbe 0xac19
movq %r13, %rdx
shlq $0x4, %rdx
movq (%rsi,%rdx), %rdi
leaq 0x1(%rdi), %r8
movq %r8, (%rsi,%rdx)
movl %edi, 0x4(%rax,%rcx,8)
movq $0x0, (%rbp,%r13,8)
movq 0x78(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0xa591
movq 0x8(%rax), %rdx
cmpq %rdx, 0x10(%rax)
je 0xa58b
movq %rdx, 0x10(%rax)
addq $0x20, %rax
jmp 0xa578
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xa5a0
callq 0x5390
incq %r13
movq 0x78(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x78(%rsp)
cmpq 0x138(%rsp), %rax
jne 0xa0d0
movss 0x10(%rsp), %xmm0
addss 0xb48b(%rip), %xmm0     # 0x15a58
movss %xmm0, 0x10(%rsp)
cmpb $0x0, 0xc(%rsp)
je 0xa7d5
movq 0x68(%rsp), %rax
subq 0x60(%rsp), %rax
sarq $0x3, %rax
imulq %r15, %rax
movl $0x2a, %ecx
cmpq $0x2, %rax
movq 0x18(%rsp), %r13
jb 0xa7de
movl $0xffffffff, 0x78(%rsp) # imm = 0xFFFFFFFF
movl $0x1, %ebx
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq %rbx, %rdx
jbe 0xac46
leaq -0x1(%rbx), %r13
leaq (%rbx,%rbx,2), %rbp
xorl %r12d, %r12d
movq (%rax,%rbp,8), %rcx
movq 0x8(%rax,%rbp,8), %r14
subq %rcx, %r14
sarq $0x3, %r14
cmpq %r14, %r12
jae 0xa795
cmpb $0x1, (%rcx,%r12,8)
jne 0xa76f
cmpq %r13, %rdx
jbe 0xac6d
leaq (,%r13,2), %rdx
addq %r13, %rdx
movq (%rax,%rdx,8), %rcx
movq 0x8(%rax,%rdx,8), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
jbe 0xac6a
movl 0x4(%rcx,%r12,8), %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
je 0xa76b
movl 0x78(%rsp), %edx
cmpl $-0x1, %edx
je 0xa6bd
cmpl %edx, %ecx
jle 0xa6c6
movl $0x2, 0x8(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0xa76b
movl %ecx, 0x78(%rsp)
jmp 0xa76b
jge 0xa6d2
movl $0x1, 0x3c(%rsp)
jmp 0xa6f5
movl $0x2, 0x3c(%rsp)
testl %ecx, %ecx
je 0xa6ff
movq 0x18(%rsp), %rsi
movq 0x48(%rsi), %rdx
subq 0x40(%rsi), %rdx
shrq $0x3, %rdx
decl %edx
cmpl %edx, %ecx
jne 0xa709
movl $0x1, 0x8(%rsp)
jmp 0xa76b
movl $0x2, 0x8(%rsp)
jmp 0xa76b
movl $0x27, %edx
movq 0x148db(%rip), %rdi     # 0x1eff0
leaq 0xb6e3(%rip), %rsi      # 0x15dff
callq 0x5450
movq 0x148c8(%rip), %rcx     # 0x1eff0
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x53b0
movsbl %al, %esi
movq 0x148aa(%rip), %rdi     # 0x1eff0
callq 0x5040
movq %rax, %rdi
callq 0x5260
movq 0x100(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %eax, %eax
testb %al, %al
je 0xa79c
incq %r12
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq %rbx, %rdx
ja 0xa63a
jmp 0xac46
movl $0x2d, %eax
jmp 0xa7a1
movl $0x1, %eax
cmpq %r14, %r12
movq 0x18(%rsp), %r13
movq 0x40(%rsp), %rbp
jb 0xa7dc
movq 0x68(%rsp), %rax
subq 0x60(%rsp), %rax
incq %rbx
sarq $0x3, %rax
imulq %r15, %rax
cmpq %rax, %rbx
jb 0xa611
movl $0x2a, %ecx
jmp 0xa7de
movq 0x18(%rsp), %r13
jmp 0xa7eb
movl %eax, %ecx
cmpl $0x2a, %ecx
movl $0x0, %eax
cmovel %eax, %ecx
jne 0xa802
movl 0x3c(%rsp), %eax
testl %eax, %eax
movl $0x17, %ecx
cmovel %eax, %ecx
movl 0x8(%rsp), %eax
testl %eax, %eax
cmovel %eax, %ecx
testl %ecx, %ecx
je 0xa094
cmpl $0x17, %ecx
jne 0xab80
movl 0x8(%rsp), %eax
orl 0x3c(%rsp), %eax
sete %al
movl 0xc(%rsp), %ecx
andb %cl, %al
cmpb $0x1, %al
jne 0xa94c
movq 0x147bd(%rip), %rbx     # 0x1eff0
leaq 0xb5ed(%rip), %rsi      # 0x15e27
movl $0x20, %edx
movq %rbx, %rdi
callq 0x5450
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x53b0
movsbl %al, %esi
movq 0x1478b(%rip), %rdi     # 0x1eff0
callq 0x5040
movq %rax, %rdi
callq 0x5260
movq 0x100(%rsp), %rbx
jmp 0xab72
leaq 0xe0(%rsp), %rbx
movq 0xe8(%rsp), %rax
subq 0xe0(%rsp), %rax
sarq $0x3, %rax
imulq %r15, %rax
cmpq $0x2, %rax
jb 0xa062
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq $0x2, %rdx
jb 0xac57
movq $-0x1, %r14
xorl %r15d, %r15d
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
incq %r14
cmpq %rcx, %r14
jae 0xa92e
addq %r15, %rsi
movq %rax, %rdi
callq 0xe2f2
addq $0x20, %r15
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq $0x1, %rdx
ja 0xa8d8
jmp 0xac57
addq $0x18, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x108a4
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
jmp 0xa887
testb %cl, %cl
je 0xab49
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rax
cmpl $0x2, 0x8(%rsp)
jne 0xa9dd
cmpq %rdx, %rax
je 0xaa4d
xorl %r14d, %r14d
leaq 0x20(%rsp), %rbx
xorl %r15d, %r15d
addq %r14, %rdx
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0xa9b0
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x28(%rsp)
jmp 0xa9b8
movq %rbx, %rdi
callq 0xeba6
incq %r15
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rax
subq %rdx, %rax
sarq $0x3, %rax
addq $0x8, %r14
cmpq %rax, %r15
jb 0xa990
jmp 0xaa4d
subq %rdx, %rax
je 0xaa4d
sarq $0x3, %rax
movq $-0x1, %r14
xorl %r12d, %r12d
leaq 0x20(%rsp), %rbx
leaq (%rax,%r14), %rsi
cmpq %r12, %rax
jbe 0xad0f
leaq (%rdx,%rsi,8), %rdx
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0xaa23
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x28(%rsp)
jmp 0xaa2b
movq %rbx, %rdi
callq 0xeba6
incq %r12
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rax
subq %rdx, %rax
sarq $0x3, %rax
decq %r14
cmpq %rax, %r12
jb 0xa9f5
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %r8
subq %rdi, %r8
je 0xab35
sarq $0x3, %r8
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r8
movq 0x18(%rsp), %rax
movq 0x48(%rax), %r9
subq 0x40(%rax), %r9
sarq $0x3, %r9
movq 0x20(%rsp), %r10
movq 0x28(%rsp), %rsi
subq %r10, %rsi
sarq $0x3, %rsi
cmpq $0x1, %r8
adcq $0x0, %r8
xorl %r11d, %r11d
xorl %ebx, %ebx
leaq (%rbx,%rbx,2), %rax
movq (%rdi,%rax,8), %r14
movq 0x8(%rdi,%rax,8), %rcx
subq %r14, %rcx
je 0xab29
sarq $0x3, %rcx
movq %r9, %rax
subq %rbx, %rax
incq %rax
cmpl $0x1, 0x8(%rsp)
cmoveq %rbx, %rax
cmpl $0x1, 0x3c(%rsp)
cmoveq %r11, %rax
movq 0x18(%rsp), %rdx
movq 0x48(%rdx), %r12
subq 0x40(%rdx), %r12
sarq $0x3, %r12
decq %r12
cmpq $0x1, %rcx
movq %rcx, %r15
adcq $0x0, %r15
xorl %r13d, %r13d
cmpq %r13, %rsi
je 0xacad
movq (%r10,%r13,8), %rdx
cmpq %rdx, %rcx
jbe 0xacb2
cmpb $0x0, (%r14,%rdx,8)
jne 0xab21
movl %eax, 0x4(%r14,%rdx,8)
incq %rax
xorl %edx, %edx
divq %r12
movq %rdx, %rax
incq %r13
cmpq %r13, %r15
jne 0xaaf4
incq %rbx
cmpq %r8, %rbx
jne 0xaaa1
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xab44
callq 0x5390
movq 0x18(%rsp), %r13
leaq 0x60(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xbdd4
movaps 0x60(%rsp), %xmm0
movq 0x100(%rsp), %rcx
movups %xmm0, (%rcx)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
testq %rbp, %rbp
je 0xab8d
movq %rbp, %rdi
callq 0x5390
movq 0x110(%rsp), %rdi
testq %rdi, %rdi
je 0xab9f
callq 0x5390
leaq 0x60(%rsp), %rdi
callq 0x7e18
leaq 0xe0(%rsp), %rdi
callq 0xe3a6
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0xabc8
callq 0x5390
leaq 0x80(%rsp), %rdi
callq 0xe3a6
leaq 0x48(%rsp), %rdi
callq 0xe3e0
leaq 0x140(%rsp), %rdi
callq 0xe41a
movq 0x100(%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xacbc(%rip), %rdi      # 0x158c9
xorl %eax, %eax
callq 0x5570
movq %r13, %rbx
jmp 0xac35
leaq 0xaca9(%rip), %rdi      # 0x158c9
movq %r13, %rsi
xorl %eax, %eax
callq 0x5570
movq %r13, %rbx
movq 0x108(%rsp), %rdx
leaq 0xac8d(%rip), %rdi      # 0x158c9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5570
leaq 0xac7c(%rip), %rdi      # 0x158c9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5570
leaq 0xac6b(%rip), %rdi      # 0x158c9
movl $0x1, %esi
xorl %eax, %eax
callq 0x5570
movq %r12, %r13
leaq 0xac55(%rip), %rdi      # 0x158c9
movq %r13, %rsi
xorl %eax, %eax
movq 0x40(%rsp), %rbp
callq 0x5570
leaq 0xac3f(%rip), %rdi      # 0x158c9
movq 0x108(%rsp), %rdx
movq %rdx, %rsi
xorl %eax, %eax
callq 0x5570
leaq 0xac26(%rip), %rdi      # 0x158c9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5570
movq %rsi, %rcx
jmp 0xacb5
movq %rdx, %rsi
leaq 0xac0d(%rip), %rdi      # 0x158c9
movq %rcx, %rdx
xorl %eax, %eax
callq 0x5570
leaq 0xabfc(%rip), %rdi      # 0x158c9
movq %r15, %rsi
xorl %eax, %eax
callq 0x5570
callq 0x50e0
leaq 0xabe6(%rip), %rdi      # 0x158c9
movq %r14, %rsi
xorl %eax, %eax
callq 0x5570
leaq 0xabd5(%rip), %rdi      # 0x158c9
movq %r14, %rsi
xorl %eax, %eax
callq 0x5570
leaq 0xabc4(%rip), %rdi      # 0x158c9
movq %r14, %rsi
xorl %eax, %eax
callq 0x5570
leaq 0xabb3(%rip), %rdi      # 0x158c9
movq %rax, %rdx
xorl %eax, %eax
callq 0x5570
jmp 0xad2c
jmp 0xae98
jmp 0xae98
movq %rax, %rbx
xorl %ebp, %ebp
jmp 0xaed9
movq %rax, %rbx
jmp 0xaf0f
movq %rax, %rbx
jmp 0xaf21
movq %rax, %rbx
jmp 0xaf38
jmp 0xaeb4
jmp 0xae98
jmp 0xae4d
movq %rax, %rbx
jmp 0xaee6
movq %rax, %rbx
movq %r13, %rdi
callq 0xedca
movq %r12, %rdi
callq 0x5390
jmp 0xae64
jmp 0xae55
jmp 0xae89
jmp 0xaeb4
jmp 0xae89
jmp 0xae89
jmp 0xae4d
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xe0f2
jmp 0xaf2e
jmp 0xae4d
jmp 0xae4d
jmp 0xae4d
jmp 0xae4d
movq %rdx, %r14
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xadda
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x60(%rsp)
jmp 0xadeb
movq %rdx, %r14
movq %rax, %rbx
movq %r12, %rdi
addq $0x40, %rdi
callq 0xf980
jmp 0xadff
movq %rdx, %r14
movq %rax, %rbx
movq %r13, %rdi
callq 0xed9c
movq %r12, %rdi
callq 0x5390
jmp 0xae17
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0xae64
movq %rbx, %rdi
callq 0x5150
leaq 0x10(%rax), %rbx
callq 0x51b0
leaq 0xa0(%rsp), %rsi
movl $0xb, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0xecdb
callq 0x5530
movq %rax, %rbx
jmp 0xaf2e
movq %rax, %rbx
jmp 0xae64
jmp 0xae89
movq %rax, %rbx
callq 0x55e0
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0xaf2e
callq 0xe634
jmp 0xaf2e
movq %rax, %rdi
callq 0xe6a3
jmp 0xaeb9
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
jne 0xaee1
jmp 0xaee6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xaebc
callq 0x5390
jmp 0xaebc
jmp 0xaec7
jmp 0xaeb4
jmp 0xaeb4
jmp 0xaeb4
movq %rax, %rbx
jmp 0xaed9
movq %rax, %rbx
movq 0x40(%rsp), %rbp
jmp 0xaed9
jmp 0xaec7
jmp 0xaec7
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xaed9
callq 0x5390
testq %rbp, %rbp
je 0xaee6
movq %rbp, %rdi
callq 0x5390
movq 0x110(%rsp), %rdi
testq %rdi, %rdi
je 0xaef8
callq 0x5390
leaq 0x60(%rsp), %rdi
callq 0x7e18
leaq 0xe0(%rsp), %rdi
callq 0xe3a6
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0xaf21
callq 0x5390
leaq 0x80(%rsp), %rdi
callq 0xe3a6
leaq 0x48(%rsp), %rdi
callq 0xe3e0
leaq 0x140(%rsp), %rdi
callq 0xe41a
movq %rbx, %rdi
callq 0x5650
nop