// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/config.cpp
// Function: SexualSelectionConfigurations::LoadFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SexualSelectionConfigurations::LoadFromFile(string szConfigFile)
{
	ifstream fsConfigFile;
	string sBuffer;
	char szPopName[MAXLINE];
	char szFormula[MAXLINE];
	
	#ifdef _OPENMP
		int nTotalCPUCore = omp_get_max_threads();//omp_get_num_threads();
	#else
		int nTotalCPUCore = 1;
	#endif
	
	printf("Start loading sexual selection file %s ...\n", szConfigFile.c_str());

	_szConfigFilename = szConfigFile; // save name of config file

	fsConfigFile.open(szConfigFile.c_str());
	//pConfigFile = fopen(szConfigFile.c_str(), "r");
	

	if (!fsConfigFile.is_open()) {
		printf("%s\n", "Cannot open sexual selection file ...");
		throw "Cannot open sexual selection file!";
	}

	getline(fsConfigFile,sBuffer);
	if (sBuffer == "") { // skip the header line
		throw "Cannot read sexual selection file!";
	}


	while(fsConfigFile.good()) 
	{
		getline(fsConfigFile,sBuffer);
		string sPopName, sFormula;
		int nGen = -1;
		sBuffer.erase(sBuffer.find_last_not_of(" \n\r\t")+1);//trim
		if (sBuffer == "") {
			continue;
		}
		sscanf(sBuffer.c_str(), "%[^\t\n]	%d	%[^\t\n]", szPopName, &nGen, szFormula);
		sPopName = szPopName; //make it string so that it saves lots of trouble of fuddling with c strings... i hate c strings.
		sFormula = szFormula;
		printf("Parsing sexual rule for Pop %s : %s for gen %d\n", sPopName.c_str(), sFormula.c_str(), nGen);
		if (sPopName.length() != 0 && sFormula.length() !=0) {
			
			

			if (this->_mpRules.find(sPopName) == this->_mpRules.end()) { // if this pop is not in the map yet
				list< string > vsFormulae;
				list< pair< Parser * , int > > vpFormulae;
				list< vector<string> > vvsSymbols;
				list< vector<string> > vvsSymbols2;
				list< vector<string> > vvsSymbols3;
				list< vector<string> > vvsSymbols4;
				list< vector<string> > vvsSymbols5;
				list< vector<string> > vvsSymbols6;
				list< vector<string> > vvsSymbols7;
				list< vector<string> > vvsSymbols8;
				list< vector<string> > vvsSymbols9;
				list< vector<string> > vvsSymbols10;
				list< vector<string> > vvsSymbols11;
				list< vector<string> > vvsSymbols12;
				list< vector<string> > vvsSymbols13;
				list< vector<string> > vvsSymbols14;

				this->_mpRules[sPopName] = vsFormulae;
				for(int nCPU=0;nCPU<nTotalCPUCore;nCPU++) {
					printf("%d CPU cores found, putting sexual selection parser on CPU %d\n",nTotalCPUCore, nCPU );
					if (this->_mpmpRuleFormulae.find(nCPU) == this->_mpmpRuleFormulae.end()) {
						 map<string , list< pair<Parser *, int> > > mpRuleFormulae;
						this->_mpmpRuleFormulae[nCPU] =  mpRuleFormulae;
					}
					this->_mpmpRuleFormulae[nCPU][sPopName] = vpFormulae;
				}
				this->_mpRuleFormulaSymbolStrings[sPopName] = vvsSymbols;
				this->_mpRuleFormulaSymbolStringsCourter[sPopName] = vvsSymbols2;
				this->_mpRuleFormulaSymbolStringsChooser[sPopName] = vvsSymbols3;
				this->_mpRuleFormulaSymbolStringsPopWide[sPopName] = vvsSymbols4;
				this->_mpRuleFormulaSymbolStringsPopWideChooser[sPopName] = vvsSymbols5;
				this->_mpRuleFormulaSymbolStringsPopWideCourter[sPopName] = vvsSymbols6;
				this->_mpRuleFormulaSymbolStringsDad[sPopName] = vvsSymbols7;
				this->_mpRuleFormulaSymbolStringsMom[sPopName] = vvsSymbols8;
				
				this->_mpRuleFormulaSymbolStringsCurrPopWidePrevGen[sPopName] = vvsSymbols9; // Symbols that are population-wide values from prev gen. of current pop
				this->_mpRuleFormulaSymbolStringsCurrPopWidePrevGenCourter[sPopName] = vvsSymbols10; // Symbols that are population-wide courter values from prev gen. of current pop
				this->_mpRuleFormulaSymbolStringsCurrPopWidePrevGenChooser[sPopName] = vvsSymbols11; // Symbols that are population-wide chooser values from prev gen. of current pop
				this->_mpRuleFormulaSymbolStringsPrevPopWidePrevGen[sPopName] = vvsSymbols12; // Symbols that are population-wide values from prev gen. of previous pop, if the individual did not migrate, previous pop = current pop
				this->_mpRuleFormulaSymbolStringsPrevPopWidePrevGenCourter[sPopName] = vvsSymbols13; // Symbols that are population-wide courter values from prev gen. of previous pop, if the individual did not migrate, previous pop = current pop
				this->_mpRuleFormulaSymbolStringsPrevPopWidePrevGenChooser[sPopName] = vvsSymbols14; // Symbols that are population-wide chooser values from prev gen. of previous pop, if the individual did not migrate, previous pop = current pop

			
			}

			
			
			Parser * pF = new Parser("");
			try {
				pF->Evaluate(sFormula);
			}
			catch(std::runtime_error e) {
				if ( string(e.what()) == "Divide by zero" ) {
					
					printf("Warning in formula: %s \nErrMsg:%s\nThis could simply be caused by uninitialized values", sFormula.c_str(), e.what());
					
					
				}
				else {
					printf("Error occured when trying to parse formula: %s \nErrMsg:%s\nPlease check formulae grammar!", sFormula.c_str(), e.what());
					exit(100);
				}
			}

			vector<string> vSymbolStrings; // all symbols
			vector<string> vSymbolStringsCourter; // only symbols referring to an individual courter's trait prefixed with Courter_
			vector<string> vSymbolStringsPopWideCourter; // symbols referring to population-level variables prefixed with PopCourter_
			vector<string> vSymbolStringsChooser; //symbols referring to individual chooser trait prefixed with My_
			vector<string> vSymbolStringsPopWideChooser;//symbols referring to population-level variables prefixed with PopChooser_
			vector<string> vSymbolStringsPopWide; // symbols referring to population-level variables prefixed with Pop_
			vector<string> vSymbolStringsDad; // symbols referring to population-level variables prefixed with Dad_
			vector<string> vSymbolStringsMom; // symbols referring to population-level variables prefixed with Mom_

			vector<string> vSymbolStringsCurrPopWidePrevGen; //PrevGenCurrPop_
			vector<string> vSymbolStringsCurrPopWidePrevGenCourter; //PrevGenCurrPopCourter_
			vector<string> vSymbolStringsCurrPopWidePrevGenChooser; //PrevGenCurrPopChooser_
			vector<string> vSymbolStringsPrevPopWidePrevGen; //PrevGenPrevPop_
			vector<string> vSymbolStringsPrevPopWidePrevGenCourter;  //PrevGenPrevPopCourter_
			vector<string> vSymbolStringsPrevPopWidePrevGenChooser; //PrevGenPrevPopChooser_

			//list all the symbols used in this formula
			for(map<string,double>::iterator it = pF->symbols_.begin(); it != pF->symbols_.end(); ++it) 
			{	
				//Parse chromosome number and position from the symbol
				//cout << (it->first) << "\n"; //list all keys

				
				if (strlen(it->first.c_str()) < 3) { // no need to add symbol
					continue;
				}

				vSymbolStrings.push_back(it->first); // save label too

				//Look at prefixes:
				string sSymbol = it->first;
				
				if (sSymbol.find("Courter_") == 0) {
					//throw(new Exception("Courter_ not yet implemented in natural selection."));
					sSymbol.replace(0, 8, "");
					vSymbolStringsCourter.push_back(sSymbol);
				}
				else if (sSymbol.find("PopCourter_") == 0) {
					//throw(new Exception("PopCourter_ not yet implemented in natural selection."));
					sSymbol.replace(0, 11, "");
					vSymbolStringsPopWideCourter.push_back(sSymbol );
				}
				else if (sSymbol.find("My_") == 0) {
					sSymbol.replace(0, 3, "");
					vSymbolStringsChooser.push_back(sSymbol);
				}
				else if (sSymbol.find("PopChooser_") == 0) {
					//throw(new Exception("PopChooser_ not yet implemented in natural selection."));
					sSymbol.replace(0, 11, "");
					vSymbolStringsPopWideChooser.push_back(sSymbol);
				}
				else if (sSymbol.find("Pop_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 4, "");
					vSymbolStringsPopWide.push_back(sSymbol);
				}
				else if (sSymbol.find("Dad_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 4, "");
					vSymbolStringsDad.push_back(sSymbol);
				}
				else if (sSymbol.find("Mom_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 4, "");
					vSymbolStringsMom.push_back(sSymbol);
				}
				else if (sSymbol.find("PrevGenCurrPop_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 15, "");
					vSymbolStringsCurrPopWidePrevGen.push_back(sSymbol);
				}
				else if (sSymbol.find("PrevGenCurrPopCourter_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 22, "");
					vSymbolStringsCurrPopWidePrevGenCourter.push_back(sSymbol);
				}
				else if (sSymbol.find("PrevGenCurrPopChooser_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 22, "");
					vSymbolStringsCurrPopWidePrevGenChooser.push_back(sSymbol);
				}
				else if (sSymbol.find("PrevGenPrevPop_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 15, "");
					vSymbolStringsPrevPopWidePrevGen.push_back(sSymbol);
				}
				else if (sSymbol.find("PrevGenPrevPopCourter_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 22, "");
					vSymbolStringsPrevPopWidePrevGenCourter.push_back(sSymbol);
				}
				else if (sSymbol.find("PrevGenPrevPopChooser_") == 0) {
					//throw(new Exception("Pop_ not yet implemented in natural selection."));
					sSymbol.replace(0, 22, "");
					vSymbolStringsPrevPopWidePrevGenChooser.push_back(sSymbol);
				}
				else { //default to be self
					vSymbolStringsChooser.push_back(sSymbol);
				}

			}
			
			delete pF;

			this->_mpRules[sPopName].push_back(sFormula); // save the formula string for further reference.
			for(int nCPU=0;nCPU<nTotalCPUCore;nCPU++) {
				if (nCPU == 0) {
					printf("Inserting %s to gen %d\n", sFormula.c_str(), nGen);
				}
				this->_mpmpRuleFormulae[nCPU][sPopName].push_back( pair< Parser *, int> ( new Parser(sFormula), nGen) ); //literally copy the pF object, so that there are nTotalCPUCore numbers of copies in the RAM! ;-)
			}
			this->_mpRuleFormulaSymbolStrings[sPopName].push_back(vSymbolStrings);
			this->_mpRuleFormulaSymbolStringsCourter[sPopName].push_back(vSymbolStringsCourter);
			this->_mpRuleFormulaSymbolStringsChooser[sPopName].push_back(vSymbolStringsChooser);
			this->_mpRuleFormulaSymbolStringsPopWide[sPopName].push_back(vSymbolStringsPopWide);
			this->_mpRuleFormulaSymbolStringsPopWideChooser[sPopName].push_back(vSymbolStringsPopWideChooser);
			this->_mpRuleFormulaSymbolStringsPopWideCourter[sPopName].push_back(vSymbolStringsPopWideCourter);
			this->_mpRuleFormulaSymbolStringsDad[sPopName].push_back(vSymbolStringsDad);
			this->_mpRuleFormulaSymbolStringsMom[sPopName].push_back(vSymbolStringsMom);

			this->_mpRuleFormulaSymbolStringsCurrPopWidePrevGen[sPopName].push_back(vSymbolStringsCurrPopWidePrevGen); //PrevGenCurrPop_
			this->_mpRuleFormulaSymbolStringsCurrPopWidePrevGenCourter[sPopName].push_back(vSymbolStringsCurrPopWidePrevGenCourter); //PrevGenCurrPopCourter_
			this->_mpRuleFormulaSymbolStringsCurrPopWidePrevGenChooser[sPopName].push_back(vSymbolStringsCurrPopWidePrevGenChooser); //PrevGenCurrPopChooser_
			this->_mpRuleFormulaSymbolStringsPrevPopWidePrevGen[sPopName].push_back(vSymbolStringsPrevPopWidePrevGen); //PrevGenPrevPop_
			this->_mpRuleFormulaSymbolStringsPrevPopWidePrevGenCourter[sPopName].push_back(vSymbolStringsPrevPopWidePrevGenCourter);  //PrevGenPrevPopCourter_
			this->_mpRuleFormulaSymbolStringsPrevPopWidePrevGenChooser[sPopName].push_back(vSymbolStringsPrevPopWidePrevGenChooser); //PrevGenPrevPopChooser_

			if (nGen > -1) {
				printf("Sexual selection special generation: %d\n", nGen);
				this->_vSpecialGens.insert(nGen);
			}
		}
	}

	printf("Sexual Selection rules for %d populations loaded. \n", this->_mpRules.size());

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a658, %rsp          # imm = 0x7A658
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x328(%rsp), %rdi
callq 0x73f0
leaq 0x260(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rsi
leaq 0x20235(%rip), %rdi     # 0x360fc
xorl %eax, %eax
callq 0x7060
movq %r14, 0x240(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71d0
movq (%rbx), %rsi
leaq 0x328(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x7200
leaq 0x3a0(%rsp), %rdi
callq 0x70c0
testb %al, %al
je 0x174f0
movq 0x328(%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %edx
leaq 0x328(%rsp), %rdi
leaq 0x250(%rsp), %rsi
callq 0x76d0
leaq 0x200d3(%rip), %rsi     # 0x36019
leaq 0x250(%rsp), %rdi
callq 0x7100
testl %eax, %eax
je 0x17505
movq 0x328(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x348(%rsp,%rax)
je 0x15fcf
movq 0x240(%rsp), %rax
movq 0x50(%rax), %rsi
leaq 0x20346(%rip), %rdi     # 0x362ca
xorl %eax, %eax
callq 0x7060
movq 0x250(%rsp), %rdi
leaq 0x260(%rsp), %rax
cmpq %rax, %rdi
je 0x15fb0
movq 0x260(%rsp), %rsi
incq %rsi
callq 0x7390
leaq 0x328(%rsp), %rdi
callq 0x70d0
addq $0x7a658, %rsp          # imm = 0x7A658
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%rsp,%rax), %rdi
addq $0x328, %rdi            # imm = 0x328
movq 0x240(%rsp), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x238(%rsp)
leaq 0x30(%rax), %rcx
movq %rcx, 0x320(%rsp)
leaq 0x58(%rax), %rcx
movq %rcx, 0x248(%rsp)
leaq 0x60(%rax), %r13
leaq 0x88(%rax), %rcx
movq %rcx, 0x2d8(%rsp)
leaq 0xb8(%rax), %rcx
movq %rcx, 0x2d0(%rsp)
leaq 0xe8(%rax), %rcx
movq %rcx, 0x2c8(%rsp)
leaq 0x118(%rax), %rcx
movq %rcx, 0x2c0(%rsp)
leaq 0x178(%rax), %rcx
movq %rcx, 0x2b8(%rsp)
leaq 0x148(%rax), %rcx
movq %rcx, 0x2b0(%rsp)
leaq 0x1a8(%rax), %rcx
movq %rcx, 0x2a8(%rsp)
leaq 0x1d8(%rax), %rcx
movq %rcx, 0x2a0(%rsp)
leaq 0x208(%rax), %rcx
movq %rcx, 0x298(%rsp)
leaq 0x238(%rax), %rcx
movq %rcx, 0x290(%rsp)
leaq 0x268(%rax), %rcx
movq %rcx, 0x288(%rsp)
leaq 0x298(%rax), %rcx
movq %rcx, 0x280(%rsp)
leaq 0x2c8(%rax), %rcx
movq %rcx, 0x278(%rsp)
leaq 0x2f8(%rax), %rcx
movq %rcx, 0x270(%rsp)
addq $0x328, %rax            # imm = 0x328
movq %rax, 0x318(%rsp)
leaq 0x250(%rsp), %r14
leaq 0x1e8(%rsp), %rbp
movl $0xa, %esi
callq 0x7350
movsbl %al, %edx
leaq 0x328(%rsp), %rdi
movq %r14, %rsi
callq 0x76d0
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x18(%rsp)
movb %cl, 0x20(%rsp)
leaq 0x228(%rsp), %rax
movq %rax, 0x218(%rsp)
movq %rcx, 0x220(%rsp)
movb %cl, 0x228(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0x4, %ecx
movq %r14, %rdi
leaq 0x1feb3(%rip), %rsi     # 0x36015
movq $-0x1, %rdx
callq 0x75e0
incq %rax
movq 0x258(%rsp), %rcx
cmpq %rax, %rcx
jb 0x174d8
movq %rax, 0x258(%rsp)
movq 0x250(%rsp), %rcx
movb $0x0, (%rcx,%rax)
movq %r14, %rdi
leaq 0x1fe79(%rip), %rsi     # 0x36019
callq 0x7100
testl %eax, %eax
je 0x173ab
movq 0x250(%rsp), %rdi
leaq 0x1fe5e(%rip), %rsi     # 0x3601a
leaq 0x3d5c0(%rsp), %r15
movq %r15, %rdx
leaq 0xc(%rsp), %rcx
leaq 0x530(%rsp), %r12
movq %r12, %r8
xorl %eax, %eax
callq 0x7360
movq 0x18(%rsp), %rbx
movq %r15, %rdi
callq 0x7170
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x7570
movq 0x220(%rsp), %rbx
movq %r12, %rdi
callq 0x7170
leaq 0x218(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x7570
movq 0x10(%rsp), %rsi
movq 0x218(%rsp), %rdx
movl 0xc(%rsp), %ecx
leaq 0x1ff54(%rip), %rdi     # 0x36194
xorl %eax, %eax
callq 0x7060
cmpq $0x0, 0x18(%rsp)
je 0x173ab
cmpq $0x0, 0x220(%rsp)
je 0x173ab
movq 0x238(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1ef66
cmpq 0x320(%rsp), %rax
jne 0x1697d
leaq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rax, 0x30(%rsp)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %rax, 0x60(%rsp)
leaq 0x1d0(%rsp), %rcx
movq %rcx, 0x1d8(%rsp)
movq %rcx, 0x1d0(%rsp)
movq %rax, 0x1e0(%rsp)
leaq 0x70(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %rax, 0x80(%rsp)
leaq 0x1b0(%rsp), %rcx
movq %rcx, 0x1b8(%rsp)
movq %rcx, 0x1b0(%rsp)
movq %rax, 0x1c0(%rsp)
leaq 0x190(%rsp), %rcx
movq %rcx, 0x198(%rsp)
movq %rcx, 0x190(%rsp)
movq %rax, 0x1a0(%rsp)
leaq 0x170(%rsp), %rcx
movq %rcx, 0x178(%rsp)
movq %rcx, 0x170(%rsp)
movq %rax, 0x180(%rsp)
leaq 0x150(%rsp), %rcx
movq %rcx, 0x158(%rsp)
movq %rcx, 0x150(%rsp)
movq %rax, 0x160(%rsp)
leaq 0x130(%rsp), %rcx
movq %rcx, 0x138(%rsp)
movq %rcx, 0x130(%rsp)
movq %rax, 0x140(%rsp)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x118(%rsp)
movq %rcx, 0x110(%rsp)
movq %rax, 0x120(%rsp)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0xf8(%rsp)
movq %rcx, 0xf0(%rsp)
movq %rax, 0x100(%rsp)
leaq 0xd0(%rsp), %rcx
movq %rcx, 0xd8(%rsp)
movq %rcx, 0xd0(%rsp)
movq %rax, 0xe0(%rsp)
leaq 0xb0(%rsp), %rcx
movq %rcx, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq %rax, 0xc0(%rsp)
leaq 0x90(%rsp), %rcx
movq %rcx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movq %rax, 0xa0(%rsp)
leaq 0x300(%rsp), %rcx
movq %rcx, 0x308(%rsp)
movq %rcx, 0x300(%rsp)
movq %rax, 0x310(%rsp)
leaq 0x2e8(%rsp), %rcx
movq %rcx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %rax, 0x2f8(%rsp)
movq 0x238(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a676
leaq 0x30(%rsp), %rcx
cmpq %rcx, %rax
je 0x16491
movq 0x30(%rsp), %rsi
movq %rax, %rdi
leaq 0x30(%rsp), %rdx
callq 0x1f35a
movl $0x0, 0x8(%rsp)
xorl %edx, %edx
leaq 0x1fd22(%rip), %rdi     # 0x361c4
movl $0x1, %esi
xorl %eax, %eax
callq 0x7060
movq 0x240(%rsp), %rax
movq 0x68(%rax), %rcx
movq %r13, %rax
testq %rcx, %rcx
je 0x164e0
movl 0x8(%rsp), %edx
movq %r13, %rax
xorl %esi, %esi
cmpl %edx, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x164c9
movq %r13, %rcx
cmpq %r13, %rax
je 0x164f6
movl 0x8(%rsp), %ecx
cmpl 0x20(%rax), %ecx
cmovlq %r13, %rax
movq %rax, %rcx
cmpq %r13, %rcx
jne 0x16555
movl $0x0, 0x1f0(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x1f8(%rsp)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x200(%rsp)
movq %rax, 0x208(%rsp)
movq %rcx, 0x210(%rsp)
movq 0x248(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1a6f2
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1b4f4
movq %rbp, %rdi
callq 0x1b980
movq 0x248(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1a6f2
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a756
leaq 0x50(%rsp), %rcx
cmpq %rcx, %rax
je 0x16590
movq 0x50(%rsp), %rsi
movq %rax, %rdi
leaq 0x50(%rsp), %rdx
callq 0x1fb16
movl 0x8(%rsp), %eax
leal 0x1(%rax), %edx
movl %edx, 0x8(%rsp)
testl %eax, %eax
js 0x1649b
movq 0x2d8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x1d0(%rsp), %rcx
cmpq %rcx, %rax
je 0x165da
movq 0x1d0(%rsp), %rsi
movq %rax, %rdi
leaq 0x1d0(%rsp), %rdx
callq 0x20038
movq 0x2d0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x70(%rsp), %rcx
cmpq %rcx, %rax
je 0x16608
movq 0x70(%rsp), %rsi
movq %rax, %rdi
leaq 0x70(%rsp), %rdx
callq 0x20038
movq 0x2c8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x1b0(%rsp), %rcx
cmpq %rcx, %rax
je 0x1663f
movq 0x1b0(%rsp), %rsi
movq %rax, %rdi
leaq 0x1b0(%rsp), %rdx
callq 0x20038
movq 0x2c0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x190(%rsp), %rcx
cmpq %rcx, %rax
je 0x16676
movq 0x190(%rsp), %rsi
movq %rax, %rdi
leaq 0x190(%rsp), %rdx
callq 0x20038
movq 0x2b8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x170(%rsp), %rcx
cmpq %rcx, %rax
je 0x166ad
movq 0x170(%rsp), %rsi
movq %rax, %rdi
leaq 0x170(%rsp), %rdx
callq 0x20038
movq 0x2b0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x150(%rsp), %rcx
cmpq %rcx, %rax
je 0x166e4
movq 0x150(%rsp), %rsi
movq %rax, %rdi
leaq 0x150(%rsp), %rdx
callq 0x20038
movq 0x2a8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x130(%rsp), %rcx
cmpq %rcx, %rax
je 0x1671b
movq 0x130(%rsp), %rsi
movq %rax, %rdi
leaq 0x130(%rsp), %rdx
callq 0x20038
movq 0x2a0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x110(%rsp), %rcx
cmpq %rcx, %rax
je 0x16752
movq 0x110(%rsp), %rsi
movq %rax, %rdi
leaq 0x110(%rsp), %rdx
callq 0x20038
movq 0x298(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0xf0(%rsp), %rcx
cmpq %rcx, %rax
je 0x16789
movq 0xf0(%rsp), %rsi
movq %rax, %rdi
leaq 0xf0(%rsp), %rdx
callq 0x20038
movq 0x290(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0xd0(%rsp), %rcx
cmpq %rcx, %rax
je 0x167c0
movq 0xd0(%rsp), %rsi
movq %rax, %rdi
leaq 0xd0(%rsp), %rdx
callq 0x20038
movq 0x288(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0xb0(%rsp), %rcx
cmpq %rcx, %rax
je 0x167f7
movq 0xb0(%rsp), %rsi
movq %rax, %rdi
leaq 0xb0(%rsp), %rdx
callq 0x20038
movq 0x280(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x90(%rsp), %rcx
cmpq %rcx, %rax
je 0x1682e
movq 0x90(%rsp), %rsi
movq %rax, %rdi
leaq 0x90(%rsp), %rdx
callq 0x20038
movq 0x278(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x300(%rsp), %rcx
cmpq %rcx, %rax
je 0x16865
movq 0x300(%rsp), %rsi
movq %rax, %rdi
leaq 0x300(%rsp), %rdx
callq 0x20038
movq 0x270(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
leaq 0x2e8(%rsp), %rcx
cmpq %rcx, %rax
je 0x1689c
movq 0x2e8(%rsp), %rsi
movq %rax, %rdi
leaq 0x2e8(%rsp), %rdx
callq 0x20038
leaq 0x2e8(%rsp), %rdi
callq 0x1b994
leaq 0x300(%rsp), %rdi
callq 0x1b994
leaq 0x90(%rsp), %rdi
callq 0x1b994
leaq 0xb0(%rsp), %rdi
callq 0x1b994
leaq 0xd0(%rsp), %rdi
callq 0x1b994
leaq 0xf0(%rsp), %rdi
callq 0x1b994
leaq 0x110(%rsp), %rdi
callq 0x1b994
leaq 0x130(%rsp), %rdi
callq 0x1b994
leaq 0x150(%rsp), %rdi
callq 0x1b994
leaq 0x170(%rsp), %rdi
callq 0x1b994
leaq 0x190(%rsp), %rdi
callq 0x1b994
leaq 0x1b0(%rsp), %rdi
callq 0x1b994
leaq 0x70(%rsp), %rdi
callq 0x1b994
leaq 0x1d0(%rsp), %rdi
callq 0x1b994
movq 0x50(%rsp), %rdi
leaq 0x50(%rsp), %r15
cmpq %r15, %rdi
je 0x16973
movq (%rdi), %rbx
movl $0x20, %esi
callq 0x7390
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x1695e
leaq 0x30(%rsp), %rdi
callq 0x1b9cc
movl $0x98, %edi
callq 0x7380
movq %rax, %rbx
movq %rax, %r12
leaq 0x1f8(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movq %rbp, %rdi
leaq 0x1f672(%rip), %rdx     # 0x36019
movq %rdx, %rsi
callq 0xa886
movq %r12, %rdi
movq %rbp, %rsi
callq 0x19f58
movq 0x1e8(%rsp), %rdi
leaq 0x1f8(%rsp), %rax
cmpq %rax, %rdi
je 0x169df
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x7390
movq %r14, %r15
movq %r12, %rdi
leaq 0x218(%rsp), %rsi
movq %r12, 0x2e0(%rsp)
callq 0x9926
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
movq %rax, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movq %rax, 0x1e0(%rsp)
movaps %xmm0, 0x1d0(%rsp)
movq %rax, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movq %rax, 0x1c0(%rsp)
movaps %xmm0, 0x1b0(%rsp)
movq %rax, 0x1a0(%rsp)
movaps %xmm0, 0x190(%rsp)
movq %rax, 0x180(%rsp)
movaps %xmm0, 0x170(%rsp)
movq %rax, 0x160(%rsp)
movaps %xmm0, 0x150(%rsp)
movq %rax, 0x140(%rsp)
movaps %xmm0, 0x130(%rsp)
movq %rax, 0x120(%rsp)
movaps %xmm0, 0x110(%rsp)
movq %rax, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
movq %rax, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movq %rax, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movq %rax, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movq 0x80(%r12), %r14
leaq 0x70(%rbx), %r12
cmpq %r12, %r14
je 0x16edc
movq 0x20(%r14), %rdi
callq 0x7170
cmpq $0x3, %rax
jb 0x16ec8
leaq 0x20(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1a0f0
leaq 0x1f8(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0xa916
movl $0x8, %ecx
movq %rbp, %rdi
leaq 0x1f6f3(%rip), %rsi     # 0x3622b
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16ce7
movl $0xb, %ecx
movq %rbp, %rdi
leaq 0x1f6d1(%rip), %rsi     # 0x36228
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16d0a
movl $0x3, %ecx
movq %rbp, %rdi
leaq 0x1f582(%rip), %rsi     # 0x360f8
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16d30
movl $0xb, %ecx
movq %rbp, %rdi
leaq 0x1f6aa(%rip), %rsi     # 0x3623f
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16d53
movl $0x4, %ecx
movq %rbp, %rdi
leaq 0x1f664(%rip), %rsi     # 0x36218
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16d79
movl $0x4, %ecx
movq %rbp, %rdi
leaq 0x1f630(%rip), %rsi     # 0x36203
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16d9f
movl $0x4, %ecx
movq %rbp, %rdi
leaq 0x1f616(%rip), %rsi     # 0x36208
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16dc5
movl $0xf, %ecx
movq %rbp, %rdi
leaq 0x1f5fc(%rip), %rsi     # 0x3620d
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16deb
movl $0x16, %ecx
movq %rbp, %rdi
leaq 0x1f5ed(%rip), %rsi     # 0x3621d
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16e11
movl $0x16, %ecx
movq %rbp, %rdi
leaq 0x1f5e5(%rip), %rsi     # 0x36234
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16e34
movl $0xf, %ecx
movq %rbp, %rdi
leaq 0x1f5dd(%rip), %rsi     # 0x3624b
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16e57
movl $0x16, %ecx
movq %rbp, %rdi
leaq 0x1f5ce(%rip), %rsi     # 0x3625b
xorl %edx, %edx
callq 0x7680
testq %rax, %rax
je 0x16e7a
movl $0x16, %ecx
movq %rbp, %rdi
leaq 0x1f5c6(%rip), %rsi     # 0x36272
xorl %edx, %edx
callq 0x7680
leaq 0x70(%rsp), %rdi
testq %rax, %rax
jne 0x16e9b
movl $0x16, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f347(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x90(%rsp), %rdi
jmp 0x16e9b
movl $0x8, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f321(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x50(%rsp), %rdi
jmp 0x16e9b
movl $0xb, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f2fe(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x1d0(%rsp), %rdi
jmp 0x16e9b
movl $0x3, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f2d8(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x70(%rsp), %rdi
jmp 0x16e9b
movl $0xb, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f2b5(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x1b0(%rsp), %rdi
jmp 0x16e9b
movl $0x4, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f28f(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x190(%rsp), %rdi
jmp 0x16e9b
movl $0x4, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f269(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x170(%rsp), %rdi
jmp 0x16e9b
movl $0x4, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f243(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x150(%rsp), %rdi
jmp 0x16e9b
movl $0xf, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f21d(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x130(%rsp), %rdi
jmp 0x16e9b
movl $0x16, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f1f7(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0x110(%rsp), %rdi
jmp 0x16e9b
movl $0x16, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f1d4(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0xf0(%rsp), %rdi
jmp 0x16e9b
movl $0xf, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f1b1(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0xd0(%rsp), %rdi
jmp 0x16e9b
movl $0x16, %edx
movq %rbp, %rdi
xorl %esi, %esi
leaq 0x1f18e(%rip), %rcx     # 0x36019
xorl %r8d, %r8d
callq 0x73e0
leaq 0xb0(%rsp), %rdi
movq %rbp, %rsi
callq 0x1a0f0
movq 0x1e8(%rsp), %rdi
leaq 0x1f8(%rsp), %rax
cmpq %rax, %rdi
je 0x16ec8
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x7390
movq %r14, %rdi
callq 0x7270
movq %rax, %r14
cmpq %r12, %rax
jne 0x16ae5
leaq 0x68(%rbx), %rdi
callq 0x1bb2c
movq 0x2e0(%rsp), %r14
movq 0x38(%r14), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x16f05
movq (%rax), %rsi
incq %rsi
callq 0x7390
movq (%r14), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x16f1c
movq (%rbx), %rsi
incq %rsi
callq 0x7390
movl $0x98, %esi
movq %r14, %rdi
callq 0x7390
movq 0x238(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a676
movq %rax, %rbx
movq %rax, %rdi
leaq 0x218(%rsp), %rsi
callq 0x1f508
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movl $0x0, 0x1e8(%rsp)
xorl %eax, %eax
testl %eax, %eax
jne 0x16f88
movq 0x218(%rsp), %rsi
movl 0xc(%rsp), %edx
leaq 0x1f308(%rip), %rdi     # 0x36289
xorl %eax, %eax
callq 0x7060
movq 0x248(%rsp), %rdi
movq %rbp, %rsi
callq 0x1a6f2
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a756
movq %rax, %rbx
movl $0x98, %edi
callq 0x7380
movq %rax, %r12
movq %rax, %rdi
leaq 0x218(%rsp), %rsi
callq 0x19f58
movl 0xc(%rsp), %r14d
movl $0x20, %edi
callq 0x7380
movq %r12, 0x10(%rax)
movl %r14d, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movl 0x1e8(%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x1e8(%rsp)
testl %ecx, %ecx
js 0x16f6a
movq %r15, %r14
movq 0x2d8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x2d0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x2c8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x70(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x2c0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x190(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x2b8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x1b0(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x2b0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x2a8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x170(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x2a0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x150(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x298(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x130(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x290(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x110(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x288(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0xf0(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x280(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x278(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0xb0(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movq 0x270(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a7d2
movq %rax, %rbx
movq %rax, %rdi
leaq 0x90(%rsp), %rsi
callq 0x201d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7080
incq 0x10(%rbx)
movl 0xc(%rsp), %esi
testl %esi, %esi
js 0x172fe
leaq 0x1efbc(%rip), %rdi     # 0x362a1
xorl %eax, %eax
callq 0x7060
movq 0x318(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x202a6
leaq 0x90(%rsp), %rdi
callq 0x1a61a
leaq 0xb0(%rsp), %rdi
callq 0x1a61a
leaq 0xd0(%rsp), %rdi
callq 0x1a61a
leaq 0xf0(%rsp), %rdi
callq 0x1a61a
leaq 0x110(%rsp), %rdi
callq 0x1a61a
leaq 0x130(%rsp), %rdi
callq 0x1a61a
leaq 0x150(%rsp), %rdi
callq 0x1a61a
leaq 0x170(%rsp), %rdi
callq 0x1a61a
leaq 0x190(%rsp), %rdi
callq 0x1a61a
leaq 0x1b0(%rsp), %rdi
callq 0x1a61a
leaq 0x70(%rsp), %rdi
callq 0x1a61a
leaq 0x1d0(%rsp), %rdi
callq 0x1a61a
leaq 0x50(%rsp), %rdi
callq 0x1a61a
leaq 0x30(%rsp), %rdi
callq 0x1a61a
movq 0x218(%rsp), %rdi
leaq 0x228(%rsp), %rax
cmpq %rax, %rdi
je 0x173d0
movq 0x228(%rsp), %rsi
incq %rsi
callq 0x7390
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x173ec
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7390
movq 0x328(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x328, %rdi            # imm = 0x328
cmpl $0x0, 0x20(%rdi)
je 0x160fa
jmp 0x15f71
movq %rax, %r14
cmpl $0x1, %edx
jne 0x177ba
movq %r14, %rdi
callq 0x7470
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x7160
movq %r14, %rdi
callq 0x7150
movq %r12, %rdi
callq 0x74d0
movq %rbp, %rdi
movq %rax, %rsi
leaq 0x50(%rsp), %rdx
callq 0x9c02
movq %rbp, %rdi
leaq 0x1dcf2(%rip), %rsi     # 0x35152
callq 0x7100
movl %eax, %r12d
movq 0x1e8(%rsp), %rdi
leaq 0x1f8(%rsp), %rax
cmpq %rax, %rdi
je 0x1748d
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x7390
movq 0x218(%rsp), %r14
leaq 0x30(%rsp), %rdi
callq 0x74d0
testl %r12d, %r12d
jne 0x1752a
leaq 0x1e9e3(%rip), %rdi     # 0x35e92
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7060
leaq 0x30(%rsp), %rdi
callq 0x7738
callq 0x7610
movq 0x2e0(%rsp), %r12
jmp 0x169fa
leaq 0x1f78c(%rip), %rdi     # 0x36c6b
leaq 0x1f7bc(%rip), %rsi     # 0x36ca2
movq %rax, %rdx
xorl %eax, %eax
callq 0x7530
leaq 0x1ec31(%rip), %rdi     # 0x36128
callq 0x7560
leaq 0x1ec4b(%rip), %rbx     # 0x3614e
jmp 0x1750c
leaq 0x1ec65(%rip), %rbx     # 0x36171
movl $0x8, %edi
callq 0x7180
movq %rbx, (%rax)
movq 0x31a18(%rip), %rsi     # 0x48f38
movq %rax, %rdi
xorl %edx, %edx
callq 0x7660
leaq 0x1e9b7(%rip), %rdi     # 0x35ee8
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7060
movl $0x64, %edi
callq 0x7450
jmp 0x175b0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x7738
callq 0x7610
jmp 0x177ba
movq %rax, %rdi
callq 0x9c3f
movq %rax, %r14
movq 0x1e8(%rsp), %rdi
leaq 0x1f8(%rsp), %rax
cmpq %rax, %rdi
je 0x17596
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x7390
jmp 0x17596
movq %rax, %r14
movl $0x98, %esi
movq %r12, %rdi
callq 0x7390
jmp 0x177ba
jmp 0x175b0
jmp 0x175b0
jmp 0x175b8
jmp 0x175b0
movq %rax, %r14
jmp 0x177ba
movq %rax, %r14
jmp 0x177fb
movq %rax, %r14
leaq 0x1e8(%rsp), %rdi
callq 0x1b980
jmp 0x17612
jmp 0x1760f
jmp 0x1770a
jmp 0x1770a
movq %rax, %r14
movq 0x1e8(%rsp), %rdi
leaq 0x1f8(%rsp), %rax
cmpq %rax, %rdi
je 0x1770d
movq 0x1f8(%rsp), %rsi
incq %rsi
jmp 0x17701
jmp 0x1770a
movq %rax, %r14
leaq 0x2e8(%rsp), %rdi
callq 0x1b994
leaq 0x300(%rsp), %rdi
callq 0x1b994
leaq 0x90(%rsp), %rdi
callq 0x1b994
leaq 0xb0(%rsp), %rdi
callq 0x1b994
leaq 0xd0(%rsp), %rdi
callq 0x1b994
leaq 0xf0(%rsp), %rdi
callq 0x1b994
leaq 0x110(%rsp), %rdi
callq 0x1b994
leaq 0x130(%rsp), %rdi
callq 0x1b994
leaq 0x150(%rsp), %rdi
callq 0x1b994
leaq 0x170(%rsp), %rdi
callq 0x1b994
leaq 0x190(%rsp), %rdi
callq 0x1b994
leaq 0x1b0(%rsp), %rdi
callq 0x1b994
leaq 0x70(%rsp), %rdi
callq 0x1b994
leaq 0x1d0(%rsp), %rdi
callq 0x1b994
leaq 0x50(%rsp), %rbx
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x176e7
movq (%rdi), %r15
movl $0x20, %esi
callq 0x7390
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x176d2
leaq 0x30(%rsp), %rdi
callq 0x1b9cc
jmp 0x177ba
movq %rax, %r14
movl $0x98, %esi
movq %r12, %rdi
callq 0x7390
jmp 0x1770d
jmp 0x1770a
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x1a61a
leaq 0xb0(%rsp), %rdi
callq 0x1a61a
leaq 0xd0(%rsp), %rdi
callq 0x1a61a
leaq 0xf0(%rsp), %rdi
callq 0x1a61a
leaq 0x110(%rsp), %rdi
callq 0x1a61a
leaq 0x130(%rsp), %rdi
callq 0x1a61a
leaq 0x150(%rsp), %rdi
callq 0x1a61a
leaq 0x170(%rsp), %rdi
callq 0x1a61a
leaq 0x190(%rsp), %rdi
callq 0x1a61a
leaq 0x1b0(%rsp), %rdi
callq 0x1a61a
leaq 0x70(%rsp), %rdi
callq 0x1a61a
leaq 0x1d0(%rsp), %rdi
callq 0x1a61a
leaq 0x50(%rsp), %rdi
callq 0x1a61a
leaq 0x30(%rsp), %rdi
callq 0x1a61a
movq 0x218(%rsp), %rdi
leaq 0x228(%rsp), %rax
cmpq %rax, %rdi
je 0x177df
movq 0x228(%rsp), %rsi
incq %rsi
callq 0x7390
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x177fb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7390
movq 0x250(%rsp), %rdi
leaq 0x260(%rsp), %rax
cmpq %rax, %rdi
je 0x17820
movq 0x260(%rsp), %rsi
incq %rsi
callq 0x7390
leaq 0x328(%rsp), %rdi
callq 0x70d0
movq %r14, %rdi
callq 0x76a0
nop