// File: /workspace/github_cpp_makefile_star2_O2/nikhilYadala[P]Python_to_cpp/Source/src/convert_to_cpp.cpp
// Function: convert_to_cpp(unsigned long, unsigned long, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, function_declaration*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void convert_to_cpp(unsigned long int start,
					unsigned long int end,
					std::vector< line_pair >& lines,
					std::string& converted_code,
					function_declaration* _function,
					std::map< std::string,std::string >& variables )
{

// std::cout<<src.lines[itr1->first].first;
	std::vector< std::string > tokens;

	//std::string res_code;
	//break_into_words(lines[start].first,tokens);
	// for(std::vector< std::string >::iterator itr=tokens.begin();itr!=tokens.end();++itr)
	// 	std::cout<<*itr<<"--";

///////////////////////////////////////Function conversion starts/////////////////////////////////////
	
	
	break_into_words(lines[start].first,tokens);
	

	if(tokens[0]=="def")
	{
		_function->return_type="";
		_function->name=tokens[1];	
		std::vector< std::string >::iterator itr,itr1=tokens.begin();

		while(*(itr1++)!=":");

		for(itr=tokens.begin()+3;;itr++){
			if(*itr == ",")
				continue;
			if(*(itr)==")")
				break;
			_function->args.push_back(std::pair< std::string,std::string >(*itr,map_type(*itr1,start)));
			itr1++;
		}

	}
	for(std::vector< string_pair >::iterator itr=_function->args.begin();itr!=_function->args.end();++itr)
			variables[itr->first]=itr->second;
	
		

	for(unsigned long int i=start;i<=end;)						//start from start only not +1 as it will miss cases of outside															 
	{	
		tokens.clear();
		break_into_words(lines[i].first,tokens);
			// 	for(std::vector< std::string >::iterator itr=tokens.begin();itr!=tokens.end();itr=itr+1)
			// 	std::	cout<<"---"<<*itr<<"-----";
			// std::cout<<"\n\n";

		std::vector< std::string >::iterator itr=tokens.begin();		
		if(*itr=="if" || *itr == "elif")
		{
			std::vector< std::string >::iterator if_or_elif = itr; 
			itr++;
			bool is_not=0;
			if(*itr=="not")
				{
					is_not=1;
					itr++;
				}	
			std::string expr="";
			
			if(is_not)
				expr.append("!");

			while(itr!=tokens.end()-1)
				expr.append(*(itr++));
			
			converted_code.append((size_t)lines[i].second*tab_size,' ');
			if( *if_or_elif == "if")
				converted_code.append("if(");
			else converted_code.append("else if(");		
			converted_code.append(expr);
			converted_code.append(")\n");
			converted_code.append((size_t)lines[i].second*tab_size,' ');
			int spaces = (size_t)lines[i].second;
			converted_code.append("{\n");
			
			int space_count=lines[i].second,st=i;
			
			while(lines[++i].second>space_count);
				
			std::string snippet;
			convert_to_cpp(st+1,i-1,lines,snippet,_function,variables);
			converted_code.append(snippet);
			
			converted_code.append(spaces*tab_size,' ');
			converted_code.append("}\n");
			//i already incremented while changing lines
			continue;

		}
		
		////NOTE:- Every section puts \n at its end so no need to put one in each section's beginning

		if(*itr=="print")
		{
			itr++;
			converted_code.append((size_t)lines[i].second*tab_size,' ');
			converted_code.append("std::cout<<");
			int f=1;
			while(itr!=tokens.end())
			{
				if(*itr=="("||*itr==")")
					f=!f;

				if(!f||*itr!=",")
					converted_code.append(*itr);
				if(f&&*itr==",")
					converted_code.append("<<\"  \"<<");
				itr++;
			}
			converted_code.append(";\n");
			i++;
			continue;
		}

		if(*itr=="return")
		{
			converted_code.append((size_t)lines[i].second*tab_size,' ');
			converted_code.append("return ");
			std::vector< std::string >::iterator itr1;
			std::string expr="";
			bool f= 0;
			while((++itr)!=tokens.end()){
				if(*itr==":"){
					f=1;
					break;
				}
				expr.append(*itr);
			}
			itr1 = itr+1;
			
			converted_code.append(expr);
			converted_code.append(";\n");
			// std::cout<<"OKK";
			if(expr_type(expr,variables)!="")
				_function->return_type=expr_type(expr,variables);
			else if(f)
				_function->return_type=*itr1;
			
			break;	//break in return as must be last line of every sensible function  or block
		}

		if(*itr=="else")
		 {
		 	converted_code.append((size_t)lines[i].second*tab_size,' ');
			converted_code.append("else\n");
		 	converted_code.append((size_t)lines[i].second*tab_size,' ');
		 	converted_code.append("{\n");
		 	int spaces = (size_t)lines[i].second;

		 	int space_count=lines[i].second,st=i;			
			while(lines[++i].second>space_count);				
			std::string snippet;
			convert_to_cpp(st+1,i-1,lines,snippet,_function,variables);
			converted_code.append(snippet);
			
			converted_code.append(spaces*tab_size,' ');
			converted_code.append("}\n");
			////NOTE:- Every section puts \n at its end so no need to put one in each section's beginning
		 	continue;
		 }

		else if (*itr=="while")
		{

		// for(std::vector< std::string >::iterator itr=tokens.begin();itr!=tokens.end();itr=itr+1)
		// 		std::	cout<<"---"<<*itr<<"-----\n";
			itr++;
			bool is_not=0;
			if(*itr=="not")
				{
					is_not=1;
					itr++;
				}
			converted_code.append((size_t)lines[i].second*tab_size,' ');
			converted_code.append("while(");
			if(is_not) converted_code.append("!");
			while(*itr!=":"){
				converted_code.append(*itr);
				itr++;
			}

			converted_code.append(")\n");
					
			converted_code.append((size_t)lines[i].second*tab_size,' ');
			int spaces = (size_t)lines[i].second;
			converted_code.append("{\n");
			
			int space_count=lines[i].second,st=i;
			
			while(lines[++i].second>space_count);
				
			std::string snippet;
			convert_to_cpp(st+1,i-1,lines,snippet,_function,variables);
			converted_code.append(snippet);
			
			converted_code.append(spaces*tab_size,' ');
			converted_code.append("}\n");
			//i already incremented while changing lines
			continue;
		}

	//code for converting for loops in python to cpp
		else if(*itr=="for")
		{
			if(std::count(tokens.begin(),tokens.end(),"range")==0)
			{
			std::cout<<"KKK "<<tokens[1]<<"  "<<tokens[3]<<"\n";
			converted_code.append((size_t)lines[i].second*tab_size,' ');

				converted_code.append("\nfor (auto &").append(tokens[1]).append(" : ").append(tokens[3]).append(")");
 			int spaces = (size_t)lines[i].second;
			converted_code.append(spaces*tab_size,' ');
			converted_code.append("{\n");

			int space_count=lines[i].second,st=i;

			while(lines[++i].second>space_count); //to find the complete for block
			std::string snippet;
			convert_to_cpp(st+1,i-1,lines,snippet,_function,variables);
			converted_code.append(snippet);
			converted_code.append(spaces*tab_size,' ');
			converted_code.append("}\n");
			//i already incremented while changing lines
			continue;

			}
			else {
			converted_code.append((size_t)lines[i].second*tab_size,' ');
			int spaces=(size_t)lines[i].second;
			converted_code.append("for(long int ");
			converted_code.append(*(++itr)); 
			std::string var=*(itr); 

			std::string start_range="0";
			std::string end_range="";

			std::vector< std::string >::iterator itr2;
			itr2=++itr;//bypassing "in"

			if(*(++itr2)=="range")
			{
				if(*(++itr2)=="(")            //the case of range(3,5)
				{
					start_range = *(++itr2);
					
					if(*(++itr2)==",")
					{
						end_range=*(++itr2);
					}
					else						//the case of range(100)
					{
						end_range=start_range.append("-1");
						start_range="0";
					}

				} //end evaluating the expression in range()

				
			}//end the range()


			converted_code.append("=");
			converted_code.append((start_range));
			converted_code.append(";").append(var).append("<=").append((end_range)).append(";");
			converted_code.append(var).append("++)\n");//starting the for loop with {
				// i++;  //to go next line
			spaces = (size_t)lines[i].second;
			converted_code.append(spaces*tab_size,' ');
			converted_code.append("{\n");

			int space_count=lines[i].second,st=i;

			while(lines[++i].second>space_count); //to find the complete for block
			std::string snippet;
			convert_to_cpp(st+1,i-1,lines,snippet,_function,variables);
			converted_code.append(snippet);
			converted_code.append(spaces*tab_size,' ');
			converted_code.append("}\n");
			//i already incremented while changing lines
			continue;
		}


	}//end elseif statement for for loop

		else if (*itr!="def")	//treat every foreign token as variable name or function
		{

			std::string v=*itr;
			std::string expr="";
			bool is_function_call=1;
			if(*(itr+1)=="="){
				is_function_call=0;
				itr=itr+2;	//skip = sign
			}



			if(std::find(tokens.begin(), tokens.end(),"raw_input")!=tokens.end())
			{
				tokens.pop_back();
				itr=itr+3;
				bool f = 0;
				int i = 0;
				expr.append(*(itr+1));
				while(*itr!=":") {
					i++;
					// if(*itr=="(") f=1;
					// if(!f) expr.append(*itr);
					itr++;
					if(i==1000000)
					{
						std::cout<<": missing on line "<<i<<std::endl;
						exit(0);
					}
				}
				itr++;
				variables[v]=map_type(*itr,i);
				converted_code.append((size_t)lines[i].second*tab_size,' ');			
				converted_code.append(variables[v]);
				if(variables[v]=="artificial_string")
					converted_code.append(" "+v+"(\"\");\n");					
				else converted_code.append(" "+v+";\n"	);

				converted_code.append((size_t)lines[i].second*tab_size,' ');
				converted_code.append("std::cout<<");
				converted_code.append(expr);
				converted_code.append(";\n");
				converted_code.append((size_t)lines[i].second*tab_size,' ');
				converted_code.append("std::cin>>");
				converted_code.append(v);
				converted_code.append(";\n");

				
			}
			//all other function calls and varible declarations and procesing
			else{
					if(is_function_call)
						while(itr!=tokens.end()) expr.append(*itr++);
					else{
							while(*itr!=":" && itr!=tokens.end())
								expr.append(*itr++);
					}
					//if the type is expliciyly mentioned 
					bool type_annotated = 1;
					if(itr == tokens.end())
					{
						type_annotated = 0;
						if(!is_function_call)
							std::cout<<"[ WARNING ] Auto type predicting at line "<<i<<std::endl;
					}

					std::vector< std::string >::iterator itr1 = itr;
					if(type_annotated)	
						itr1 = itr+1;
					

		    		expr = eval_expr(expr);

					if(!is_function_call)
					{
						bool not_decl = (variables.find(v) != variables.end());
				
							if(!type_annotated)
								variables[v]=expr_type(expr,variables);
							else{
								std::string t ="";
								while(itr1!=tokens.end()){
									t.append(*itr1);
									itr1++;
								}
								variables[v]=map_type(t,i);
							}
									
							converted_code.append((size_t)lines[i].second*tab_size,' ');		
							
								if(expr_type(expr,variables)=="list")
								{
									itr = tokens.begin()+3;
									converted_code.append("std::"+variables[v]+" ").append(v).append(";");
									// std::string::iterator itr3=itr;
									// if(variables.count(*itr3))
									// {
									// 	for(std::vector <int>::iterator it=(*itr3).begin();it!=(*itr3).end();it++)

									// }


									while(*itr!="]")
									{
										if(*itr=="["||*itr==",")
											itr++;
 										else {converted_code.append("\n").append(v).append(".push_back(").append(*itr).append(");");
 											itr++;
 									}
 								    }


                                   }

						 		   if(expr_type(expr,variables)!="list")
									{	
										if(!not_decl) 
										converted_code.append(variables[v]);	
										converted_code.append(" ");
										converted_code.append(v);
										converted_code.append(" = ");
										converted_code.append(expr);
										converted_code.append(";\n");
									
									}
					}

					
					else{// if it is a function call
						converted_code.append((size_t)lines[i].second*tab_size,' ');
						converted_code.append(expr);
						converted_code.append(";\n");
					}
			}
			i++;
			continue;



		}	 
		i++;							// if nothing gets caught
	
	}		

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r9, -0x40(%rbp)
movq %r8, -0x58(%rbp)
movq %rcx, -0x30(%rbp)
movq %rsi, -0x128(%rbp)
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rsi
andq $0x0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rdi, -0x48(%rbp)
imulq $0x28, %rdi, %rdi
movq %rdx, -0x38(%rbp)
addq (%rdx), %rdi
callq 0x2904
movq -0x90(%rbp), %rdi
leaq 0x643b(%rip), %rsi      # 0x906f
callq 0x42a8
testb %al, %al
je 0x2d35
movq -0x58(%rbp), %rax
leaq 0x20(%rax), %rdi
leaq 0x65ae(%rip), %rsi      # 0x91fe
callq 0x2350
movq -0x90(%rbp), %rsi
addq $0x20, %rsi
movq -0x58(%rbp), %rdi
callq 0x2110
movq -0x90(%rbp), %rbx
leaq 0x64ec(%rip), %r14      # 0x9163
movq %rbx, %rdi
addq $0x20, %rbx
movq %r14, %rsi
callq 0x4381
testb %al, %al
jne 0x2c77
movq -0x90(%rbp), %r12
addq $0x60, %r12
movq -0x58(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x120(%rbp)
leaq -0x188(%rbp), %r15
leaq -0x78(%rbp), %r13
leaq -0xd0(%rbp), %r14
movq %r12, %rdi
leaq 0x63b3(%rip), %rsi      # 0x9073
callq 0x42a8
testb %al, %al
jne 0x2d2f
movq %r12, %rdi
leaq 0x6346(%rip), %rsi      # 0x9019
callq 0x42a8
testb %al, %al
jne 0x2d35
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2290
movq %r13, %rdi
movq %r15, %rsi
movq -0x48(%rbp), %rdx
callq 0x2a92
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x438e
movq -0x120(%rbp), %rdi
movq %r14, %rsi
callq 0x4c0a
movq %r14, %rdi
callq 0x43b4
movq %r13, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x20e0
addq $0x20, %rbx
addq $0x20, %r12
jmp 0x2cb6
movq -0x58(%rbp), %rax
movq 0x40(%rax), %rbx
movq -0x58(%rbp), %rax
cmpq 0x48(%rax), %rbx
je 0x2d68
movq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x42dc
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
addq $0x20, %rbx
jmp 0x2d3d
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x120(%rbp)
leaq -0x110(%rbp), %r12
movq -0x48(%rbp), %r14
cmpq -0x128(%rbp), %r14
ja 0x4014
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x43d4
movq %r14, -0x48(%rbp)
imulq $0x28, %r14, %r13
movq -0x38(%rbp), %rax
movq (%rax), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x2904
movq -0x90(%rbp), %rbx
movq %rbx, %rdi
leaq 0x62ae(%rip), %rsi      # 0x9077
callq 0x42a8
testb %al, %al
jne 0x2de9
movq %rbx, %rdi
leaq 0x6299(%rip), %rsi      # 0x9075
callq 0x42a8
testb %al, %al
je 0x2fbc
leaq 0x20(%rbx), %r12
movq %r12, %rdi
leaq 0x6283(%rip), %rsi      # 0x907a
callq 0x42a8
movl %eax, %r15d
leaq 0x40(%rbx), %r14
testb %al, %al
cmoveq %r12, %r14
leaq -0xd0(%rbp), %rdi
leaq 0x63e7(%rip), %rsi      # 0x91fe
leaq -0x78(%rbp), %rdx
callq 0x20b0
testb %r15b, %r15b
je 0x2e41
leaq -0xd0(%rbp), %rdi
leaq 0x624b(%rip), %rsi      # 0x907e
callq 0x2340
leaq -0x110(%rbp), %r12
jmp 0x2e48
leaq -0x110(%rbp), %r12
movq -0x88(%rbp), %rax
addq $-0x20, %rax
cmpq %rax, %r14
je 0x2e70
leaq 0x20(%r14), %r15
leaq -0xd0(%rbp), %rdi
movq %r14, %rsi
callq 0x2360
movq %r15, %r14
jmp 0x2e48
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %r14
movq %r14, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %rbx, %rdi
leaq 0x61de(%rip), %rsi      # 0x9077
callq 0x42a8
testb %al, %al
leaq 0x61d9(%rip), %rsi      # 0x9080
leaq 0x61d7(%rip), %rax      # 0x9085
cmovneq %rax, %rsi
movq %r14, %rdi
callq 0x2340
movq %r14, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %r14, %rdi
leaq 0x6230(%rip), %rsi      # 0x9103
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq %r14, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq -0x38(%rbp), %r15
movq (%r15), %rax
movslq 0x20(%rax,%r13), %rbx
movq %r14, %rdi
leaq 0x63ea(%rip), %rsi      # 0x92f3
callq 0x2340
movq (%r15), %rax
leaq (%rax,%r13), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x48(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x2f20
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
andq $0x0, -0x70(%rbp)
movb $0x0, -0x68(%rbp)
movq -0x48(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x38(%rbp), %rdx
leaq -0x78(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x2bd9
movq -0x30(%rbp), %r15
movq %r15, %rdi
leaq -0x78(%rbp), %rsi
callq 0x2360
shlq $0x2, %rbx
movq %r15, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq 0x636e(%rip), %rsi      # 0x930b
callq 0x2340
leaq -0x78(%rbp), %rdi
callq 0x20e0
leaq -0xd0(%rbp), %rdi
callq 0x20e0
jmp 0x2d82
movq %rbx, %rdi
leaq 0x60c3(%rip), %rsi      # 0x9089
callq 0x42a8
testb %al, %al
je 0x309c
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %r14
movq %r14, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r14, %rdi
leaq 0x6093(%rip), %rsi      # 0x908f
callq 0x2340
addq $0x20, %rbx
pushq $0x1
popq %r14
cmpq -0x88(%rbp), %rbx
je 0x31d1
movq %rbx, %rdi
leaq 0x60a9(%rip), %rsi      # 0x90c9
callq 0x42a8
testb %al, %al
jne 0x303c
movq %rbx, %rdi
leaq 0x5fe6(%rip), %rsi      # 0x9019
callq 0x42a8
testb %al, %al
je 0x3047
xorl %eax, %eax
testl %r14d, %r14d
sete %al
movl %eax, %r14d
testl %r14d, %r14d
je 0x305f
movq %rbx, %rdi
leaq 0x601d(%rip), %rsi      # 0x9073
callq 0x4381
testb %al, %al
je 0x3070
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x2360
testl %r14d, %r14d
je 0x3093
movq %rbx, %rdi
leaq 0x5ff9(%rip), %rsi      # 0x9073
callq 0x42a8
testb %al, %al
je 0x3093
movq -0x30(%rbp), %rdi
leaq 0x600d(%rip), %rsi      # 0x909b
callq 0x2340
addq $0x20, %rbx
jmp 0x3009
movq %rbx, %rdi
leaq 0x5ffe(%rip), %rsi      # 0x90a4
callq 0x42a8
testb %al, %al
jne 0x3ee1
movq %rbx, %rdi
leaq 0x5ff6(%rip), %rsi      # 0x90b3
callq 0x42a8
testb %al, %al
je 0x31ed
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %rbx, %rdi
leaq 0x5fc5(%rip), %rsi      # 0x90b8
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %rbx, %rdi
leaq 0x61d6(%rip), %rsi      # 0x92f3
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
addq %r13, %rax
addq $0x48, %rax
movslq -0x28(%rax), %rbx
movq -0x48(%rbp), %r14
incq %r14
leaq 0x28(%rax), %rcx
cmpl %ebx, (%rax)
movq %rcx, %rax
jg 0x3138
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
andq $0x0, -0xc8(%rbp)
movb $0x0, -0xc0(%rbp)
movq -0x48(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x38(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x2bd9
movq -0x30(%rbp), %r15
movq %r15, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
shlq $0x2, %rbx
movq %r15, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq 0x6144(%rip), %rsi      # 0x930b
callq 0x2340
jmp 0x2fab
movq -0x30(%rbp), %rdi
leaq 0x5f4b(%rip), %rsi      # 0x9127
callq 0x2340
movq -0x48(%rbp), %r14
incq %r14
jmp 0x2d82
movq %rbx, %rdi
leaq 0x5ec7(%rip), %rsi      # 0x90be
callq 0x42a8
testb %al, %al
je 0x337f
leaq 0x20(%rbx), %r15
movq %r15, %rdi
leaq 0x5e68(%rip), %rsi      # 0x907a
callq 0x42a8
movl %eax, %r14d
addq $0x40, %rbx
testb %al, %al
cmoveq %r15, %rbx
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %r15
movq %r15, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq 0x5e77(%rip), %rsi      # 0x90c4
callq 0x2340
testb %r14b, %r14b
je 0x3278
movq %r15, %rdi
leaq 0x5e1d(%rip), %rsi      # 0x907e
callq 0x2340
jmp 0x3278
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x2360
addq $0x20, %rbx
movq %rbx, %rdi
leaq 0x5ee1(%rip), %rsi      # 0x9163
callq 0x4381
testb %al, %al
jne 0x3268
movq -0x30(%rbp), %r14
movq %r14, %rdi
leaq 0x5e6a(%rip), %rsi      # 0x9103
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq %r14, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq -0x38(%rbp), %r15
movq (%r15), %rax
movslq 0x20(%rax,%r13), %rbx
movq %r14, %rdi
leaq 0x6024(%rip), %rsi      # 0x92f3
callq 0x2340
movq (%r15), %rax
leaq (%rax,%r13), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x48(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x32e6
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
andq $0x0, -0xc8(%rbp)
movb $0x0, -0xc0(%rbp)
movq -0x48(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x38(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x2bd9
movq -0x30(%rbp), %r15
movq %r15, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
shlq $0x2, %rbx
movq %r15, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq 0x5f96(%rip), %rsi      # 0x930b
callq 0x2340
jmp 0x2fab
movq %rbx, %rdi
leaq 0x5d42(%rip), %rsi      # 0x90cb
callq 0x42a8
testb %al, %al
je 0x34a3
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
leaq 0x5d24(%rip), %rdx      # 0x90cf
callq 0x4e41
testq %rax, %rax
je 0x358b
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %r15
movq %r15, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq 0x5d09(%rip), %rsi      # 0x90eb
callq 0x2340
leaq 0x20(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2360
leaq -0xd0(%rbp), %rdi
movq %r14, %rsi
callq 0x2290
leaq -0x78(%rbp), %rdi
leaq 0x5ce9(%rip), %rsi      # 0x90f9
movq %r12, %rdx
callq 0x20b0
movq %r12, %rdi
leaq 0x5ddc(%rip), %rsi      # 0x91fe
leaq -0xf0(%rbp), %rdx
callq 0x20b0
leaq 0x60(%rbx), %rdi
leaq 0x5c96(%rip), %rsi      # 0x90cf
callq 0x42a8
testb %al, %al
je 0x3ab5
leaq 0x80(%rbx), %rdi
leaq 0x5c75(%rip), %rsi      # 0x90c9
callq 0x42a8
testb %al, %al
je 0x3ab5
leaq 0xa0(%rbx), %rsi
leaq -0x78(%rbp), %rdi
callq 0x2110
leaq 0xc0(%rbx), %rdi
leaq 0x5bf4(%rip), %rsi      # 0x9073
callq 0x42a8
testb %al, %al
je 0x3a8a
addq $0xe0, %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2110
jmp 0x3ab5
movq %rbx, %rdi
leaq 0x5bc2(%rip), %rsi      # 0x906f
callq 0x4381
testb %al, %al
je 0x31e1
leaq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x2290
leaq -0x78(%rbp), %rdi
leaq 0x5d2a(%rip), %rsi      # 0x91fe
movq %r12, %rdx
callq 0x20b0
leaq 0x20(%rbx), %rdi
leaq 0x5c18(%rip), %rsi      # 0x90ff
callq 0x42a8
movl %eax, %r15d
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
leaq 0x5c02(%rip), %rdx      # 0x9106
callq 0x4e80
movzbl %r15b, %r14d
shll $0x6, %r14d
leaq (%rbx,%r14), %r12
movq -0x88(%rbp), %rdi
cmpq %rdi, %rax
je 0x381a
addq $-0x20, %rdi
movq %rdi, -0x88(%rbp)
callq 0x20e0
subq $-0x80, %r12
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
callq 0x2360
addq %rbx, %r14
addq $0x80, %r14
xorl %ebx, %ebx
pushq $0x20
popq %r15
leaq -0x110(%rbp), %r12
leaq -0x20(%r14), %rdi
leaq 0x5bfc(%rip), %rsi      # 0x9163
callq 0x4381
testb %al, %al
je 0x372c
incl %ebx
addq $0x20, %r14
addq $0x28, %r15
cmpl $0xf4240, %ebx          # imm = 0xF4240
jne 0x355c
jmp 0x4032
movq 0x9a46(%rip), %rdi      # 0xcfd8
leaq 0x5b3c(%rip), %rsi      # 0x90d5
callq 0x21a0
movq -0x30(%rbp), %r14
movq -0x90(%rbp), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
leaq 0x5c4e(%rip), %rsi      # 0x920d
callq 0x21a0
movq -0x90(%rbp), %rsi
addq $0x60, %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
leaq 0x5c1c(%rip), %rsi      # 0x91fd
callq 0x21a0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq %r14, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r14, %rdi
leaq 0x5acf(%rip), %rsi      # 0x90da
callq 0x2340
movq -0x90(%rbp), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0x2360
movq %rax, %rdi
leaq 0x5aba(%rip), %rsi      # 0x90e7
callq 0x2340
movq -0x90(%rbp), %rsi
addq $0x60, %rsi
movq %rax, %rdi
callq 0x2360
movq %rax, %rdi
leaq 0x59ca(%rip), %rsi      # 0x9019
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rbx
shlq $0x2, %rbx
movq %r14, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r14, %rdi
leaq 0x5c77(%rip), %rsi      # 0x92f3
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
leaq (%rax,%r13), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x48(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x3697
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
andq $0x0, -0xc8(%rbp)
movb $0x0, -0xc0(%rbp)
movq -0x48(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x38(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x2bd9
movq -0x30(%rbp), %r15
movq %r15, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %r15, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq 0x5be9(%rip), %rsi      # 0x930b
callq 0x2340
jmp 0x2fab
leaq -0x168(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2290
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x2a92
movq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x42dc
movq %rax, %rdi
movq %r12, %rsi
callq 0x2240
movq %r12, %rdi
callq 0x20e0
leaq -0x168(%rbp), %rdi
callq 0x20e0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x42dc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2360
movq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x42dc
movq %rax, %rdi
leaq 0x5853(%rip), %rsi      # 0x9020
callq 0x42a8
testb %al, %al
je 0x387f
leaq -0xf0(%rbp), %rbx
movq %rbx, %rdi
leaq 0x5a23(%rip), %rsi      # 0x920e
leaq -0xd0(%rbp), %rdx
callq 0x4232
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x591f(%rip), %rdx      # 0x9123
callq 0x4209
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x2360
jmp 0x38ba
testb %r15b, %r15b
je 0x385c
movq %r12, %rdi
leaq 0x593a(%rip), %rsi      # 0x9163
callq 0x4381
movq -0x88(%rbp), %r14
testb %al, %al
je 0x3965
cmpq %r14, %r12
je 0x3965
leaq 0x20(%r12), %rbx
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
callq 0x2360
movq %rbx, %r12
jmp 0x381f
cmpq -0x88(%rbp), %r12
je 0x3962
leaq 0x20(%r12), %rbx
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
callq 0x2360
movq %rbx, %r12
jmp 0x385c
leaq -0xf0(%rbp), %rbx
movq %rbx, %rdi
leaq 0x597e(%rip), %rsi      # 0x920e
leaq -0xd0(%rbp), %rdx
callq 0x4232
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x587e(%rip), %rdx      # 0x9127
callq 0x4209
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x2360
movq %r12, %rdi
callq 0x20e0
leaq -0xf0(%rbp), %rdi
callq 0x20e0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %rbx, %rdi
leaq 0x5799(%rip), %rsi      # 0x908f
callq 0x2340
movq %rbx, %rdi
leaq -0x78(%rbp), %rsi
callq 0x2360
movq %rbx, %rdi
leaq 0x5816(%rip), %rsi      # 0x9127
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15), %rsi
shlq $0x2, %rsi
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %rbx, %rdi
leaq 0x57f0(%rip), %rsi      # 0x912a
callq 0x2340
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %rbx, %rdi
leaq 0x57cf(%rip), %rsi      # 0x9127
callq 0x2340
jmp 0x3ed5
movq %r12, %r14
cmpq %r14, %r12
setne %al
movb %r15b, -0x118(%rbp)
xorb $0x1, %r15b
orb %al, %r15b
jne 0x39a2
movq 0x9656(%rip), %rdi      # 0xcfd8
leaq 0x57ac(%rip), %rsi      # 0x9135
callq 0x21a0
movq %rax, %rdi
movq -0x48(%rbp), %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20f0
cmpq %r14, %r12
setne -0x49(%rbp)
leaq -0x110(%rbp), %r15
movq %r15, %rdi
leaq -0x78(%rbp), %rbx
movq %rbx, %rsi
callq 0x260c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20e0
cmpb $0x0, -0x118(%rbp)
je 0x3a44
movq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4f76
movq %rax, -0x118(%rbp)
cmpq %r14, %r12
je 0x3c8b
leaq -0x110(%rbp), %rdi
leaq 0x57f5(%rip), %rsi      # 0x91fe
leaq -0xf0(%rbp), %rdx
callq 0x20b0
xorl %eax, %eax
movb -0x49(%rbp), %cl
movb %cl, %al
shll $0x5, %eax
addq %rax, %r12
cmpq -0x88(%rbp), %r12
je 0x3c27
leaq -0x110(%rbp), %rdi
movq %r12, %rsi
callq 0x2360
addq $0x20, %r12
jmp 0x3a22
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x21f0
leaq -0x110(%rbp), %r12
movq %rbx, %rdi
leaq -0x78(%rbp), %rsi
callq 0x2360
movq %rbx, %rdi
leaq 0x56a7(%rip), %rsi      # 0x9127
callq 0x2340
jmp 0x3ed5
leaq -0x78(%rbp), %rdi
leaq 0x5666(%rip), %rsi      # 0x90fb
callq 0x2340
movq %r12, %rdi
movq %rax, %rsi
callq 0x2110
leaq -0x78(%rbp), %rdi
leaq 0x5649(%rip), %rsi      # 0x90f9
callq 0x2350
movq -0x30(%rbp), %rdi
leaq 0x563f(%rip), %rsi      # 0x90ff
callq 0x2340
movq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2360
movq -0x30(%rbp), %rdi
leaq 0x5699(%rip), %rsi      # 0x9176
callq 0x2340
movq %rax, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %rax, %rdi
leaq 0x5603(%rip), %rsi      # 0x90fe
callq 0x2340
movq %rax, %rdi
movq %r12, %rsi
callq 0x2360
movq %rax, %rdi
leaq 0x5661(%rip), %rsi      # 0x9176
callq 0x2340
movq -0x30(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %rax, %rdi
leaq 0x55cd(%rip), %rsi      # 0x9101
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rbx
shlq $0x2, %rbx
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq -0x30(%rbp), %rdi
leaq 0x5790(%rip), %rsi      # 0x92f3
callq 0x2340
movq -0x38(%rbp), %rax
movq (%rax), %rax
leaq (%rax,%r13), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x48(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x3b7e
leaq -0xe0(%rbp), %rax
movq %rax, -0xf0(%rbp)
andq $0x0, -0xe8(%rbp)
movb $0x0, -0xe0(%rbp)
movq -0x48(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x38(%rbp), %rdx
leaq -0xf0(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x2bd9
movq -0x30(%rbp), %r15
movq %r15, %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2360
movq %r15, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq 0x5702(%rip), %rsi      # 0x930b
callq 0x2340
leaq -0xf0(%rbp), %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x20e0
jmp 0x2fa2
leaq -0x148(%rbp), %rbx
movq %rbx, %rdi
leaq -0x110(%rbp), %r15
movq %r15, %rsi
callq 0x2290
leaq -0xf0(%rbp), %rdi
movq %rbx, %rsi
movq -0x48(%rbp), %rdx
callq 0x2a92
movq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x42dc
movq %rax, %rdi
leaq -0xf0(%rbp), %rbx
movq %rbx, %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x20e0
leaq -0x148(%rbp), %rdi
callq 0x20e0
jmp 0x3cb8
movq %r15, %rdi
leaq -0x78(%rbp), %rsi
movq -0x40(%rbp), %rbx
movq %rbx, %rdx
callq 0x277c
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x42dc
movq %rax, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20e0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
movq -0x30(%rbp), %rdi
pushq $0x20
popq %rdx
callq 0x21f0
movq %r15, %rdi
leaq -0x78(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x277c
movq %r15, %rdi
leaq 0x5325(%rip), %rsi      # 0x901b
callq 0x42a8
movl %eax, %r14d
movq %r15, %rdi
callq 0x20e0
testb %r14b, %r14b
je 0x3e28
movq -0x90(%rbp), %r12
movq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x42dc
leaq -0xf0(%rbp), %r14
movq %r14, %rdi
leaq 0x5428(%rip), %rsi      # 0x915f
movq %rax, %rdx
callq 0x4232
leaq -0x110(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x54bb(%rip), %rdx      # 0x920e
callq 0x4209
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x2360
movq %rax, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %rax, %rdi
leaq 0x53f9(%rip), %rsi      # 0x9176
callq 0x2340
addq $0x60, %r12
leaq -0x110(%rbp), %rdi
callq 0x20e0
leaq -0xf0(%rbp), %rdi
callq 0x20e0
movq %r12, %rdi
leaq 0x53bd(%rip), %rsi      # 0x9165
callq 0x4381
testb %al, %al
je 0x3e28
movq %r12, %rdi
leaq 0x53ac(%rip), %rsi      # 0x9167
callq 0x42a8
testb %al, %al
jne 0x3e1f
movq %r12, %rdi
leaq 0x52a5(%rip), %rsi      # 0x9073
callq 0x42a8
testb %al, %al
jne 0x3e1f
movq -0x30(%rbp), %rdi
leaq 0x541b(%rip), %rsi      # 0x91fd
callq 0x2340
movq %rax, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %rax, %rdi
leaq 0x5369(%rip), %rsi      # 0x9169
callq 0x2340
movq %rax, %rdi
movq %r12, %rsi
callq 0x2360
movq %rax, %rdi
leaq 0x535b(%rip), %rsi      # 0x9175
callq 0x2340
addq $0x20, %r12
jmp 0x3d9e
leaq -0x110(%rbp), %r12
movq %r12, %rdi
leaq -0x78(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x277c
movq %r12, %rdi
leaq 0x51d2(%rip), %rsi      # 0x901b
callq 0x4381
movl %eax, %r14d
movq %r12, %rdi
callq 0x20e0
testb %r14b, %r14b
movq -0x30(%rbp), %rbx
je 0x3ed5
movq -0x118(%rbp), %rax
cmpq -0x120(%rbp), %rax
jne 0x3e8d
movq -0x40(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x42dc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2360
movq %rbx, %rdi
leaq 0x5377(%rip), %rsi      # 0x920e
callq 0x2340
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x2360
movq %rbx, %rdi
leaq 0x52c3(%rip), %rsi      # 0x9178
callq 0x2340
movq %rbx, %rdi
leaq -0x78(%rbp), %rsi
callq 0x2360
movq %rbx, %rdi
leaq 0x5257(%rip), %rsi      # 0x9127
callq 0x2340
movq -0x48(%rbp), %r14
incq %r14
jmp 0x2fa2
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r13), %rsi
shlq $0x2, %rsi
pushq $0x20
popq %rdx
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x21f0
leaq 0x51a4(%rip), %rsi      # 0x90ab
movq %r14, %rdi
callq 0x2340
leaq 0x52e8(%rip), %rsi      # 0x91fe
leaq -0xd0(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x20b0
addq $0x40, %rbx
leaq 0x5232(%rip), %r15      # 0x9163
leaq -0xd0(%rbp), %r12
leaq -0x20(%rbx), %r14
movq -0x88(%rbp), %r13
cmpq %r13, %r14
je 0x3f68
movq %r14, %rdi
movq %r15, %rsi
callq 0x42a8
testb %al, %al
jne 0x3f68
addq $0x20, %rbx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2360
jmp 0x3f38
leaq -0xd0(%rbp), %rsi
movq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x2360
leaq 0x51a5(%rip), %rsi      # 0x9127
movq %r15, %rdi
callq 0x2340
leaq -0x78(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x277c
leaq 0x5259(%rip), %rsi      # 0x91fe
leaq -0x78(%rbp), %r15
movq %r15, %rdi
callq 0x4381
movl %eax, %r12d
movq %r15, %rdi
callq 0x20e0
testb %r12b, %r12b
je 0x3ff3
leaq -0x78(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x277c
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
leaq -0x78(%rbp), %rbx
movq %rbx, %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x20e0
jmp 0x4008
cmpq %r13, %r14
je 0x4008
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x2110
leaq -0xd0(%rbp), %rdi
callq 0x20e0
leaq -0x90(%rbp), %rdi
callq 0x43e2
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f9f(%rip), %rdi      # 0xcfd8
leaq 0x50d0(%rip), %rsi      # 0x9110
callq 0x21a0
movq %rax, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x2310
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x2230
jmp 0x417d
jmp 0x41d1
jmp 0x40bb
movq %rax, %rbx
jmp 0x4086
jmp 0x417d
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x20e0
leaq -0x148(%rbp), %rdi
jmp 0x416c
jmp 0x41d1
jmp 0x41d1
jmp 0x41d1
jmp 0x41d1
jmp 0x41d1
jmp 0x41e6
jmp 0x40c0
jmp 0x40c0
jmp 0x40bb
jmp 0x41d1
movq %rax, %rbx
jmp 0x40cf
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x20e0
leaq -0xf0(%rbp), %rdi
jmp 0x4187
jmp 0x41d1
jmp 0x41d1
jmp 0x41e6
jmp 0x41df
jmp 0x41d1
jmp 0x41d1
jmp 0x41d1
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x20e0
jmp 0x4112
movq %rax, %rbx
leaq -0x168(%rbp), %rdi
jmp 0x4187
jmp 0x41d1
jmp 0x41d1
jmp 0x41df
jmp 0x41d1
jmp 0x41e6
jmp 0x41df
jmp 0x41e6
jmp 0x41d1
jmp 0x41df
jmp 0x41e6
jmp 0x41df
jmp 0x41df
jmp 0x41e6
jmp 0x417d
jmp 0x41d1
jmp 0x41df
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x20e0
jmp 0x4180
jmp 0x41d1
jmp 0x41d1
jmp 0x41d1
jmp 0x41e6
jmp 0x41df
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x20e0
jmp 0x41d4
jmp 0x41e6
jmp 0x41df
jmp 0x41d1
jmp 0x41df
jmp 0x41e6
jmp 0x41df
movq %rax, %rbx
jmp 0x41bc
movq %rax, %rbx
jmp 0x41b3
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x43b4
leaq -0x78(%rbp), %rdi
callq 0x20e0
leaq -0x188(%rbp), %rdi
jmp 0x41f0
jmp 0x41df
jmp 0x41e6
jmp 0x41df
jmp 0x41df
jmp 0x41df
jmp 0x41df
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20e0
jmp 0x41e9
movq %rax, %rbx
jmp 0x41f5
jmp 0x41e6
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x20e0
leaq -0x90(%rbp), %rdi
callq 0x43e2
movq %rbx, %rdi
callq 0x2320