// File: 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
movq %rsp, %rbp
subq $0x970, %rsp            # imm = 0x970
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x570(%rbp)
leaq 0x43787(%rip), %rdi     # 0xaaa58
movq %rdi, -0x568(%rbp)
callq 0x282f0
movl %eax, %ecx
movq -0x568(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x28(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x257a0
movb %al, %cl
movq -0x568(%rbp), %rax
movb %cl, -0x15(%rbp)
movq 0x20(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x23a30
movb %al, -0x16(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x560(%rbp)
callq 0x8870
movq -0x560(%rbp), %rdx
leaq 0x1183e(%rip), %rsi     # 0x78b6c
leaq -0x40(%rbp), %rdi
callq 0xcb30
jmp 0x67339
leaq 0x43718(%rip), %rdi     # 0xaaa58
leaq -0x40(%rbp), %rsi
callq 0x27e40
movsd %xmm0, -0x578(%rbp)
jmp 0x67353
leaq -0x40(%rbp), %rdi
callq 0x82e0
leaq -0x41(%rbp), %rdi
callq 0x8540
movsd -0x578(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0x580(%rbp)
callq 0x8870
movq -0x580(%rbp), %rdx
leaq 0x117e4(%rip), %rsi     # 0x78b77
leaq -0x98(%rbp), %rdi
callq 0xcb30
jmp 0x673a1
leaq 0x436b0(%rip), %rsi     # 0xaaa58
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x1c190
jmp 0x673ba
leaq -0x98(%rbp), %rdi
callq 0x82e0
leaq -0x99(%rbp), %rdi
callq 0x8540
leaq 0xf77b(%rip), %rsi      # 0x76b54
leaq -0x78(%rbp), %rdi
callq 0xcbe0
movb %al, -0x581(%rbp)
jmp 0x673ea
movq -0x570(%rbp), %rdi
movb -0x581(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0xa0(%rbp)
addq $0x48, %rdi
callq 0x5c320
cmpq $0x0, %rax
je 0x67433
movq -0x570(%rbp), %rdi
addq $0x60, %rdi
callq 0x5c320
cmpq $0x0, %rax
jne 0x674e9
movq -0x570(%rbp), %rdi
callq 0x81d0
movq %rax, %rsi
leaq 0x11743(%rip), %rdi     # 0x78b8c
xorl %eax, %eax
callq 0x8080
jmp 0x67452
movq -0x570(%rbp), %rax
movb $0x1, 0x40(%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x6971d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x67493
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x82e0
leaq -0x41(%rbp), %rdi
callq 0x8540
jmp 0x6973d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x674c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x82e0
leaq -0x99(%rbp), %rdi
callq 0x8540
jmp 0x6973d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x69734
movq -0x570(%rbp), %rsi
leaq 0x43561(%rip), %rax     # 0xaaa58
movq 0x20(%rax), %rax
movq %rax, -0x590(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x69750
jmp 0x67510
movq -0x590(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x23a90
movq %rax, -0x598(%rbp)
jmp 0x6752c
leaq -0xd0(%rbp), %rdi
callq 0x82e0
movq -0x598(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x4a510
movq %rax, -0xd8(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x33090
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x4a540
testb $0x1, %al
jne 0x67588
jmp 0x67622
leaq -0xd8(%rbp), %rdi
callq 0x5c0c0
movl 0x8(%rax), %eax
movl %eax, -0xe4(%rbp)
cmpl $-0x1, -0xe4(%rbp)
jne 0x675ac
testb $0x1, -0x15(%rbp)
je 0x675bd
testb $0x1, -0x16(%rbp)
je 0x6760f
movl -0xe4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x6760f
leaq -0xd8(%rbp), %rdi
callq 0x5c0c0
movq (%rax), %rax
testb $0x1, 0x61(%rax)
je 0x6760d
movq -0x570(%rbp), %rax
movb $0x1, 0x40(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x6971d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x82e0
jmp 0x69734
jmp 0x6760f
jmp 0x67611
leaq -0xd8(%rbp), %rdi
callq 0x4a5a0
jmp 0x67559
movq -0x570(%rbp), %rdi
callq 0x81d0
movq %rax, %rsi
leaq 0x1158a(%rip), %rdi     # 0x78bc2
xorl %eax, %eax
callq 0x8080
jmp 0x67641
movq -0x570(%rbp), %rdi
movl $0x0, -0xe8(%rbp)
addq $0x60, %rdi
callq 0x5c320
movl %eax, -0xec(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x2ada0
leaq 0x433e4(%rip), %rax     # 0xaaa58
movq 0x28(%rax), %rdi
callq 0x25870
movq %rax, -0x5a0(%rbp)
jmp 0x67686
movq -0x570(%rbp), %rsi
movq -0x5a0(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq 0x433b6(%rip), %rax     # 0xaaa58
movq 0x28(%rax), %rax
movq %rax, -0x5a8(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x81f0
jmp 0x676bb
movq -0x5a8(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x25920
movq %rax, -0x5b0(%rbp)
jmp 0x676d7
leaq -0x138(%rbp), %rdi
callq 0x82e0
movq -0x5b0(%rbp), %rax
movq -0x570(%rbp), %rsi
movq %rax, -0x118(%rbp)
leaq 0x43359(%rip), %rax     # 0xaaa58
movq 0x28(%rax), %rax
movq %rax, -0x5b8(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x81f0
jmp 0x67718
movq -0x5b8(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x25950
movq %rax, -0x5c0(%rbp)
jmp 0x67734
leaq -0x160(%rbp), %rdi
callq 0x82e0
movq -0x5c0(%rbp), %rax
movq -0x570(%rbp), %rsi
movq %rax, -0x140(%rbp)
leaq 0x432fc(%rip), %rax     # 0xaaa58
movq 0x28(%rax), %rax
movq %rax, -0x5c8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x81f0
jmp 0x67775
movq -0x5c8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x258f0
movq %rax, -0x5d0(%rbp)
jmp 0x67791
leaq -0x188(%rbp), %rdi
callq 0x82e0
movq -0x5d0(%rbp), %rax
movq %rax, -0x168(%rbp)
movl $0x0, -0x18c(%rbp)
movl -0x18c(%rbp), %eax
leaq 0x42d3a(%rip), %rcx     # 0xaa4fc
cmpl (%rcx), %eax
jge 0x68cbe
movq -0x110(%rbp), %rdi
leaq -0x18c(%rbp), %rsi
callq 0x2c580
movq %rax, -0x5d8(%rbp)
jmp 0x677e6
movq -0x570(%rbp), %rsi
movq -0x5d8(%rbp), %rdi
callq 0x2c6b0
movq %rax, -0x5e0(%rbp)
jmp 0x67802
movq -0x5e0(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x118(%rbp), %rdi
callq 0x4bdb0
movq %rax, -0x1a0(%rbp)
movq -0x140(%rbp), %rdi
callq 0x4bdb0
movq %rax, -0x1a8(%rbp)
movq -0x168(%rbp), %rdi
callq 0x4bdb0
movq %rax, -0x1b0(%rbp)
movq -0x198(%rbp), %rdi
callq 0x4a510
movq %rax, -0x1b8(%rbp)
movq -0x198(%rbp), %rdi
callq 0x33090
movq %rax, -0x1c0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x4a540
testb $0x1, %al
jne 0x6788b
jmp 0x68ca8
leaq -0x1a0(%rbp), %rdi
callq 0x4bea0
movq %rax, %rsi
leaq -0x1d8(%rbp), %rdi
callq 0x4c8d0
jmp 0x678a8
leaq -0x1a8(%rbp), %rdi
callq 0x4bea0
movq %rax, %rsi
leaq -0x1f0(%rbp), %rdi
callq 0x4c8d0
jmp 0x678c5
leaq -0x1b0(%rbp), %rdi
callq 0x4bea0
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
callq 0x4c8d0
jmp 0x678e2
leaq -0x1b8(%rbp), %rdi
callq 0x5c0c0
movq (%rax), %rax
movq %rax, -0x210(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3f3c0
movq %rax, -0x218(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3f240
movq %rax, -0x220(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x46260
testb $0x1, %al
jne 0x6793a
jmp 0x67fc5
leaq -0x218(%rbp), %rdi
callq 0x462a0
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
movl $0x4, %edx
movq $-0x1, %rcx
callq 0x8500
jmp 0x67963
leaq -0x218(%rbp), %rdi
callq 0x462a0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x260(%rbp), %rdi
movl $0x3, %ecx
callq 0x8500
jmp 0x67989
leaq 0x10766(%rip), %rsi     # 0x780f6
leaq -0x260(%rbp), %rdi
callq 0x2d8a0
movb %al, -0x5e1(%rbp)
jmp 0x679a4
movb -0x5e1(%rbp), %al
testb $0x1, %al
jne 0x679b3
jmp 0x67b35
leaq 0x10740(%rip), %rsi     # 0x780fa
leaq -0x260(%rbp), %rdi
callq 0x2d8a0
movb %al, -0x5e2(%rbp)
jmp 0x679ce
movb -0x5e2(%rbp), %al
testb $0x1, %al
jne 0x679dd
jmp 0x67b35
movl $0x8, %edi
callq 0x8230
movq %rax, -0x5f8(%rbp)
movl $0x1, %edi
callq 0x84c0
movq %rax, -0x5f0(%rbp)
jmp 0x67a01
movq -0x5f0(%rbp), %rdi
leaq 0x111c7(%rip), %rsi     # 0x78bd6
callq 0x129a0
jmp 0x67a16
movq -0x5f8(%rbp), %rdi
movq -0x5f0(%rbp), %rax
movq %rax, (%rdi)
leaq 0x4229a(%rip), %rsi     # 0xa9cc8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
jmp 0x69746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6970f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x82e0
jmp 0x6970f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x82e0
jmp 0x6970f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x82e0
jmp 0x6970f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68c97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68c8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68c7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x67fb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x67fa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x67b24
movq -0x5f0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x1, %esi
callq 0x84d0
movq -0x5f8(%rbp), %rdi
callq 0x8370
jmp 0x67fa8
movq -0x570(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x240(%rbp), %rsi
callq 0x5c190
movq %rax, -0x600(%rbp)
jmp 0x67b58
movq -0x570(%rbp), %rdi
movq -0x600(%rbp), %rax
movq %rax, -0x268(%rbp)
addq $0xb8, %rdi
callq 0x5c1c0
movq %rax, -0x270(%rbp)
leaq -0x268(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x5c160
testb $0x1, %al
jne 0x67b9c
jmp 0x67c37
movl $0x8, %edi
callq 0x8230
movq %rax, -0x610(%rbp)
movl $0x1, %edi
callq 0x84c0
movq %rax, -0x608(%rbp)
jmp 0x67bc0
movq -0x608(%rbp), %rdi
leaq 0x10507(%rip), %rsi     # 0x780d5
callq 0x129a0
jmp 0x67bd5
movq -0x610(%rbp), %rdi
movq -0x608(%rbp), %rax
movq %rax, (%rdi)
leaq 0x420db(%rip), %rsi     # 0xa9cc8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
jmp 0x69746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x67c26
movq -0x608(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x1, %esi
callq 0x84d0
movq -0x610(%rbp), %rdi
callq 0x8370
jmp 0x67fa8
movq -0x570(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x240(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x618(%rbp)
jmp 0x67c5a
movq -0x618(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x628(%rbp)
movq -0x210(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x620(%rbp)
leaq 0x10f73(%rip), %rsi     # 0x78bf9
leaq -0x290(%rbp), %rdi
leaq -0x240(%rbp), %rdx
callq 0xc3f0
jmp 0x67c9b
movq -0x620(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x31840
movq %rax, -0x630(%rbp)
jmp 0x67cb7
movq -0x630(%rbp), %rax
movsd -0x628(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x290(%rbp), %rdi
callq 0x82e0
movq -0x570(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x240(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x638(%rbp)
jmp 0x67cf9
movq -0x638(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x648(%rbp)
movq -0x210(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x640(%rbp)
leaq 0x10edc(%rip), %rsi     # 0x78c02
leaq -0x2b0(%rbp), %rdi
leaq -0x240(%rbp), %rdx
callq 0xc3f0
jmp 0x67d3b
movq -0x640(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
callq 0x31840
movq %rax, -0x650(%rbp)
jmp 0x67d57
movq -0x650(%rbp), %rax
movsd -0x648(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x2b0(%rbp), %rdi
callq 0x82e0
movq 0x4220b(%rip), %rdi     # 0xa9f88
leaq 0x10e87(%rip), %rsi     # 0x78c0b
callq 0x84a0
movq %rax, -0x658(%rbp)
jmp 0x67d92
movq -0x658(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x8840
movq %rax, -0x660(%rbp)
jmp 0x67dad
movq -0x660(%rbp), %rdi
leaq 0x10e3e(%rip), %rsi     # 0x78bf9
callq 0x84a0
movq %rax, -0x668(%rbp)
jmp 0x67dc9
leaq -0x240(%rbp), %rdi
callq 0x81d0
movq -0x668(%rbp), %rdi
movq %rax, %rsi
callq 0x84a0
movq %rax, -0x670(%rbp)
jmp 0x67ded
movq -0x670(%rbp), %rdi
leaq 0x10a10(%rip), %rsi     # 0x7880b
callq 0x84a0
movq %rax, -0x678(%rbp)
jmp 0x67e09
movq -0x570(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x240(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x680(%rbp)
jmp 0x67e2c
movq -0x678(%rbp), %rdi
movq -0x680(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, -0x688(%rbp)
jmp 0x67e4c
movq -0x688(%rbp), %rdi
leaq 0xf3c2(%rip), %rsi      # 0x7721c
callq 0x84a0
jmp 0x67e61
movq 0x42120(%rip), %rdi     # 0xa9f88
leaq 0x10d9c(%rip), %rsi     # 0x78c0b
callq 0x84a0
movq %rax, -0x690(%rbp)
jmp 0x67e7d
movq -0x690(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x8840
movq %rax, -0x698(%rbp)
jmp 0x67e98
movq -0x698(%rbp), %rdi
leaq 0x10d5c(%rip), %rsi     # 0x78c02
callq 0x84a0
movq %rax, -0x6a0(%rbp)
jmp 0x67eb4
leaq -0x240(%rbp), %rdi
callq 0x81d0
movq -0x6a0(%rbp), %rdi
movq %rax, %rsi
callq 0x84a0
movq %rax, -0x6a8(%rbp)
jmp 0x67ed8
movq -0x6a8(%rbp), %rdi
leaq 0x10925(%rip), %rsi     # 0x7880b
callq 0x84a0
movq %rax, -0x6b0(%rbp)
jmp 0x67ef4
movq -0x570(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x240(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x6b8(%rbp)
jmp 0x67f17
movq -0x6b0(%rbp), %rdi
movq -0x6b8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x88c0
movq %rax, -0x6c0(%rbp)
jmp 0x67f38
movq -0x6c0(%rbp), %rdi
leaq 0xf2d6(%rip), %rsi      # 0x7721c
callq 0x84a0
jmp 0x67f4d
leaq -0x260(%rbp), %rdi
callq 0x82e0
leaq -0x240(%rbp), %rdi
callq 0x82e0
leaq -0x218(%rbp), %rdi
callq 0x462c0
jmp 0x6790b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x82e0
jmp 0x67fa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x2b0(%rbp), %rdi
callq 0x82e0
leaq -0x260(%rbp), %rdi
callq 0x82e0
leaq -0x240(%rbp), %rdi
callq 0x82e0
jmp 0x68c7f
leaq -0x1d8(%rbp), %rdi
callq 0x3f3c0
movq %rax, -0x2b8(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x3f240
movq %rax, -0x2c0(%rbp)
leaq -0x2b8(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
callq 0x46260
testb $0x1, %al
jne 0x68007
jmp 0x685f7
leaq -0x2b8(%rbp), %rdi
callq 0x462a0
movq %rax, %rsi
leaq -0x2e0(%rbp), %rdi
movl $0x4, %edx
movq $-0x1, %rcx
callq 0x8500
jmp 0x68030
leaq -0x2b8(%rbp), %rdi
callq 0x462a0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x300(%rbp), %rdi
movl $0x3, %ecx
callq 0x8500
jmp 0x68056
leaq 0x10099(%rip), %rsi     # 0x780f6
leaq -0x300(%rbp), %rdi
callq 0x2d8a0
movb %al, -0x6c1(%rbp)
jmp 0x68071
movb -0x6c1(%rbp), %al
testb $0x1, %al
jne 0x68080
jmp 0x68167
leaq 0x10073(%rip), %rsi     # 0x780fa
leaq -0x300(%rbp), %rdi
callq 0x2d8a0
movb %al, -0x6c2(%rbp)
jmp 0x6809b
movb -0x6c2(%rbp), %al
testb $0x1, %al
jne 0x680aa
jmp 0x68167
movl $0x8, %edi
callq 0x8230
movq %rax, -0x6d8(%rbp)
movl $0x1, %edi
callq 0x84c0
movq %rax, -0x6d0(%rbp)
jmp 0x680ce
movq -0x6d0(%rbp), %rdi
leaq 0x10afa(%rip), %rsi     # 0x78bd6
callq 0x129a0
jmp 0x680e3
movq -0x6d8(%rbp), %rdi
movq -0x6d0(%rbp), %rax
movq %rax, (%rdi)
leaq 0x41bcd(%rip), %rsi     # 0xa9cc8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
jmp 0x69746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x685e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x685da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68156
movq -0x6d0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x1, %esi
callq 0x84d0
movq -0x6d8(%rbp), %rdi
callq 0x8370
jmp 0x685da
movq -0x570(%rbp), %rdi
addq $0xe8, %rdi
leaq -0x2e0(%rbp), %rsi
callq 0x5c190
movq %rax, -0x6e0(%rbp)
jmp 0x6818a
movq -0x570(%rbp), %rdi
movq -0x6e0(%rbp), %rax
movq %rax, -0x308(%rbp)
addq $0xe8, %rdi
callq 0x5c1c0
movq %rax, -0x310(%rbp)
leaq -0x308(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x5c160
testb $0x1, %al
jne 0x681ce
jmp 0x68269
movl $0x8, %edi
callq 0x8230
movq %rax, -0x6f0(%rbp)
movl $0x1, %edi
callq 0x84c0
movq %rax, -0x6e8(%rbp)
jmp 0x681f2
movq -0x6e8(%rbp), %rdi
leaq 0x10a10(%rip), %rsi     # 0x78c10
callq 0x129a0
jmp 0x68207
movq -0x6f0(%rbp), %rdi
movq -0x6e8(%rbp), %rax
movq %rax, (%rdi)
leaq 0x41aa9(%rip), %rsi     # 0xa9cc8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
jmp 0x69746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68258
movq -0x6e8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x1, %esi
callq 0x84d0
movq -0x6f0(%rbp), %rdi
callq 0x8370
jmp 0x685da
movq -0x570(%rbp), %rdi
addq $0xe8, %rdi
leaq -0x2e0(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x6f8(%rbp)
jmp 0x6828c
movq -0x6f8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x708(%rbp)
movq -0x210(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x700(%rbp)
leaq 0x1097f(%rip), %rsi     # 0x78c37
leaq -0x330(%rbp), %rdi
leaq -0x2e0(%rbp), %rdx
callq 0xc3f0
jmp 0x682cd
movq -0x700(%rbp), %rdi
leaq -0x330(%rbp), %rsi
callq 0x31840
movq %rax, -0x710(%rbp)
jmp 0x682e9
movq -0x710(%rbp), %rax
movsd -0x708(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x330(%rbp), %rdi
callq 0x82e0
movq -0x570(%rbp), %rdi
addq $0xe8, %rdi
leaq -0x2e0(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x718(%rbp)
jmp 0x6832b
movq -0x718(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x728(%rbp)
movq -0x210(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x720(%rbp)
leaq 0x108ef(%rip), %rsi     # 0x78c47
leaq -0x350(%rbp), %rdi
leaq -0x2e0(%rbp), %rdx
callq 0xc3f0
jmp 0x6836d
movq -0x720(%rbp), %rdi
leaq -0x350(%rbp), %rsi
callq 0x31840
movq %rax, -0x730(%rbp)
jmp 0x68389
movq -0x730(%rbp), %rax
movsd -0x728(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x350(%rbp), %rdi
callq 0x82e0
movq 0x41bd9(%rip), %rdi     # 0xa9f88
leaq 0x10855(%rip), %rsi     # 0x78c0b
callq 0x84a0
movq %rax, -0x738(%rbp)
jmp 0x683c4
movq -0x738(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x8840
movq %rax, -0x740(%rbp)
jmp 0x683df
movq -0x740(%rbp), %rdi
leaq 0x1084a(%rip), %rsi     # 0x78c37
callq 0x84a0
movq %rax, -0x748(%rbp)
jmp 0x683fb
leaq -0x2e0(%rbp), %rdi
callq 0x81d0
movq -0x748(%rbp), %rdi
movq %rax, %rsi
callq 0x84a0
movq %rax, -0x750(%rbp)
jmp 0x6841f
movq -0x750(%rbp), %rdi
leaq 0x103de(%rip), %rsi     # 0x7880b
callq 0x84a0
movq %rax, -0x758(%rbp)
jmp 0x6843b
movq -0x570(%rbp), %rdi
addq $0xe8, %rdi
leaq -0x2e0(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x760(%rbp)
jmp 0x6845e
movq -0x758(%rbp), %rdi
movq -0x760(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, -0x768(%rbp)
jmp 0x6847e
movq -0x768(%rbp), %rdi
leaq 0xed90(%rip), %rsi      # 0x7721c
callq 0x84a0
jmp 0x68493
movq 0x41aee(%rip), %rdi     # 0xa9f88
leaq 0x1076a(%rip), %rsi     # 0x78c0b
callq 0x84a0
movq %rax, -0x770(%rbp)
jmp 0x684af
movq -0x770(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x8840
movq %rax, -0x778(%rbp)
jmp 0x684ca
movq -0x778(%rbp), %rdi
leaq 0x1076f(%rip), %rsi     # 0x78c47
callq 0x84a0
movq %rax, -0x780(%rbp)
jmp 0x684e6
leaq -0x2e0(%rbp), %rdi
callq 0x81d0
movq -0x780(%rbp), %rdi
movq %rax, %rsi
callq 0x84a0
movq %rax, -0x788(%rbp)
jmp 0x6850a
movq -0x788(%rbp), %rdi
leaq 0x102f3(%rip), %rsi     # 0x7880b
callq 0x84a0
movq %rax, -0x790(%rbp)
jmp 0x68526
movq -0x570(%rbp), %rdi
addq $0xe8, %rdi
leaq -0x2e0(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x798(%rbp)
jmp 0x68549
movq -0x790(%rbp), %rdi
movq -0x798(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x88c0
movq %rax, -0x7a0(%rbp)
jmp 0x6856a
movq -0x7a0(%rbp), %rdi
leaq 0xeca4(%rip), %rsi      # 0x7721c
callq 0x84a0
jmp 0x6857f
leaq -0x300(%rbp), %rdi
callq 0x82e0
leaq -0x2e0(%rbp), %rdi
callq 0x82e0
leaq -0x2b8(%rbp), %rdi
callq 0x462c0
jmp 0x67fd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x330(%rbp), %rdi
callq 0x82e0
jmp 0x685da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x350(%rbp), %rdi
callq 0x82e0
leaq -0x300(%rbp), %rdi
callq 0x82e0
leaq -0x2e0(%rbp), %rdi
callq 0x82e0
jmp 0x68c7f
leaq -0x1f0(%rbp), %rdi
callq 0x3f3c0
movq %rax, -0x358(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x3f240
movq %rax, -0x360(%rbp)
leaq -0x358(%rbp), %rdi
leaq -0x360(%rbp), %rsi
callq 0x46260
testb $0x1, %al
jne 0x68639
jmp 0x68c26
leaq -0x358(%rbp), %rdi
callq 0x462a0
movq %rax, %rsi
leaq -0x380(%rbp), %rdi
movl $0x4, %edx
movq $-0x1, %rcx
callq 0x8500
jmp 0x68662
leaq -0x358(%rbp), %rdi
callq 0x462a0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x3a0(%rbp), %rdi
movl $0x3, %ecx
callq 0x8500
jmp 0x68688
leaq 0xfa67(%rip), %rsi      # 0x780f6
leaq -0x3a0(%rbp), %rdi
callq 0x2d8a0
movb %al, -0x7a1(%rbp)
jmp 0x686a3
movb -0x7a1(%rbp), %al
testb $0x1, %al
jne 0x686b2
jmp 0x68799
leaq 0xfa41(%rip), %rsi      # 0x780fa
leaq -0x3a0(%rbp), %rdi
callq 0x2d8a0
movb %al, -0x7a2(%rbp)
jmp 0x686cd
movb -0x7a2(%rbp), %al
testb $0x1, %al
jne 0x686dc
jmp 0x68799
movl $0x8, %edi
callq 0x8230
movq %rax, -0x7b8(%rbp)
movl $0x1, %edi
callq 0x84c0
movq %rax, -0x7b0(%rbp)
jmp 0x68700
movq -0x7b0(%rbp), %rdi
leaq 0x104c8(%rip), %rsi     # 0x78bd6
callq 0x129a0
jmp 0x68715
movq -0x7b8(%rbp), %rdi
movq -0x7b0(%rbp), %rax
movq %rax, (%rdi)
leaq 0x4159b(%rip), %rsi     # 0xa9cc8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
jmp 0x69746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68c18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68c0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68788
movq -0x7b0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x1, %esi
callq 0x84d0
movq -0x7b8(%rbp), %rdi
callq 0x8370
jmp 0x68c0c
movq -0x570(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq -0x380(%rbp), %rsi
callq 0x5c190
movq %rax, -0x7c0(%rbp)
jmp 0x687bc
movq -0x570(%rbp), %rdi
movq -0x7c0(%rbp), %rax
movq %rax, -0x3a8(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x5c1c0
movq %rax, -0x3b0(%rbp)
leaq -0x3a8(%rbp), %rdi
leaq -0x3b0(%rbp), %rsi
callq 0x5c160
testb $0x1, %al
jne 0x68800
jmp 0x6889b
movl $0x8, %edi
callq 0x8230
movq %rax, -0x7d0(%rbp)
movl $0x1, %edi
callq 0x84c0
movq %rax, -0x7c8(%rbp)
jmp 0x68824
movq -0x7c8(%rbp), %rdi
leaq 0x10425(%rip), %rsi     # 0x78c57
callq 0x129a0
jmp 0x68839
movq -0x7d0(%rbp), %rdi
movq -0x7c8(%rbp), %rax
movq %rax, (%rdi)
leaq 0x41477(%rip), %rsi     # 0xa9cc8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
jmp 0x69746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6888a
movq -0x7c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x1, %esi
callq 0x84d0
movq -0x7d0(%rbp), %rdi
callq 0x8370
jmp 0x68c0c
movq -0x570(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq -0x380(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x7d8(%rbp)
jmp 0x688be
movq -0x7d8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x7e8(%rbp)
movq -0x210(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x7e0(%rbp)
leaq 0x10396(%rip), %rsi     # 0x78c80
leaq -0x3d0(%rbp), %rdi
leaq -0x380(%rbp), %rdx
callq 0xc3f0
jmp 0x688ff
movq -0x7e0(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
callq 0x31840
movq %rax, -0x7f0(%rbp)
jmp 0x6891b
movq -0x7f0(%rbp), %rax
movsd -0x7e8(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x3d0(%rbp), %rdi
callq 0x82e0
movq -0x570(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq -0x380(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x7f8(%rbp)
jmp 0x6895d
movq -0x7f8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x808(%rbp)
movq -0x210(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x800(%rbp)
leaq 0x10306(%rip), %rsi     # 0x78c90
leaq -0x3f0(%rbp), %rdi
leaq -0x380(%rbp), %rdx
callq 0xc3f0
jmp 0x6899f
movq -0x800(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
callq 0x31840
movq %rax, -0x810(%rbp)
jmp 0x689bb
movq -0x810(%rbp), %rax
movsd -0x808(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x3f0(%rbp), %rdi
callq 0x82e0
movq 0x415a7(%rip), %rdi     # 0xa9f88
leaq 0x10223(%rip), %rsi     # 0x78c0b
callq 0x84a0
movq %rax, -0x818(%rbp)
jmp 0x689f6
movq -0x818(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x8840
movq %rax, -0x820(%rbp)
jmp 0x68a11
movq -0x820(%rbp), %rdi
leaq 0x10261(%rip), %rsi     # 0x78c80
callq 0x84a0
movq %rax, -0x828(%rbp)
jmp 0x68a2d
leaq -0x380(%rbp), %rdi
callq 0x81d0
movq -0x828(%rbp), %rdi
movq %rax, %rsi
callq 0x84a0
movq %rax, -0x830(%rbp)
jmp 0x68a51
movq -0x830(%rbp), %rdi
leaq 0xfdac(%rip), %rsi      # 0x7880b
callq 0x84a0
movq %rax, -0x838(%rbp)
jmp 0x68a6d
movq -0x570(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq -0x380(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x840(%rbp)
jmp 0x68a90
movq -0x838(%rbp), %rdi
movq -0x840(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, -0x848(%rbp)
jmp 0x68ab0
movq -0x848(%rbp), %rdi
leaq 0xe75e(%rip), %rsi      # 0x7721c
callq 0x84a0
jmp 0x68ac5
movq 0x414bc(%rip), %rdi     # 0xa9f88
leaq 0x10138(%rip), %rsi     # 0x78c0b
callq 0x84a0
movq %rax, -0x850(%rbp)
jmp 0x68ae1
movq -0x850(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x8840
movq %rax, -0x858(%rbp)
jmp 0x68afc
movq -0x858(%rbp), %rdi
leaq 0x10186(%rip), %rsi     # 0x78c90
callq 0x84a0
movq %rax, -0x860(%rbp)
jmp 0x68b18
leaq -0x380(%rbp), %rdi
callq 0x81d0
movq -0x860(%rbp), %rdi
movq %rax, %rsi
callq 0x84a0
movq %rax, -0x868(%rbp)
jmp 0x68b3c
movq -0x868(%rbp), %rdi
leaq 0xfcc1(%rip), %rsi      # 0x7880b
callq 0x84a0
movq %rax, -0x870(%rbp)
jmp 0x68b58
movq -0x570(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq -0x380(%rbp), %rsi
callq 0x5c1f0
movq %rax, -0x878(%rbp)
jmp 0x68b7b
movq -0x870(%rbp), %rdi
movq -0x878(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x88c0
movq %rax, -0x880(%rbp)
jmp 0x68b9c
movq -0x880(%rbp), %rdi
leaq 0xe672(%rip), %rsi      # 0x7721c
callq 0x84a0
jmp 0x68bb1
leaq -0x3a0(%rbp), %rdi
callq 0x82e0
leaq -0x380(%rbp), %rdi
callq 0x82e0
leaq -0x358(%rbp), %rdi
callq 0x462c0
jmp 0x6860a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x3d0(%rbp), %rdi
callq 0x82e0
jmp 0x68c0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x3f0(%rbp), %rdi
callq 0x82e0
leaq -0x3a0(%rbp), %rdi
callq 0x82e0
leaq -0x380(%rbp), %rdi
callq 0x82e0
jmp 0x68c7f
leaq -0x1a0(%rbp), %rdi
callq 0x4bec0
leaq -0x1a8(%rbp), %rdi
callq 0x4bec0
leaq -0x1b0(%rbp), %rdi
callq 0x4bec0
leaq -0x208(%rbp), %rdi
callq 0x2bfd0
leaq -0x1f0(%rbp), %rdi
callq 0x2bfd0
leaq -0x1d8(%rbp), %rdi
callq 0x2bfd0
leaq -0x1b8(%rbp), %rdi
callq 0x4a5a0
jmp 0x6785c
leaq -0x208(%rbp), %rdi
callq 0x2bfd0
leaq -0x1f0(%rbp), %rdi
callq 0x2bfd0
leaq -0x1d8(%rbp), %rdi
callq 0x2bfd0
jmp 0x6970f
jmp 0x68caa
movl -0x18c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18c(%rbp)
jmp 0x677b5
leaq -0x420(%rbp), %rdi
callq 0x2c1f0
leaq -0x450(%rbp), %rdi
callq 0x2c1f0
movb $0x0, -0x451(%rbp)
leaq -0x479(%rbp), %rdi
movq %rdi, -0x888(%rbp)
callq 0x8870
movq -0x888(%rbp), %rdx
leaq 0xffa2(%rip), %rsi      # 0x78ca0
leaq -0x478(%rbp), %rdi
callq 0xcb30
jmp 0x68d0c
leaq 0x41d45(%rip), %rdi     # 0xaaa58
leaq -0x478(%rbp), %rsi
callq 0x27e40
movsd %xmm0, -0x890(%rbp)
jmp 0x68d29
movsd -0x890(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x894(%rbp)
leaq -0x478(%rbp), %rdi
callq 0x82e0
leaq -0x479(%rbp), %rdi
callq 0x8540
movl -0x894(%rbp), %eax
movl %eax, -0x458(%rbp)
cmpl $-0x1, -0x458(%rbp)
jne 0x68d75
movl $0x3e8, %eax            # imm = 0x3E8
movl %eax, -0x898(%rbp)
jmp 0x68d81
movl -0x458(%rbp), %eax
movl %eax, -0x898(%rbp)
movl -0x898(%rbp), %eax
movl %eax, -0x458(%rbp)
movl $0x0, -0x480(%rbp)
movl $0x0, -0x484(%rbp)
movsd 0xd8ef(%rip), %xmm0     # 0x76698
movsd %xmm0, -0x490(%rbp)
movq -0x570(%rbp), %rcx
movl -0x480(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x480(%rbp)
movl -0xe8(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jl 0x68e2f
leaq 0xfee4(%rip), %rdi      # 0x78cbd
xorl %eax, %eax
callq 0x8080
jmp 0x68de2
jmp 0x696b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68e0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x478(%rbp), %rdi
callq 0x82e0
leaq -0x479(%rbp), %rdi
callq 0x8540
jmp 0x696f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x696f7
leaq -0x420(%rbp), %rdi
callq 0x6cb50
cmpq $0x0, %rax
je 0x68e4d
leaq -0x420(%rbp), %rdi
callq 0x6cb70
movq -0x570(%rbp), %rax
movl 0x2c(%rax), %eax
subl -0xe8(%rbp), %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0xec(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x498(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x6cb90
movsd -0x490(%rbp), %xmm0
ucomisd -0x498(%rbp), %xmm0
jne 0x68ec9
jp 0x68ec9
movl -0x484(%rbp), %eax
cmpl -0x458(%rbp), %eax
jle 0x68eb8
leaq 0xfe26(%rip), %rdi      # 0x78cd0
xorl %eax, %eax
callq 0x8080
jmp 0x68eb3
jmp 0x696b8
movl -0x484(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x484(%rbp)
jmp 0x68ec9
movsd -0x498(%rbp), %xmm0
movsd %xmm0, -0x490(%rbp)
movl $0x0, -0x49c(%rbp)
movl -0x49c(%rbp), %eax
leaq 0x4160c(%rip), %rcx     # 0xaa4fc
cmpl (%rcx), %eax
jge 0x68f87
cmpl $0x1, -0xa0(%rbp)
jne 0x68f71
movl $0x10, %edi
callq 0x84c0
movq %rax, -0x8a0(%rbp)
jmp 0x68f14
movq -0x8a0(%rbp), %rdi
movsd -0x498(%rbp), %xmm0
callq 0x155c0
jmp 0x68f2a
movq -0x8a0(%rbp), %rax
movq %rax, -0x4a8(%rbp)
leaq -0x108(%rbp), %rdi
leaq -0x4a8(%rbp), %rsi
callq 0x2ae30
jmp 0x68f4d
jmp 0x68f71
movq -0x8a0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x10, %esi
callq 0x84d0
jmp 0x696f7
jmp 0x68f73
movl -0x49c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x49c(%rbp)
jmp 0x68ee3
movsd -0x498(%rbp), %xmm0
leaq 0xfd55(%rip), %rdi      # 0x78ceb
movb $0x1, %al
callq 0x8080
jmp 0x68f9f
movl $0x0, -0x4ac(%rbp)
movl -0x4ac(%rbp), %eax
cmpl -0xec(%rbp), %eax
jge 0x695b7
movq -0x570(%rbp), %rcx
movl -0xe8(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x68fff
leaq -0x450(%rbp), %rdi
callq 0x6cb50
movq -0x570(%rbp), %rdi
movq %rax, -0x8a8(%rbp)
addq $0x60, %rdi
callq 0x5c320
movq %rax, %rcx
movq -0x8a8(%rbp), %rax
cmpq %rcx, %rax
jb 0x69004
jmp 0x695a3
movl $0x0, -0x4b0(%rbp)
movl -0xec(%rbp), %edi
callq 0x65e50
movl %eax, -0x8ac(%rbp)
jmp 0x69021
movl -0x8ac(%rbp), %eax
movl %eax, -0x4b4(%rbp)
movb $0x1, -0x4b5(%rbp)
leaq -0x420(%rbp), %rdi
leaq -0x4b4(%rbp), %rsi
callq 0x2cba0
movq %rax, -0x8b8(%rbp)
jmp 0x69050
movq -0x8b8(%rbp), %rax
movq %rax, -0x4c0(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x2cbe0
movq %rax, -0x4c8(%rbp)
leaq -0x4c0(%rbp), %rdi
leaq -0x4c8(%rbp), %rsi
callq 0x2cb70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x8b9(%rbp)
jne 0x69095
jmp 0x690eb
leaq -0x450(%rbp), %rdi
leaq -0x4b4(%rbp), %rsi
callq 0x2cba0
movq %rax, -0x8c8(%rbp)
jmp 0x690b1
movq -0x8c8(%rbp), %rax
movq %rax, -0x4d0(%rbp)
leaq -0x450(%rbp), %rdi
callq 0x2cbe0
movq %rax, -0x4d8(%rbp)
leaq -0x4d0(%rbp), %rdi
leaq -0x4d8(%rbp), %rsi
callq 0x6cbb0
movb %al, -0x8b9(%rbp)
movb -0x8b9(%rbp), %al
testb $0x1, %al
jne 0x690f7
jmp 0x69156
movl -0xec(%rbp), %edi
callq 0x65e50
movl %eax, -0x8cc(%rbp)
jmp 0x6910a
movl -0x8cc(%rbp), %eax
movl %eax, -0x4b4(%rbp)
leaq -0x450(%rbp), %rdi
callq 0x6cb50
movq -0x570(%rbp), %rdi
movq %rax, -0x8d8(%rbp)
addq $0x60, %rdi
callq 0x5c320
movq %rax, %rcx
movq -0x8d8(%rbp), %rax
cmpq %rcx, %rax
jb 0x69151
movb $0x0, -0x4b5(%rbp)
jmp 0x69156
jmp 0x69034
testb $0x1, -0x4b5(%rbp)
je 0x6919b
leaq -0x420(%rbp), %rdi
leaq -0x4b4(%rbp), %rsi
callq 0x2cb00
movb %dl, -0x8e1(%rbp)
movq %rax, -0x8e0(%rbp)
jmp 0x69181
movb -0x8e1(%rbp), %al
movq -0x8e0(%rbp), %rcx
movq %rcx, -0x4e8(%rbp)
movb %al, -0x4e0(%rbp)
testb $0x1, -0x4b5(%rbp)
jne 0x691a9
jmp 0x695a3
movq -0x570(%rbp), %rdi
addq $0x60, %rdi
movslq -0x4b4(%rbp), %rsi
callq 0x5c340
movq %rax, -0x8f0(%rbp)
jmp 0x691c9
movq -0x8f0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x4f0(%rbp)
movq -0x4f0(%rbp), %rdi
callq 0x5a6d0
movl %eax, -0x8f4(%rbp)
jmp 0x691ee
movl -0x8f4(%rbp), %eax
cmpl $0x0, %eax
jne 0x6923a
leaq -0x450(%rbp), %rdi
leaq -0x4b4(%rbp), %rsi
callq 0x2cb00
movb %dl, -0x901(%rbp)
movq %rax, -0x900(%rbp)
jmp 0x6921b
movb -0x901(%rbp), %al
movq -0x900(%rbp), %rcx
movq %rcx, -0x500(%rbp)
movb %al, -0x4f8(%rbp)
jmp 0x695a3
testb $0x1, -0x451(%rbp)
jne 0x692f7
cvttsd2si -0x20(%rbp), %eax
movl %eax, -0x504(%rbp)
movl $0x0, -0x508(%rbp)
movl -0x508(%rbp), %eax
cmpl -0x504(%rbp), %eax
jge 0x692f5
movq -0x570(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x910(%rbp)
callq 0x5c320
movl %eax, %edi
callq 0x65e50
movl %eax, -0x908(%rbp)
jmp 0x69294
movq -0x910(%rbp), %rdi
movl -0x908(%rbp), %eax
movslq %eax, %rsi
callq 0x5c340
movq %rax, -0x918(%rbp)
jmp 0x692b2
movq -0x918(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x510(%rbp)
movq -0x4f0(%rbp), %rdi
movq -0x510(%rbp), %rsi
movzbl -0x15(%rbp), %edx
andl $0x1, %edx
callq 0x587a0
jmp 0x692df
jmp 0x692e1
movl -0x508(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x508(%rbp)
jmp 0x6925c
jmp 0x692f7
leaq -0x528(%rbp), %rdi
callq 0x5b570
movsd -0x498(%rbp), %xmm0
movsd 0xef65(%rip), %xmm2     # 0x78278
movaps %xmm0, %xmm1
mulsd %xmm2, %xmm1
xorps %xmm2, %xmm2
movsd 0xf7f3(%rip), %xmm3     # 0x78b18
callq 0x65d00
movsd %xmm0, -0x920(%rbp)
jmp 0x69334
movsd -0x920(%rbp), %xmm0
callq 0x65ec0
cvttsd2si %xmm0, %eax
movl %eax, -0x52c(%rbp)
cmpl $0x1, -0xa0(%rbp)
jne 0x693ad
movslq -0x4b0(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x2b050
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movsd %xmm0, -0x928(%rbp)
jmp 0x6937c
movsd -0x928(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x52c(%rbp)
jmp 0x693ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x528(%rbp), %rdi
callq 0x5b590
jmp 0x696f7
cmpl $0x0, -0x52c(%rbp)
jne 0x693c5
movl $0x1b, -0xa4(%rbp)
jmp 0x69587
movq -0x4f0(%rbp), %rdi
movl -0x52c(%rbp), %edx
movzbl -0x16(%rbp), %ecx
andl $0x1, %ecx
leaq -0x528(%rbp), %rsi
callq 0x5a6f0
jmp 0x693e7
movq -0x4f0(%rbp), %rdi
callq 0x5a6d0
movl %eax, -0x92c(%rbp)
jmp 0x693fb
movl -0x92c(%rbp), %eax
cmpl $0x0, %eax
jne 0x69442
leaq -0x450(%rbp), %rdi
leaq -0x4b4(%rbp), %rsi
callq 0x2cb00
movb %dl, -0x939(%rbp)
movq %rax, -0x938(%rbp)
jmp 0x69428
movb -0x939(%rbp), %al
movq -0x938(%rbp), %rcx
movq %rcx, -0x540(%rbp)
movb %al, -0x538(%rbp)
leaq -0x528(%rbp), %rdi
callq 0x60a70
movq %rax, -0x548(%rbp)
leaq -0x528(%rbp), %rdi
callq 0x60900
movq %rax, -0x550(%rbp)
leaq -0x548(%rbp), %rdi
leaq -0x550(%rbp), %rsi
callq 0x6ca70
testb $0x1, %al
jne 0x69484
jmp 0x6957d
movq -0x570(%rbp), %rcx
movl -0xe8(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x69558
leaq -0x548(%rbp), %rdi
callq 0x6cab0
movq (%rax), %rdi
callq 0x570f0
movl %eax, -0x940(%rbp)
jmp 0x694b6
movl -0x940(%rbp), %eax
cmpl $0x0, %eax
jne 0x69504
movq -0x570(%rbp), %rax
movq 0xa8(%rax), %rax
movslq -0x4b0(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x948(%rbp)
leaq -0x548(%rbp), %rdi
callq 0x6cab0
movq -0x948(%rbp), %rdi
movq %rax, %rsi
callq 0x5c0f0
jmp 0x69502
jmp 0x69547
movq -0x570(%rbp), %rax
movq 0xb0(%rax), %rax
movslq -0x4b0(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x950(%rbp)
leaq -0x548(%rbp), %rdi
callq 0x6cab0
movq -0x950(%rbp), %rdi
movq %rax, %rsi
callq 0x5c0f0
jmp 0x69545
jmp 0x69547
movl -0xe8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe8(%rbp)
jmp 0x6956a
leaq 0xf7a1(%rip), %rdi      # 0x78d00
xorl %eax, %eax
callq 0x8080
jmp 0x69568
jmp 0x6957d
jmp 0x6956c
leaq -0x548(%rbp), %rdi
callq 0x6cad0
jmp 0x69455
movl $0x0, -0xa4(%rbp)
leaq -0x528(%rbp), %rdi
callq 0x5b590
movl -0xa4(%rbp), %eax
testl %eax, %eax
je 0x695a1
jmp 0x6959f
jmp 0x695a3
jmp 0x695a3
movl -0x4ac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4ac(%rbp)
jmp 0x68fa9
movb $0x1, -0x451(%rbp)
movl $0x0, -0x554(%rbp)
movl -0x554(%rbp), %eax
leaq 0x40f27(%rip), %rcx     # 0xaa4fc
cmpl (%rcx), %eax
jge 0x6963f
cmpl $0x1, -0xa0(%rbp)
jne 0x6962c
movslq -0x554(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x2b050
movq (%rax), %rax
movq %rax, -0x958(%rbp)
cmpq $0x0, %rax
je 0x69612
movq -0x958(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movslq -0x554(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x2b050
movq $0x0, (%rax)
jmp 0x6962e
movl -0x554(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x554(%rbp)
jmp 0x695c8
jmp 0x69641
movl -0x480(%rbp), %ecx
xorl %eax, %eax
cmpl -0x458(%rbp), %ecx
movb %al, -0x959(%rbp)
jg 0x696aa
movq -0x570(%rbp), %rdx
movl -0xe8(%rbp), %ecx
xorl %eax, %eax
cmpl 0x2c(%rdx), %ecx
movb %al, -0x959(%rbp)
jge 0x696aa
leaq -0x450(%rbp), %rdi
callq 0x6cb50
movq -0x570(%rbp), %rdi
movq %rax, -0x968(%rbp)
addq $0x60, %rdi
callq 0x5c320
movq %rax, %rcx
movq -0x968(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x959(%rbp)
movb -0x959(%rbp), %al
testb $0x1, %al
jne 0x68db1
movq -0x570(%rbp), %rax
movb $0x1, 0x40(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0xa4(%rbp)
leaq -0x450(%rbp), %rdi
callq 0x6cbe0
leaq -0x420(%rbp), %rdi
callq 0x6cbe0
leaq -0x108(%rbp), %rdi
callq 0x6cc00
jmp 0x6971d
leaq -0x450(%rbp), %rdi
callq 0x6cbe0
leaq -0x420(%rbp), %rdi
callq 0x6cbe0
leaq -0x108(%rbp), %rdi
callq 0x6cc00
jmp 0x69734
leaq -0x78(%rbp), %rdi
callq 0x82e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x970, %rsp            # imm = 0x970
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x82e0
movq -0x50(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)