// File: /workspace/github_cpp_makefile_star2_O2/melop[P]admixem/Population.cpp
// Function: Population::Breed()
bool Population::Breed() {
	
	
	int nCurrGen = SimulConfig.GetCurrGen(); // tell what is the current generation
	bool bIgnoreGlobalRules = SimulConfig.pSexualSelConfig->IgnoreGlobalRules(nCurrGen); // is there special sexual selection rules for this generation?
	bool bIgnoreGlobalRulesNa = SimulConfig.pNaturalSelConfig->IgnoreGlobalRules(nCurrGen);
	double nSampleMate = SimulConfig.GetNumericConfig("SampleMate");
	string sOffSpringCountFunc = SimulConfig.GetConfig("kids_per_female_func");
	int nOffSpringCountFunc = (sOffSpringCountFunc=="Poisson")? 1:0; //1 - Poisson, 0- normal distribution with variance being 1/4 of mean

	if (_mpMales.size()==0 || _mpFemales.size()==0) {
		printf("Pop %s cannot breed because one of the sexes is 0...\n", _sPopName.c_str());
		this->_bBred = true;
		return false;
	}

	//Check if natural selection prob or sexual selection prob is zero, if so, no need to continue.
	list< pair< Parser *, int> > * pqParsers = SimulConfig.pNaturalSelConfig->GetFormulae(this->GetPopName());

	for (list< pair< Parser *, int> >::iterator itParser= pqParsers->begin(); itParser != pqParsers->end() ; ++itParser) {
		int nGen = itParser->second;
		if ((nGen ==-1 && !bIgnoreGlobalRules) || (bIgnoreGlobalRulesNa && nGen == nCurrGen) ) {
			if (itParser->first->IsZero) {
				this->_bBred = true;
				return true; //no need to continue since surviving prob is zero.
			}
		}
	}

	printf("Pop %s breeding...\n", _sPopName.c_str());
	int nNewOffSpringCount = 0;
	int nNumFemales = _mpFemales.size();
	
	vector< Poisson* > vOffSpringPoissonGen; 
	

	//set population level variables for freq dependent sexual selection:

	
	map< int, map<string , list< pair<Parser *, int> > > > * mppqParsers = SimulConfig.pSexualSelConfig->GetFormulaeAllCPUs();

	list< vector<string> > * pqvPopCourterSymbols = SimulConfig.pSexualSelConfig->GetFormulaSymbolStringsPopCourter( this->_sPopName);
	list< vector<string> > * pqvPopChooserSymbols = SimulConfig.pSexualSelConfig->GetFormulaSymbolStringsPopChooser( this->_sPopName);
	list< vector<string> > * pqvPopSymbols = SimulConfig.pSexualSelConfig->GetFormulaSymbolStringsPop( this->_sPopName);



	for(int nCPU=0;nCPU<nTotalCPUCore;nCPU++) { //set global current population parameters for all the CPUs

		list< pair< Parser *, int > > * pqParsers = &(*mppqParsers)[nCPU][this->_sPopName];
		list< vector<string> >::iterator itPopCourterSymbols= pqvPopCourterSymbols->begin();
		list< vector<string> >::iterator itPopChooserSymbols= pqvPopChooserSymbols->begin();
		list< vector<string> >::iterator itPopSymbols= pqvPopSymbols->begin();

		for (list< pair< Parser *, int > > ::iterator itParser= pqParsers->begin(); itParser != pqParsers->end() ; ++itParser) {
				vector<string> vSymbolsPopCourter = *itPopCourterSymbols;
				vector<string> vSymbolsPopChooser = *itPopChooserSymbols;
				vector<string> vSymbolsPop = *itPopSymbols;

				Parser * pParser = itParser->first;

				//Set courter symbol values
				for(vector<string>::iterator itSymbol=vSymbolsPop.begin();itSymbol!=vSymbolsPop.end();++itSymbol)
				{
					string sSymbol = (*itSymbol).substr(4);
					string sType = (*itSymbol).substr(0, 3); //either Avg or Std
					if (sType != "Avg" && sType != "Std") {
						throw new Exception("Population parameter type unknown!");
					}
					if (this->_mpSumPhenotype.find(sSymbol) == _mpSumPhenotype.end()) {
						throw new Exception("Unable to find population symbol");
					}
			
					pParser->symbols_[string("Pop_Avg_"+sSymbol)] = this->_mpSumPhenotype[sSymbol].first;
					pParser->symbols_[string("Pop_Std_"+sSymbol)] = this->_mpSumPhenotype[sSymbol].second;
					cout << "CPU:" << nCPU << "Pop_Avg_" << sSymbol.c_str() << "=" << this->_mpSumPhenotype[sSymbol].first << "\n";
					cout << "CPU:" << nCPU << "Pop_Std_" << sSymbol.c_str() << "=" << this->_mpSumPhenotype[sSymbol].second << "\n";
				}

				for(vector<string>::iterator itSymbol=vSymbolsPopCourter.begin();itSymbol!=vSymbolsPopCourter.end();++itSymbol)
				{
					string sSymbol = (*itSymbol).substr(4);
					string sType = (*itSymbol).substr(0, 3); //either Avg or Std
					if (sType != "Avg" && sType != "Std") {
						throw new Exception("Population parameter type unknown!");
					}
					if (this->_mpSumPhenotypeMale.find(sSymbol) == _mpSumPhenotypeMale.end()) {
						throw new Exception("Unable to find population symbol: male");
					}
			
					pParser->symbols_[string("PopCourter_Avg_"+sSymbol)] = this->_mpSumPhenotypeMale[sSymbol].first;
					pParser->symbols_[string("PopCourter_Std_"+sSymbol)] = this->_mpSumPhenotypeMale[sSymbol].second;
					cout << "CPU:" << nCPU << "PopCourter_Avg_" << sSymbol.c_str() << "=" << this->_mpSumPhenotypeMale[sSymbol].first << "\n";
					cout << "CPU:" << nCPU << "PopCourter_Std_" << sSymbol.c_str() << "=" << this->_mpSumPhenotypeMale[sSymbol].second << "\n";
				}

				for(vector<string>::iterator itSymbol=vSymbolsPopChooser.begin();itSymbol!=vSymbolsPopChooser.end();++itSymbol)
				{
					string sSymbol = (*itSymbol).substr(4);
					string sType = (*itSymbol).substr(0, 3); //either Avg or Std
					if (sType != "Avg" && sType != "Std") {
						throw new Exception("Population parameter type unknown!");
					}
					if (this->_mpSumPhenotypeFemale.find(sSymbol) == _mpSumPhenotypeFemale.end()) {
						throw new Exception("Unable to find population symbol: female");
					}
			
					pParser->symbols_[string("PopChooser_Avg_"+sSymbol)] = this->_mpSumPhenotypeFemale[sSymbol].first;
					pParser->symbols_[string("PopChooser_Std_"+sSymbol)] = this->_mpSumPhenotypeFemale[sSymbol].second;
					cout << "CPU:" << nCPU << "PopChooser_Avg_" << sSymbol.c_str() << "=" << this->_mpSumPhenotypeFemale[sSymbol].first << "\n";
					cout << "CPU:" << nCPU << "PopChooser_Std_" << sSymbol.c_str() << "=" << this->_mpSumPhenotypeFemale[sSymbol].second << "\n";


				}
			
				++itPopCourterSymbols;
				++itPopChooserSymbols;
				++itPopSymbols;
		}
	}

	//for (vector<Individual *>::iterator itFemale = _mpFemales.begin(); itFemale!= _mpFemales.end(); ++itFemale) {
	//enable omp. because this is random access, ideal for parallel
	std::set<int> stSampledFemales;//keep a list of the females already sampled so that they're not sampled twice.
	std::set<int> stExhaustedFemales; // a list of females without further gametes
	//int nExhaustedFemales=0;
	bool bCourterHandeled = false;
	int nMaxLoop = SimulConfig.GetNumericConfig("FemaleGiveBirthMaxIterations");
	nMaxLoop = (nMaxLoop==-1)? 1000:nMaxLoop; //do at most 20 loops.
	int nLoopCount = 0;
	int nSameAvgKidIterCount = 0;
	double nPrevKidPerFemale = -1.0;
	do 
	{
		nLoopCount++;
		if (nNewOffSpringCount >= this->_nPopMaxSize) {
			printf("Max Pop Size met.\n");
			break; //no need to continue;
		}
		//#pragma omp critical
		//{
			if (stSampledFemales.size() != 0) {
				stSampledFemales.clear();
			}
		//}
	double nAvgKidPerFemale = (double)(_nPopMaxSize - nNewOffSpringCount) / (double)nNumFemales; // average kid per female, given the number offsprings left to fill the pop
	vOffSpringPoissonGen.clear();
		
	if (nPrevKidPerFemale == nAvgKidPerFemale ) {
		//no addition;
		if (nSameAvgKidIterCount > nMaxLoop) {
			printf("No more breeding possible\n");
			break;
		} else {
			nSameAvgKidIterCount++;	
		}
	}
	nPrevKidPerFemale = nAvgKidPerFemale;
		
	for(int nCPU=0;nCPU<nTotalCPUCore;nCPU++) { //set global current population parameters for all the CPUs

		//initialize poisson generators for offspring numbers
		if (nOffSpringCountFunc == 1 ) {
			Poisson * OffSpPois = new Poisson(nAvgKidPerFemale);
			vOffSpringPoissonGen.push_back(OffSpPois);
		}
	}

	printf("AvgKidPerFemale: %f\n", nAvgKidPerFemale);

	#pragma omp parallel shared(bCourterHandeled, stExhaustedFemales, stSampledFemales, nNumFemales, nSampleMate, bIgnoreGlobalRules, nAvgKidPerFemale, bIgnoreGlobalRulesNa, nNewOffSpringCount) 
	//private(pFemale, nCourters, pCourter, vOffSprings, itOffSpring)
	{
	


	#pragma omp for 
		//reduction(+: nNewOffSpringCount) 
	for(int i=0;i<nNumFemales;i++) 
	{
		if (nNewOffSpringCount >= this->_nPopMaxSize || stExhaustedFemales.size() >= this->_mpFemales.size()) {
			continue; // first see if new pop already filled up by other threads. if so then do nothing.
		}
		
		#ifdef _OPENMP
		int nCPU = omp_get_thread_num();
			#ifdef DEBUG
			printf("CPU %d: %s : %d\n", nCPU, "SexSelFormulae # ", nCPU);
			#endif
		#else
			int nCPU = 0;
		#endif

		//Go over each female so that they can mate.
		int nRandFemaleInd=fnGetRandIndex(nNumFemales);
		bool bGetRandSuccess = true;
		
			while((stSampledFemales.find(nRandFemaleInd)!= stSampledFemales.end()) && (stExhaustedFemales.find(nRandFemaleInd) == stExhaustedFemales.end())) {
				nRandFemaleInd=fnGetRandIndex(nNumFemales);
				if (stExhaustedFemales.size() >= this->_mpFemales.size()) {
					bGetRandSuccess = false;
					break;
				}
			}
			if (bGetRandSuccess) {
				#pragma omp critical
				{
					stSampledFemales.insert(nRandFemaleInd);
				}
			}
		#ifdef DEBUG
		printf("CPU %d: Female Id: %d\n", nCPU, nRandFemaleInd);
		#endif
		if (!bGetRandSuccess) {
			continue;
		}

		Individual * pFemale = this->_mpFemales.at(nRandFemaleInd); //get random female

		if (pFemale->GetGameteNum() == 0) 
		{
				#pragma omp critical
				{
			
			
						stExhaustedFemales.insert(nRandFemaleInd); // this female cannot produce more offsprings.

				}
				continue; //if already no gamete then don't bother.
				//nExhaustedFemales++;
		}

		if (!bCourterHandeled) {
		int nCourters = (int)nSampleMate; //(int)NormalExt(nSampleMate , 1, 0, 100);

		
			for (int j=0;j<nCourters;j++) {
				#ifdef DEBUG
				printf("CPU %d: Breed::beforerandom\n", nCPU);
				printf("CPU %d: _mpMale.size() %d\n", nCPU, _mpMales.size());
				#endif
				
				Individual * pCourter = this->_mpMales.at(fnGetRandIndex(this->_mpMales.size() ));

				#ifdef DEBUG
				printf("CPU %d: Breed::afterrandom\n", nCPU);
				#endif
				//#pragma omp critical
				//{
					pFemale->HandleCourter(pCourter , bIgnoreGlobalRules);
				//}
				#ifdef DEBUG
				printf("CPU %d : Breed::aftercourterhandler\n", nCPU);
				#endif
			}
		}
		

		//After mating, get the offspring out!

		vector<Individual *> vOffSprings;

		int nTargetOffSpringCount =  round(NormalExt(nAvgKidPerFemale,nAvgKidPerFemale/4, 0,10000));

		if ( nOffSpringCountFunc == 1 ) { //use poisson distribution for offspring number
			#ifdef DEBUG
			printf("CPU %d : Getting Target offspring...\n", nCPU );
			#endif
			nTargetOffSpringCount = vOffSpringPoissonGen[nCPU]->Next();
			#ifdef DEBUG
			printf("CPU %d : Target offspring: %d\n", nCPU, nTargetOffSpringCount );
			#endif
		}
		//#pragma omp critical
		//{
		if (nTargetOffSpringCount == 0) {
			continue;
		}

		#ifdef DEBUG

		printf("CPU %d: Breed::GiveBirth before\n", nCPU);
		#endif
		
		pFemale->GiveBirth(vOffSprings, nTargetOffSpringCount, bIgnoreGlobalRulesNa); // to save memory, natural selection that isn't frequency dependent is carried out in the GiveBirth Function!
		
		#ifdef DEBUG

		printf("CPU %d: Breed::GiveBirth after\n", nCPU);
		#endif
		//}

		if (pFemale->GetGameteNum() == 0) 
		{
			#ifdef DEBUG

			printf("CPU %d: Exhausted female before\n", nCPU);
			#endif
			#pragma omp critical
			{
			
			
				stExhaustedFemales.insert(nRandFemaleInd); // this female cannot produce more offsprings.
				//nExhaustedFemales++;
			}

			#ifdef DEBUG
			printf("CPU %d: Exhausted female after\n", nCPU);
			#endif
		}

		#ifdef DEBUG
		printf("CPU %d: Start insert offspring\n", nCPU);
		#endif
		//#pragma omp critical
		//{
		for (vector<Individual *>::iterator itOffSpring = vOffSprings.begin(); itOffSpring!=vOffSprings.end(); ++itOffSpring) 
		{

			if (nNewOffSpringCount < this->_nPopMaxSize)
			{
				if ( (*itOffSpring)->GetSex() == Individual::Male) {

					//#pragma omp critical
						this->_mpvNewGenMales[nCPU].push_back(*itOffSpring);
					//}
				}
				else {
					//#pragma omp critical
					//{
						this->_mpvNewGenFemales[nCPU].push_back(*itOffSpring);
					//}
				}
				#pragma omp critical
				{
					nNewOffSpringCount++;
				}
			}
			else {

				printf("No need to insert more offsprings, break;\n");
				break; // no need to do anything more, already exceeded limit;
			}
		}

		//} // end omp
		#ifdef DEBUG
		printf("CPU %d: end insert offspring\n", nCPU);
		#endif

	}

		
	} //end parallel block

	bCourterHandeled = true;
		
		for(int nCPU=0;nCPU<nTotalCPUCore;nCPU++) { //set global current population parameters for all the CPUs
			//delete poisson generators for offspring numbers
			if (nOffSpringCountFunc == 1 ) {
				#ifdef DEBUG
				printf("CPU %d: Realease poisson generator\n", nCPU);
				#endif
				delete vOffSpringPoissonGen[nCPU];
				vOffSpringPoissonGen[nCPU] = NULL;
			}
		}


	} // end do block
	while( (nLoopCount <= nMaxLoop) && (nNewOffSpringCount < this->_nPopMaxSize) && (stExhaustedFemales.size() < this->_mpFemales.size()) ) ; //end do while block.
	/* needs more work
	int nExcessOffsprings = nNewOffSpringCount - this->_nPopMaxSize;
	int nExcessMales = nExcessOffsprings / 2;
	int nExcessFemales = nExcessOffsprings - nExcessMales;
	int nDeletedMales = 0;
	int nDeletedFemales = 0;
	
	if (nExcessOffsprings > 0) {
		printf("Delete %d extra males and %d females (total %d)\n", nExcessMales,  nExcessFemales, nExcessOffsprings);	
	}
	
		for(int nCPU=0;nCPU<nTotalCPUCore;nCPU++) { //set global current population parameters for all the CPUs

			if (nDeletedMales < nExcessMales && (!this->_mpvNewGenMales[nCPU].empty())) {
				Individual *pToDelete = (this->_mpvNewGenMales[nCPU].back());
				this->_mpvNewGenMales[nCPU].pop_back();
				delete pToDelete;
				nDeletedMales++;
			}
                        if (nDeletedFemales < nExcessFemales && (!this->_mpvNewGenFemales[nCPU].empty())) {
                                Individual *pToDelete = (this->_mpvNewGenFemales[nCPU].back());
                                this->_mpvNewGenFemales[nCPU].pop_back();
				delete pToDelete;
                                nDeletedFemales++;
                        }
		}
	*/
	
	this->_bBred = true; //set flag
	return true;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rdi, 0x10(%rsp)
leaq 0x1f093(%rip), %rbx     # 0x45938
movq %rbx, %rdi
callq 0x16ac0
movl %eax, %ebp
movq 0x28(%rbx), %rdi
movl %eax, %esi
callq 0x15162
movb %al, 0xf(%rsp)
movq 0x20(%rbx), %rdi
movl %ebp, %esi
callq 0x139e6
movl %eax, %ebx
leaq 0x8ff2(%rip), %rsi      # 0x2f8c4
leaq 0x288(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x9512
leaq 0x1f04a(%rip), %rdi     # 0x45938
leaq 0x288(%rsp), %rsi
callq 0x16872
movsd %xmm0, 0x138(%rsp)
leaq 0x288(%rsp), %rdi
callq 0x71a0
leaq 0x8fb7(%rip), %rsi      # 0x2f8cf
leaq 0x248(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x9512
movb %bl, 0xe(%rsp)
leaq 0x1f000(%rip), %rbx     # 0x45938
leaq 0x268(%rsp), %rdi
leaq 0x248(%rsp), %rdx
movq %rbx, %rsi
callq 0xf118
leaq 0x248(%rsp), %rdi
callq 0x71a0
leaq 0x6fa8(%rip), %rsi      # 0x2d90c
leaq 0x268(%rsp), %rdi
callq 0x954d
movb %al, 0xd(%rsp)
movq 0x10(%rsp), %r15
movq 0x50(%r15), %rax
cmpq 0x48(%r15), %rax
je 0x26a28
movq 0x68(%r15), %rax
cmpq 0x60(%r15), %rax
je 0x26a28
movq 0x20(%rbx), %r14
leaq 0x228(%rsp), %rdi
movq %r15, %rsi
callq 0x7550
leaq 0x228(%rsp), %rsi
movq %r14, %rdi
callq 0x13a18
movb 0xe(%rsp), %r15b
movq %rax, %r14
movq 0x10(%rsp), %rax
leaq 0x48(%rax), %rcx
movq %rcx, 0x168(%rsp)
addq $0x60, %rax
movq %rax, 0x160(%rsp)
leaq 0x228(%rsp), %rdi
callq 0x71a0
movq %r14, %rax
movq (%rax), %rax
cmpq %r14, %rax
je 0x26a45
movl 0x18(%rax), %edx
cmpl $-0x1, %edx
setne %cl
cmpl %ebp, %edx
sete %dl
testb %dl, %r15b
jne 0x26a10
orb 0xf(%rsp), %cl
jne 0x269ef
movq 0x10(%rax), %rcx
cmpb $0x1, 0x61(%rcx)
jne 0x269ef
movq 0x10(%rsp), %rax
movb $0x1, 0x40(%rax)
jmp 0x27848
movq (%r15), %rsi
leaq 0x8eb2(%rip), %rdi      # 0x2f8e4
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x7050
movb $0x1, 0x40(%r15)
jmp 0x2784a
movq 0x10(%rsp), %r15
movq (%r15), %rsi
leaq 0x8ec6(%rip), %rdi      # 0x2f91a
xorl %eax, %eax
callq 0x7050
movq 0x68(%r15), %rax
subq 0x60(%r15), %rax
movq %rax, 0x50(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xa0(%rsp)
andq $0x0, 0xb0(%rsp)
movq 0x28(%rbx), %rdi
callq 0x151ca
movq %rax, 0x158(%rsp)
movq 0x28(%rbx), %r14
leaq 0x208(%rsp), %rdi
movq %r15, %rsi
callq 0x7550
leaq 0x208(%rsp), %rsi
movq %r14, %rdi
callq 0x151f4
movq %rax, 0x150(%rsp)
leaq 0x208(%rsp), %rdi
callq 0x71a0
movq 0x28(%rbx), %r14
leaq 0x1e8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7550
leaq 0x1e8(%rsp), %rsi
movq %r14, %rdi
callq 0x15200
movq %rax, 0x148(%rsp)
leaq 0x1e8(%rsp), %rdi
callq 0x71a0
movq 0x28(%rbx), %rbx
leaq 0x1c8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7550
leaq 0x1c8(%rsp), %rsi
movq %rbx, %rdi
callq 0x151e8
movq %rax, 0x140(%rsp)
shrq $0x3, 0x50(%rsp)
leaq 0x1c8(%rsp), %rdi
callq 0x71a0
movq 0x10(%rsp), %rax
leaq 0xb8(%rax), %rcx
movq %rcx, 0x38(%rsp)
leaq 0xc0(%rax), %rcx
movq %rcx, 0x58(%rsp)
leaq 0xe8(%rax), %rcx
movq %rcx, 0x28(%rsp)
leaq 0xf0(%rax), %rcx
movq %rcx, 0x98(%rsp)
leaq 0x118(%rax), %rcx
movq %rcx, 0x30(%rsp)
addq $0x120, %rax            # imm = 0x120
movq %rax, 0x90(%rsp)
xorl %eax, %eax
leaq 0xc0(%rsp), %r13
leaq 0x108(%rsp), %r15
leaq 0x60(%rsp), %rbx
movl %eax, 0x1c(%rsp)
leaq 0x1e82c(%rip), %rcx     # 0x453e4
cmpl (%rcx), %eax
jge 0x27338
movq 0x158(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x176fe
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1774c
movq %rax, %rcx
movq 0x150(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x148(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x140(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x80(%rsp)
movq %rcx, 0x40(%rsp)
movq %rcx, 0x170(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
cmpq %rcx, %rax
je 0x2732d
movq 0x48(%rsp), %rax
leaq 0x10(%rax), %rsi
leaq 0xf0(%rsp), %rdi
callq 0x1dc64
movq 0x88(%rsp), %rax
leaq 0x10(%rax), %rsi
leaq 0x190(%rsp), %rdi
callq 0x1dc64
movq 0x80(%rsp), %rax
leaq 0x10(%rax), %rsi
leaq 0x178(%rsp), %rdi
callq 0x1dc64
movq 0x40(%rsp), %rax
movq 0x10(%rax), %r14
movq 0x178(%rsp), %r12
addq $0x68, %r14
cmpq 0x180(%rsp), %r12
je 0x26ea0
movq %r13, %rdi
movq %r12, %rsi
pushq $0x4
popq %rdx
pushq $-0x1
popq %rcx
callq 0x7430
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
pushq $0x3
popq %rcx
callq 0x7430
movq %r15, %rdi
leaq 0x81e5(%rip), %rsi      # 0x2eeb6
callq 0x17c35
testb %al, %al
je 0x26cf1
movq %r15, %rdi
leaq 0x81d6(%rip), %rsi      # 0x2eeba
callq 0x17c35
testb %al, %al
jne 0x278e6
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x24054
cmpq 0x58(%rsp), %rax
je 0x2786b
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x8c27(%rip), %rsi      # 0x2f951
movq %r13, %rdx
callq 0x9325
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18432
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
callq 0x71a0
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x8be9(%rip), %rsi      # 0x2f95a
movq %r13, %rdx
callq 0x9325
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18432
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
callq 0x71a0
movq 0x1e1f3(%rip), %rdi     # 0x44f90
leaq 0x8bbf(%rip), %rsi      # 0x2f963
callq 0x73d0
movl 0x1c(%rsp), %esi
movq %rax, %rdi
callq 0x76b0
movq %rax, %rdi
leaq 0x8b92(%rip), %rsi      # 0x2f951
callq 0x73d0
movq 0xc0(%rsp), %rsi
movq %rax, %rdi
callq 0x73d0
movq %rax, %rdi
leaq 0x879f(%rip), %rsi      # 0x2f57d
callq 0x73d0
movq %rax, %rbp
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd (%rax), %xmm0
movq %rbp, %rdi
callq 0x7620
movq %rax, %rdi
leaq 0x713e(%rip), %rsi      # 0x2df47
callq 0x73d0
movq 0x1e17b(%rip), %rdi     # 0x44f90
leaq 0x8b47(%rip), %rsi      # 0x2f963
callq 0x73d0
movl 0x1c(%rsp), %esi
movq %rax, %rdi
callq 0x76b0
movq %rax, %rdi
leaq 0x8b23(%rip), %rsi      # 0x2f95a
callq 0x73d0
movq 0xc0(%rsp), %rsi
movq %rax, %rdi
callq 0x73d0
movq %rax, %rdi
leaq 0x8727(%rip), %rsi      # 0x2f57d
callq 0x73d0
movq %rax, %rbp
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd 0x8(%rax), %xmm0
movq %rbp, %rdi
callq 0x7620
movq %rax, %rdi
leaq 0x70c5(%rip), %rsi      # 0x2df47
callq 0x73d0
movq %r15, %rdi
callq 0x71a0
movq %r13, %rdi
callq 0x71a0
addq $0x20, %r12
jmp 0x26c98
movq 0xf0(%rsp), %r12
cmpq 0xf8(%rsp), %r12
je 0x270b3
movq %r13, %rdi
movq %r12, %rsi
pushq $0x4
popq %rdx
pushq $-0x1
popq %rcx
callq 0x7430
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
pushq $0x3
popq %rcx
callq 0x7430
movq %r15, %rdi
leaq 0x7fd5(%rip), %rsi      # 0x2eeb6
callq 0x17c35
testb %al, %al
je 0x26f01
movq %r15, %rdi
leaq 0x7fc6(%rip), %rsi      # 0x2eeba
callq 0x17c35
testb %al, %al
jne 0x2791f
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x24054
cmpq 0x98(%rsp), %rax
je 0x27892
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x8a52(%rip), %rsi      # 0x2f98f
movq %r13, %rdx
callq 0x9325
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18432
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
callq 0x71a0
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x8a1b(%rip), %rsi      # 0x2f99f
movq %r13, %rdx
callq 0x9325
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18432
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
callq 0x71a0
movq 0x1dfe0(%rip), %rdi     # 0x44f90
leaq 0x89ac(%rip), %rsi      # 0x2f963
callq 0x73d0
movl 0x1c(%rsp), %esi
movq %rax, %rdi
callq 0x76b0
movq %rax, %rdi
leaq 0x89bd(%rip), %rsi      # 0x2f98f
callq 0x73d0
movq 0xc0(%rsp), %rsi
movq %rax, %rdi
callq 0x73d0
movq %rax, %rdi
leaq 0x858c(%rip), %rsi      # 0x2f57d
callq 0x73d0
movq %rax, %rbp
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd (%rax), %xmm0
movq %rbp, %rdi
callq 0x7620
movq %rax, %rdi
leaq 0x6f2b(%rip), %rsi      # 0x2df47
callq 0x73d0
movq 0x1df68(%rip), %rdi     # 0x44f90
leaq 0x8934(%rip), %rsi      # 0x2f963
callq 0x73d0
movl 0x1c(%rsp), %esi
movq %rax, %rdi
callq 0x76b0
movq %rax, %rdi
leaq 0x8955(%rip), %rsi      # 0x2f99f
callq 0x73d0
movq 0xc0(%rsp), %rsi
movq %rax, %rdi
callq 0x73d0
movq %rax, %rdi
leaq 0x8514(%rip), %rsi      # 0x2f57d
callq 0x73d0
movq %rax, %rbp
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd 0x8(%rax), %xmm0
movq %rbp, %rdi
callq 0x7620
movq %rax, %rdi
leaq 0x6eb2(%rip), %rsi      # 0x2df47
callq 0x73d0
movq %r15, %rdi
callq 0x71a0
movq %r13, %rdi
callq 0x71a0
addq $0x20, %r12
jmp 0x26ea8
movq 0x190(%rsp), %r12
cmpq 0x198(%rsp), %r12
je 0x272c6
movq %r13, %rdi
movq %r12, %rsi
pushq $0x4
popq %rdx
pushq $-0x1
popq %rcx
callq 0x7430
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
pushq $0x3
popq %rcx
callq 0x7430
movq %r15, %rdi
leaq 0x7dc2(%rip), %rsi      # 0x2eeb6
callq 0x17c35
testb %al, %al
je 0x27114
movq %r15, %rdi
leaq 0x7db3(%rip), %rsi      # 0x2eeba
callq 0x17c35
testb %al, %al
jne 0x27958
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x24054
cmpq 0x90(%rsp), %rax
je 0x278bc
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x8888(%rip), %rsi      # 0x2f9d8
movq %r13, %rdx
callq 0x9325
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18432
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
callq 0x71a0
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x8851(%rip), %rsi      # 0x2f9e8
movq %r13, %rdx
callq 0x9325
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18432
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
callq 0x71a0
movq 0x1ddcd(%rip), %rdi     # 0x44f90
leaq 0x8799(%rip), %rsi      # 0x2f963
callq 0x73d0
movl 0x1c(%rsp), %esi
movq %rax, %rdi
callq 0x76b0
movq %rax, %rdi
leaq 0x87f3(%rip), %rsi      # 0x2f9d8
callq 0x73d0
movq 0xc0(%rsp), %rsi
movq %rax, %rdi
callq 0x73d0
movq %rax, %rdi
leaq 0x8379(%rip), %rsi      # 0x2f57d
callq 0x73d0
movq %rax, %rbp
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd (%rax), %xmm0
movq %rbp, %rdi
callq 0x7620
movq %rax, %rdi
leaq 0x6d18(%rip), %rsi      # 0x2df47
callq 0x73d0
movq 0x1dd55(%rip), %rdi     # 0x44f90
leaq 0x8721(%rip), %rsi      # 0x2f963
callq 0x73d0
movl 0x1c(%rsp), %esi
movq %rax, %rdi
callq 0x76b0
movq %rax, %rdi
leaq 0x878b(%rip), %rsi      # 0x2f9e8
callq 0x73d0
movq 0xc0(%rsp), %rsi
movq %rax, %rdi
callq 0x73d0
movq %rax, %rdi
leaq 0x8301(%rip), %rsi      # 0x2f57d
callq 0x73d0
movq %rax, %rbp
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x2322c
movsd 0x8(%rax), %xmm0
movq %rbp, %rdi
callq 0x7620
movq %rax, %rdi
leaq 0x6c9f(%rip), %rsi      # 0x2df47
callq 0x73d0
movq %r15, %rdi
callq 0x71a0
movq %r13, %rdi
callq 0x71a0
addq $0x20, %r12
jmp 0x270bb
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x80(%rsp)
leaq 0x178(%rsp), %rdi
callq 0x17632
leaq 0x190(%rsp), %rdi
callq 0x17632
leaq 0xf0(%rsp), %rdi
callq 0x17632
movq 0x170(%rsp), %rcx
jmp 0x26c25
movl 0x1c(%rsp), %eax
incl %eax
jmp 0x26bad
leaq 0xc8(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x110(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x867f(%rip), %rsi      # 0x2f9f8
leaq 0x1a8(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x9512
leaq 0x1e5a6(%rip), %rdi     # 0x45938
leaq 0x1a8(%rsp), %rsi
callq 0x16872
leaq 0x1e03e(%rip), %r13     # 0x453e4
cvttsd2si %xmm0, %ebx
leaq 0x1a8(%rsp), %rdi
callq 0x71a0
cmpl $-0x1, %ebx
movl $0x3e8, %r15d           # imm = 0x3E8
cmovnel %ebx, %r15d
movq 0x50(%rsp), %rax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x90(%rsp)
cvttsd2si 0x138(%rsp), %ecx
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %edx
movq %rdx, 0x40(%rsp)
cmovlel %esi, %ecx
movl %ecx, 0x98(%rsp)
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movl %ecx, 0x38(%rsp)
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %eax
movsd 0x6013(%rip), %xmm0     # 0x2d428
movsd %xmm0, 0x20(%rsp)
leaq 0xc0(%rsp), %rbp
leaq 0xf0(%rsp), %rbx
movl $0x0, 0x58(%rsp)
movq $0x0, 0x30(%rsp)
xorl %r12d, %r12d
movl %r15d, 0x48(%rsp)
cmpl %eax, %r12d
jge 0x2780c
cmpq $0x0, 0xe8(%rsp)
je 0x27468
movq %rbp, %rdi
callq 0x29708
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %eax
movq 0xa0(%rsp), %rcx
cmpq %rcx, 0xa8(%rsp)
je 0x27482
movq %rcx, 0xa8(%rsp)
subl %r12d, %eax
cvtsi2sd %eax, %xmm0
divsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x274ca
jp 0x274ca
movq 0x40(%rsp), %rax
cmpl %r15d, %eax
jle 0x274c3
leaq 0x86f0(%rip), %rdi      # 0x2fba7
callq 0x75c0
xorl %eax, %eax
jmp 0x277cf
incl %eax
movq %rax, 0x40(%rsp)
xorl %r15d, %r15d
cmpl (%r13), %r15d
jge 0x2750f
cmpb $0x0, 0xd(%rsp)
je 0x2750a
pushq $0x10
popq %rdi
callq 0x73f0
movq %rax, %r14
movq %rax, %rdi
movsd 0x28(%rsp), %xmm0
callq 0xc584
movq %r14, 0x60(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x17084
incl %r15d
jmp 0x274cd
leaq 0x84ff(%rip), %rdi      # 0x2fa15
movsd 0x28(%rsp), %xmm0
movb $0x1, %al
callq 0x7050
movsd 0x28(%rsp), %xmm0
mulsd 0x7abf(%rip), %xmm0     # 0x2eff0
movsd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
cmpl 0x38(%rsp), %r15d
je 0x27772
movq 0x10(%rsp), %rcx
cmpl 0x2c(%rcx), %r12d
jge 0x2776a
movq 0x68(%rcx), %rax
subq 0x60(%rcx), %rax
sarq $0x3, %rax
cmpq %rax, 0x130(%rsp)
jae 0x2776a
movq 0x50(%rsp), %rdi
callq 0x25c49
movl %eax, 0xf0(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x1df42
leaq 0xc8(%rsp), %rcx
cmpq %rcx, %rax
je 0x275e5
leaq 0x108(%rsp), %rdi
movq %rbx, %rsi
callq 0x1df42
leaq 0x110(%rsp), %rcx
cmpq %rcx, %rax
jne 0x275e5
movq 0x50(%rsp), %rdi
callq 0x25c49
movl %eax, 0xf0(%rsp)
movq 0x10(%rsp), %rcx
movq 0x68(%rcx), %rax
subq 0x60(%rcx), %rax
sarq $0x3, %rax
cmpq %rax, 0x130(%rsp)
jb 0x2757f
jmp 0x2776a
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x1ddf0
movslq 0xf0(%rsp), %rsi
movq 0x160(%rsp), %rdi
callq 0x232b2
movq (%rax), %r14
movq %r14, %rdi
callq 0x226b8
testl %eax, %eax
je 0x276f8
testb $0x1, 0x30(%rsp)
je 0x2770a
xorpd %xmm0, %xmm0
movapd %xmm0, 0x60(%rsp)
andq $0x0, 0x70(%rsp)
xorps %xmm2, %xmm2
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x8226(%rip), %xmm3     # 0x2f870
callq 0x25ba4
leaq 0x1dd8e(%rip), %r13     # 0x453e4
callq 0x25c97
cmpb $0x0, 0xd(%rsp)
je 0x27672
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cvttsd2si %xmm0, %edx
testl %edx, %edx
je 0x27760
movzbl 0xe(%rsp), %ecx
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x226bc
movq %r14, %rdi
callq 0x226b8
testl %eax, %eax
jne 0x276ac
leaq 0x108(%rsp), %rdi
movq %rbx, %rsi
callq 0x1ddf0
movq 0x60(%rsp), %r14
cmpq 0x68(%rsp), %r14
je 0x27760
movq 0x10(%rsp), %rax
cmpl 0x2c(%rax), %r12d
jge 0x27754
movq (%r14), %rdi
callq 0x20c92
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movq 0x10(%rsp), %rax
movq 0xa8(%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x2320e
incl %r12d
addq $0x8, %r14
jmp 0x276b1
leaq 0x108(%rsp), %rdi
movq %rbx, %rsi
callq 0x1ddf0
jmp 0x2776a
movl 0x98(%rsp), %r13d
subl $0x1, %r13d
jb 0x27623
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
subq 0x48(%rax), %rdi
shrq $0x3, %rdi
callq 0x25c49
movslq %eax, %rsi
movq 0x168(%rsp), %rdi
callq 0x232b2
movq (%rax), %rsi
movzbl 0xf(%rsp), %edx
movq %r14, %rdi
callq 0x21712
jmp 0x27712
leaq 0x8422(%rip), %rdi      # 0x2fb7d
callq 0x75c0
leaq 0x60(%rsp), %rdi
callq 0x234c6
incl %r15d
jmp 0x2753a
movl (%r13), %eax
xorl %r14d, %r14d
movl 0x48(%rsp), %r15d
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x277ba
cmpb $0x0, 0xd(%rsp)
je 0x277b5
movq 0xa0(%rsp), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x277b0
movq (%rdi), %rax
callq *0x20(%rax)
movl (%r13), %eax
movq 0xa0(%rsp), %rcx
andq $0x0, (%rcx,%r14,8)
incq %r14
jmp 0x2777e
movb $0x1, %al
movq %rax, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movb $0x1, %al
testb %al, %al
je 0x27818
cmpl %r15d, 0x58(%rsp)
jge 0x27818
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %eax
cmpl %eax, %r12d
jge 0x27818
movq 0x10(%rsp), %rdx
movq 0x68(%rdx), %rcx
subq 0x60(%rdx), %rcx
incl 0x58(%rsp)
sarq $0x3, %rcx
cmpq %rcx, 0x130(%rsp)
jb 0x27444
jmp 0x27818
leaq 0x83ae(%rip), %rdi      # 0x2fbc1
callq 0x75c0
movq 0x10(%rsp), %rax
movb $0x1, 0x40(%rax)
leaq 0x108(%rsp), %rdi
callq 0x29692
leaq 0xc0(%rsp), %rdi
callq 0x29692
leaq 0xa0(%rsp), %rdi
callq 0x296ea
movb $0x1, %bl
leaq 0x268(%rsp), %rdi
callq 0x71a0
movl %ebx, %eax
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x71d0
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x73f0
movq %rax, %r15
leaq 0x760d(%rip), %rsi      # 0x2ee95
movq %rax, %rdi
callq 0xad94
jmp 0x2790b
pushq $0x8
popq %rdi
callq 0x71d0
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x73f0
movq %rax, %r15
leaq 0x80b9(%rip), %rsi      # 0x2f968
movq %rax, %rdi
callq 0xad94
jmp 0x27944
pushq $0x8
popq %rdi
callq 0x71d0
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x73f0
movq %rax, %r15
leaq 0x80d6(%rip), %rsi      # 0x2f9af
movq %rax, %rdi
callq 0xad94
jmp 0x2797d
pushq $0x8
popq %rdi
callq 0x71d0
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x73f0
movq %rax, %r15
leaq 0x802b(%rip), %rsi      # 0x2f92e
movq %rax, %rdi
callq 0xad94
movq %r15, (%r14)
leaq 0x1d3c3(%rip), %rsi     # 0x44cd8
movq %r14, %rdi
xorl %edx, %edx
callq 0x76a0
pushq $0x8
popq %rdi
callq 0x71d0
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x73f0
movq %rax, %r15
leaq 0x7ff2(%rip), %rsi      # 0x2f92e
movq %rax, %rdi
callq 0xad94
movq %r15, (%r14)
leaq 0x1d38a(%rip), %rsi     # 0x44cd8
movq %r14, %rdi
xorl %edx, %edx
callq 0x76a0
pushq $0x8
popq %rdi
callq 0x71d0
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x73f0
movq %rax, %r15
leaq 0x7fb9(%rip), %rsi      # 0x2f92e
movq %rax, %rdi
callq 0xad94
movq %r15, (%r14)
leaq 0x1d351(%rip), %rsi     # 0x44cd8
movq %r14, %rdi
xorl %edx, %edx
callq 0x76a0
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
callq 0x71a0
jmp 0x27a81
jmp 0x27a7e
movq %rax, %rbx
leaq 0x1c8(%rsp), %rdi
jmp 0x279da
jmp 0x27a76
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
jmp 0x279da
jmp 0x27a76
movq %rax, %rbx
leaq 0x208(%rsp), %rdi
callq 0x71a0
jmp 0x27b5c
jmp 0x27a76
jmp 0x27a76
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x71a0
jmp 0x27b69
movq %rax, %rbx
jmp 0x27b69
movq %rax, %rbx
leaq 0x248(%rsp), %rdi
jmp 0x27b71
jmp 0x27a2d
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
jmp 0x27b71
movq %rax, %rbx
jmp 0x27b76
jmp 0x27a7e
jmp 0x27a7e
jmp 0x27a76
jmp 0x27a51
jmp 0x27a7e
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x7400
jmp 0x27a81
jmp 0x27a7e
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x234c6
jmp 0x27a81
jmp 0x27a7e
jmp 0x27a7e
jmp 0x27a7e
movq %rax, %rbx
jmp 0x27b4f
movq %rax, %rbx
jmp 0x27b42
movq %rax, %rbx
jmp 0x27b5c
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x29692
leaq 0xc0(%rsp), %rdi
callq 0x29692
jmp 0x27b5c
jmp 0x27aae
jmp 0x27aae
jmp 0x27aae
jmp 0x27aae
jmp 0x27aca
jmp 0x27aae
jmp 0x27aca
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x7400
jmp 0x27acd
jmp 0x27aca
jmp 0x27b18
jmp 0x27b18
jmp 0x27b18
jmp 0x27aca
jmp 0x27aca
movq %rax, %rbx
movq %r14, %rdi
callq 0x7300
jmp 0x27b1b
jmp 0x27af3
jmp 0x27af8
jmp 0x27b18
jmp 0x27b18
jmp 0x27b05
jmp 0x27b18
jmp 0x27b05
jmp 0x27af3
jmp 0x27af8
jmp 0x27b18
jmp 0x27b18
jmp 0x27b05
jmp 0x27b18
jmp 0x27b05
movq %rax, %rbx
jmp 0x27b35
movq %rax, %rbx
jmp 0x27b28
jmp 0x27b18
jmp 0x27b18
jmp 0x27b05
jmp 0x27b18
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x71a0
jmp 0x27b1b
jmp 0x27b18
jmp 0x27b18
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x71a0
leaq 0xc0(%rsp), %rdi
callq 0x71a0
leaq 0x178(%rsp), %rdi
callq 0x17632
leaq 0x190(%rsp), %rdi
callq 0x17632
leaq 0xf0(%rsp), %rdi
callq 0x17632
leaq 0xa0(%rsp), %rdi
callq 0x296ea
leaq 0x268(%rsp), %rdi
callq 0x71a0
movq %rbx, %rdi
callq 0x76d0