// File: /workspace/github_cpp_makefile_star2_O3/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 $0x178, %rsp            # imm = 0x178
movq %r9, -0x70(%rbp)
movq %r8, %rbx
movq %rcx, -0x38(%rbp)
movq %rsi, -0x130(%rbp)
xorps %xmm0, %xmm0
leaq -0xf0(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rdi, -0x40(%rbp)
leaq (%rdi,%rdi,4), %rdi
shlq $0x3, %rdi
movq %rdx, -0x30(%rbp)
addq (%rdx), %rdi
callq 0x2b2f
movq %rbx, -0xf8(%rbp)
movq -0xf0(%rbp), %rdi
leaq 0x810f(%rip), %rsi      # 0xb06f
callq 0x2080
testl %eax, %eax
je 0x45ed
movq -0xf8(%rbp), %r14
movq 0x40(%r14), %rbx
cmpq 0x48(%r14), %rbx
movq -0x70(%rbp), %r15
je 0x2fa6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4bc2
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
addq $0x20, %rbx
cmpq 0x48(%r14), %rbx
jne 0x2f82
movq -0x40(%rbp), %rax
cmpq -0x130(%rbp), %rax
jbe 0x2fd1
leaq -0xf0(%rbp), %rdi
callq 0x4d2e
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%r15), %rax
movq %rax, -0x138(%rbp)
movq -0xf0(%rbp), %rbx
movq -0xe8(%rbp), %r14
cmpq %rbx, %r14
je 0x3013
movq %rbx, %r15
movq (%r15), %rdi
addq $0x10, %r15
cmpq %r15, %rdi
je 0x3003
callq 0x21c0
addq $0x10, %r15
cmpq %r14, %r15
jne 0x2ff2
movq %rbx, -0xe8(%rbp)
movq -0x40(%rbp), %rax
leaq (%rax,%rax,4), %r12
leaq (,%r12,8), %rdi
movq -0x30(%rbp), %rax
addq (%rax), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2b2f
movq -0xf0(%rbp), %rbx
movq %rbx, %rdi
leaq 0x8030(%rip), %rsi      # 0xb077
callq 0x2080
testl %eax, %eax
je 0x3202
movq %rbx, %rdi
leaq 0x8017(%rip), %rsi      # 0xb075
callq 0x2080
testl %eax, %eax
je 0x3202
movq %rbx, %rdi
leaq 0x8014(%rip), %rsi      # 0xb089
callq 0x2080
testl %eax, %eax
je 0x342e
movq %rbx, %rdi
leaq 0x8018(%rip), %rsi      # 0xb0a4
callq 0x2080
testl %eax, %eax
je 0x4751
movq %rbx, %rdi
leaq 0x8010(%rip), %rsi      # 0xb0b3
callq 0x2080
testl %eax, %eax
je 0x3538
movq %rbx, %rdi
leaq 0x8004(%rip), %rsi      # 0xb0be
callq 0x2080
testl %eax, %eax
je 0x3668
movq %rbx, %rdi
leaq 0x7ffa(%rip), %rsi      # 0xb0cb
callq 0x2080
testl %eax, %eax
je 0x380f
movq %rbx, %rdi
leaq 0x7f87(%rip), %rsi      # 0xb06f
callq 0x2080
testl %eax, %eax
je 0x351b
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0xd0(%rbp), %rdi
callq 0x4d94
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0x80ec(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e32
leaq 0x20(%rbx), %rdi
leaq 0x7fba(%rip), %rsi      # 0xb0ff
callq 0x2080
movl %eax, %r13d
xorl %r14d, %r14d
testl %eax, %eax
sete %r15b
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
leaq 0x7f9b(%rip), %rdx      # 0xb106
callq 0x59b1
movb %r15b, %r14b
shll $0x6, %r14d
addq %r14, %rbx
movq -0xe8(%rbp), %rcx
cmpq %rcx, %rax
je 0x3cdb
leaq -0x20(%rcx), %rax
movq %rax, -0xe8(%rbp)
movq -0x20(%rcx), %rdi
addq $-0x10, %rcx
cmpq %rcx, %rdi
je 0x31a7
callq 0x21c0
movq 0x80(%rbx), %rsi
movq 0x88(%rbx), %rdx
leaq -0x90(%rbp), %rdi
callq 0x2090
movq -0x70(%rbp), %r12
addq $0x60, %rbx
xorl %r14d, %r14d
movl $0x20, %r15d
movq %rbx, %rdi
leaq 0x7f87(%rip), %rsi      # 0xb163
callq 0x2080
testl %eax, %eax
je 0x39a6
incl %r14d
addq $0x20, %rbx
addq $0x28, %r15
cmpl $0xf4240, %r14d         # imm = 0xF4240
jne 0x31d2
jmp 0x48da
leaq 0x20(%rbx), %r15
movq %r15, %rdi
leaq 0x7e6a(%rip), %rsi      # 0xb07a
callq 0x2080
movl %eax, %r14d
leaq 0x40(%rbx), %r13
testl %eax, %eax
cmovneq %r15, %r13
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0xd0(%rbp), %rdi
leaq 0x7fe0(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e32
testl %r14d, %r14d
jne 0x325e
leaq -0xd0(%rbp), %rdi
leaq 0x7e25(%rip), %rsi      # 0xb07e
callq 0x23b0
movq -0xe8(%rbp), %rax
addq $-0x20, %rax
cmpq %rax, %r13
je 0x328b
leaq 0x20(%r13), %r14
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq -0xd0(%rbp), %rdi
callq 0x2090
movq %r14, %r13
jmp 0x325e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %r14
movq 0x8(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %rbx, %rdi
leaq 0x7dba(%rip), %rsi      # 0xb077
callq 0x2080
testl %eax, %eax
leaq 0x7db5(%rip), %rsi      # 0xb080
leaq 0x7db3(%rip), %rax      # 0xb085
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x23b0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %r14, %rdi
callq 0x2090
movq %r14, %rdi
leaq 0x7e05(%rip), %rsi      # 0xb103
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq 0x8(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq -0x30(%rbp), %r15
movq (%r15), %rax
movslq 0x20(%rax,%r12,8), %rbx
movq %r14, %rdi
leaq 0x7fd6(%rip), %rsi      # 0xb313
callq 0x23b0
movq (%r15), %rax
leaq (%rax,%r12,8), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x40(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x3354
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x0, -0x88(%rbp)
movb $0x0, -0x80(%rbp)
movq -0x40(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x30(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movq -0xf8(%rbp), %r8
movq -0x70(%rbp), %r9
callq 0x2ef8
movq -0x38(%rbp), %r15
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
shlq $0x2, %rbx
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23a0
movq %r15, %rdi
leaq 0x7f38(%rip), %rsi      # 0xb32b
callq 0x23b0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x340d
callq 0x21c0
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x3522
callq 0x21c0
jmp 0x3522
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %r15
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %r15, %rdi
leaq 0x7c2f(%rip), %rsi      # 0xb08f
callq 0x23b0
addq $0x20, %rbx
cmpq -0xe8(%rbp), %rbx
je 0x350c
movl $0x1, %r14d
movq %rbx, %rdi
leaq 0x7c43(%rip), %rsi      # 0xb0c9
callq 0x2080
testl %eax, %eax
je 0x34a2
movq %rbx, %rdi
leaq 0x7b80(%rip), %rsi      # 0xb019
callq 0x2080
testl %eax, %eax
jne 0x34ad
xorl %eax, %eax
testl %r14d, %r14d
sete %al
movl %eax, %r14d
testl %r14d, %r14d
je 0x34c5
movq %rbx, %rdi
leaq 0x7bb7(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x34d9
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x2090
testl %r14d, %r14d
je 0x34fb
movq %rbx, %rdi
leaq 0x7b90(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
jne 0x34fb
movq %r15, %rdi
leaq 0x7ba5(%rip), %rsi      # 0xb09b
callq 0x23b0
addq $0x20, %rbx
cmpq -0xe8(%rbp), %rbx
jne 0x347c
movq %r15, %rdi
leaq 0x7c11(%rip), %rsi      # 0xb127
callq 0x23b0
movq -0x40(%rbp), %r14
incq %r14
movq %r14, -0x40(%rbp)
cmpq -0x130(%rbp), %r14
jbe 0x2fdc
jmp 0x2fb3
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %rbx, %rdi
leaq 0x7b4e(%rip), %rsi      # 0xb0b8
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %rbx, %rdi
leaq 0x7d76(%rip), %rsi      # 0xb313
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
leaq (%rax,%r12,8), %rax
addq $0x48, %rax
movslq -0x28(%rax), %rbx
movq -0x40(%rbp), %r14
incq %r14
leaq 0x28(%rax), %rcx
cmpl %ebx, (%rax)
movq %rcx, %rax
jg 0x35b9
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq $0x0, -0xc8(%rbp)
movb $0x0, -0xc0(%rbp)
movq -0x40(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x30(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0xf8(%rbp), %r8
movq -0x70(%rbp), %r9
callq 0x2ef8
movq -0x38(%rbp), %r15
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
shlq $0x2, %rbx
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23a0
movq %r15, %rdi
leaq 0x7ccd(%rip), %rsi      # 0xb32b
callq 0x23b0
jmp 0x340d
leaq 0x20(%rbx), %r15
movq %r15, %rdi
leaq 0x7a04(%rip), %rsi      # 0xb07a
callq 0x2080
movl %eax, %r14d
addq $0x40, %rbx
testl %eax, %eax
cmovneq %r15, %rbx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %r15
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %r15, %rdi
leaq 0x7a0a(%rip), %rsi      # 0xb0c4
callq 0x23b0
testl %r14d, %r14d
jne 0x36e9
movq %r15, %rdi
leaq 0x79b0(%rip), %rsi      # 0xb07e
callq 0x23b0
jmp 0x36e9
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq -0x38(%rbp), %rdi
callq 0x2090
addq $0x20, %rbx
movq %rbx, %rdi
leaq 0x7a70(%rip), %rsi      # 0xb163
callq 0x2080
testl %eax, %eax
jne 0x36d5
movq -0x38(%rbp), %r14
movq %r14, %rdi
leaq 0x79f9(%rip), %rsi      # 0xb103
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq 0x8(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq -0x30(%rbp), %r15
movq (%r15), %rax
movslq 0x20(%rax,%r12,8), %rbx
movq %r14, %rdi
leaq 0x7bca(%rip), %rsi      # 0xb313
callq 0x23b0
movq (%r15), %rax
leaq (%rax,%r12,8), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x40(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x3760
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq $0x0, -0xc8(%rbp)
movb $0x0, -0xc0(%rbp)
movq -0x40(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x30(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0xf8(%rbp), %r8
movq -0x70(%rbp), %r9
callq 0x2ef8
movq -0x38(%rbp), %r15
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
shlq $0x2, %rbx
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23a0
movq %r15, %rdi
leaq 0x7b26(%rip), %rsi      # 0xb32b
callq 0x23b0
jmp 0x340d
movq -0xf0(%rbp), %r14
movq -0xe8(%rbp), %r15
cmpq %r15, %r14
je 0x3aec
movq %r12, -0x120(%rbp)
xorl %r13d, %r13d
leaq 0x7898(%rip), %r12      # 0xb0cf
movq %r14, %rdi
movq %r12, %rsi
callq 0x2080
cmpl $0x1, %eax
adcq $0x0, %r13
addq $0x20, %r14
cmpq %r15, %r14
jne 0x3837
testq %r13, %r13
movq -0x120(%rbp), %r12
je 0x3aec
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %r14
movq 0x8(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %r14, %rdi
leaq 0x7857(%rip), %rsi      # 0xb0eb
callq 0x23b0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x2090
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq -0xd0(%rbp), %rdi
callq 0x4d94
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0x7812(%rip), %rsi      # 0xb0f9
leaq 0x780c(%rip), %rdx      # 0xb0fa
callq 0x4e32
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x7918(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e32
leaq 0x60(%rbx), %rdi
leaq 0x77b6(%rip), %rsi      # 0xb0cf
callq 0x2080
testl %eax, %eax
jne 0x430d
leaq 0x80(%rbx), %rdi
leaq 0x7795(%rip), %rsi      # 0xb0c9
callq 0x2080
testl %eax, %eax
jne 0x430d
leaq 0xa0(%rbx), %rsi
leaq -0x90(%rbp), %rdi
callq 0x2110
leaq 0xc0(%rbx), %rdi
leaq 0x7711(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x42fa
leaq -0x90(%rbp), %rdi
leaq 0x777e(%rip), %rsi      # 0xb0fb
callq 0x23b0
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x2110
leaq -0x90(%rbp), %rdi
leaq 0x775d(%rip), %rsi      # 0xb0f9
callq 0x22c0
jmp 0x430d
leaq -0x168(%rbp), %rax
movq %rax, -0x178(%rbp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq -0x178(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d94
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x2cfa
movq %r12, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4bc2
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x2290
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x3a0a
callq 0x21c0
movq -0x178(%rbp), %rdi
leaq -0x168(%rbp), %rax
cmpq %rax, %rdi
je 0x3a22
callq 0x21c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %r12, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4bc2
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x2090
movq %r12, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4bc2
movq %rax, %rdi
leaq 0x75a0(%rip), %rsi      # 0xb020
callq 0x2080
testl %eax, %eax
je 0x3e50
leaq -0x118(%rbp), %r12
movq %r12, %rdi
leaq 0x7790(%rip), %rsi      # 0xb22e
leaq -0xd0(%rbp), %rdx
callq 0x4b36
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r14
movq %r12, %rdi
leaq 0x766b(%rip), %rsi      # 0xb127
callq 0x23b0
leaq -0x50(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3eaf
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x3eb5
movl $0x4, %edx
movq 0xb4e0(%rip), %rdi      # 0xefd8
leaq 0x75d6(%rip), %rsi      # 0xb0d5
callq 0x2250
movq -0x38(%rbp), %r14
movq -0xf0(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq 0xb4ba(%rip), %rdi      # 0xefd8
callq 0x2250
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x76f8(%rip), %rsi      # 0xb22d
callq 0x2250
movq -0xf0(%rbp), %rax
movq 0x60(%rax), %rsi
movq 0x68(%rax), %rdx
movq %rbx, %rdi
callq 0x2250
movl $0x1, %edx
movq %rax, %rdi
leaq 0x76bd(%rip), %rsi      # 0xb21d
callq 0x2250
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq 0x8(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %r14, %rdi
leaq 0x7547(%rip), %rsi      # 0xb0da
callq 0x23b0
movq -0xf0(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x752e(%rip), %rsi      # 0xb0e7
callq 0x23b0
movq -0xf0(%rbp), %rcx
movq 0x60(%rcx), %rsi
movq 0x68(%rcx), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x743a(%rip), %rsi      # 0xb019
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rbx
shlq $0x2, %rbx
movq 0x8(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23a0
movq %r14, %rdi
leaq 0x76fe(%rip), %rsi      # 0xb313
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
leaq (%rax,%r12,8), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x40(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x3c30
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq $0x0, -0xc8(%rbp)
movb $0x0, -0xc0(%rbp)
movq -0x40(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x30(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0xf8(%rbp), %r8
movq -0x70(%rbp), %r9
callq 0x2ef8
movq -0x38(%rbp), %r15
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23a0
movq %r15, %rdi
leaq 0x765a(%rip), %rsi      # 0xb32b
callq 0x23b0
jmp 0x340d
testl %r13d, %r13d
je 0x3d1f
cmpq -0xe8(%rbp), %rbx
je 0x3d40
leaq 0x20(%rbx), %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq -0x90(%rbp), %rdi
callq 0x2090
movq %r14, %rbx
jmp 0x3ce0
leaq 0x20(%rbx), %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq -0x90(%rbp), %rdi
callq 0x2090
movq %r14, %rbx
movq %rbx, %rdi
leaq 0x743a(%rip), %rsi      # 0xb163
callq 0x2080
movq -0xe8(%rbp), %r15
testl %eax, %eax
je 0x3d43
cmpq %r15, %rbx
jne 0x3d05
jmp 0x3d43
movq %rbx, %r15
movq %r12, -0x120(%rbp)
movl %r13d, -0x124(%rbp)
testl %r13d, %r13d
jne 0x3dad
cmpq %r15, %rbx
jne 0x3dad
movl $0x29, %edx
movq 0xb271(%rip), %rdi      # 0xefd8
leaq 0x73c7(%rip), %rsi      # 0xb135
callq 0x2250
movq 0xb25e(%rip), %rdi      # 0xefd8
movq -0x40(%rbp), %rsi
callq 0x2130
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
xorl %r14d, %r14d
cmpq %r15, %rbx
setne -0x61(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, %rdi
leaq -0x90(%rbp), %r13
movq %r13, %rsi
callq 0x272c
movq %r13, %rdi
movq %r12, %rsi
callq 0x2290
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x3dea
callq 0x21c0
cmpl $0x0, -0x124(%rbp)
movq -0x120(%rbp), %r12
je 0x3ee1
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x72e1(%rip), %rsi      # 0xb127
callq 0x23b0
jmp 0x40df
leaq -0x118(%rbp), %r12
movq %r12, %rdi
leaq 0x73cd(%rip), %rsi      # 0xb22e
leaq -0xd0(%rbp), %rdx
callq 0x4b36
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r14
movq %r12, %rdi
leaq 0x72a4(%rip), %rsi      # 0xb123
callq 0x23b0
leaq -0x50(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3fde
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x3fe4
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0x58(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
jmp 0x400b
movq -0x70(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x5ab2
movq %rax, %r13
cmpq %r15, %rbx
je 0x4115
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x730e(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e32
movb -0x61(%rbp), %al
movb %al, %r14b
shll $0x5, %r14d
addq %r14, %rbx
cmpq -0xe8(%rbp), %rbx
leaq -0x158(%rbp), %r14
je 0x3f52
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq -0x60(%rbp), %rdi
callq 0x2090
addq $0x20, %rbx
cmpq -0xe8(%rbp), %rbx
jne 0x3f35
leaq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4d94
leaq -0x118(%rbp), %rdi
movq %r14, %rsi
movq -0x40(%rbp), %rdx
callq 0x2cfa
movq -0x70(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4bc2
movq %rax, %rdi
leaq -0x118(%rbp), %rsi
callq 0x2290
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x3fbd
callq 0x21c0
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x4147
callq 0x21c0
jmp 0x4147
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0x58(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x401d
callq 0x21c0
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x4035
callq 0x21c0
movq (%r14), %rax
movslq (%rax,%r15), %rcx
shlq $0x2, %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %rbx, %rdi
leaq 0x7031(%rip), %rsi      # 0xb08f
callq 0x23b0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x70a4(%rip), %rsi      # 0xb127
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15), %rcx
shlq $0x2, %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq %rbx, %rdi
leaq 0x7075(%rip), %rsi      # 0xb12a
callq 0x23b0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x704d(%rip), %rsi      # 0xb127
callq 0x23b0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x40f4
callq 0x21c0
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x351b
callq 0x21c0
jmp 0x351b
leaq -0x60(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movq -0x70(%rbp), %rbx
movq %rbx, %rdx
callq 0x2928
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4bc2
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x2290
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4159
callq 0x21c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %rdi
movq 0x8(%rdi), %rsi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
movq -0x70(%rbp), %r14
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
leaq -0x90(%rbp), %rsi
movq %r14, %rdx
callq 0x2928
movq %rbx, %rdi
leaq 0x6e79(%rip), %rsi      # 0xb01b
callq 0x2080
movl %eax, %ebx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
movq -0x38(%rbp), %r15
je 0x41bf
callq 0x21c0
testl %ebx, %ebx
je 0x4291
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
leaq -0x90(%rbp), %rsi
movq %r14, %rdx
callq 0x2928
movq %rbx, %rdi
leaq 0x6e34(%rip), %rsi      # 0xb01b
callq 0x2080
movl %eax, %ebx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4200
callq 0x21c0
testl %ebx, %ebx
movq -0x38(%rbp), %rbx
je 0x40df
cmpq -0x138(%rbp), %r13
jne 0x4233
movq %r14, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4bc2
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6ff1(%rip), %rsi      # 0xb22e
callq 0x23b0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6f16(%rip), %rsi      # 0xb178
callq 0x23b0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6ea0(%rip), %rsi      # 0xb127
callq 0x23b0
jmp 0x40df
movq -0xf0(%rbp), %rbx
movq %r14, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4bc2
leaq -0x118(%rbp), %r12
movq %r12, %rdi
leaq 0x6ea7(%rip), %rsi      # 0xb15f
movq %rax, %rdx
callq 0x4b36
movq %r12, %rdi
leaq 0x6f64(%rip), %rsi      # 0xb22e
callq 0x23b0
leaq -0x50(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x44d5
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x44db
addq $0xe0, %rbx
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x2110
movq -0x38(%rbp), %rdi
leaq 0x6de7(%rip), %rsi      # 0xb0ff
callq 0x23b0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x38(%rbp), %rdi
callq 0x2090
movq -0x38(%rbp), %rdi
leaq 0x6e37(%rip), %rsi      # 0xb176
callq 0x23b0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6d9a(%rip), %rsi      # 0xb0fe
callq 0x23b0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6df3(%rip), %rsi      # 0xb176
callq 0x23b0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0x38(%rbp), %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6d58(%rip), %rsi      # 0xb101
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rbx
shlq $0x2, %rbx
movq -0x38(%rbp), %rdi
movq 0x8(%rdi), %rsi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23a0
movq -0x38(%rbp), %rdi
leaq 0x6f32(%rip), %rsi      # 0xb313
callq 0x23b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
leaq (%rax,%r12,8), %rcx
addq $0x48, %rcx
movl -0x28(%rcx), %eax
movq -0x40(%rbp), %r14
incq %r14
leaq 0x28(%rcx), %rdx
cmpl %eax, (%rcx)
movq %rdx, %rcx
jg 0x43fc
leaq -0x108(%rbp), %rax
movq %rax, -0x118(%rbp)
movq $0x0, -0x110(%rbp)
movb $0x0, -0x108(%rbp)
movq -0x40(%rbp), %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
leaq -0x1(%r14), %rsi
movq -0x30(%rbp), %rdx
leaq -0x118(%rbp), %rcx
movq -0xf8(%rbp), %r8
movq -0x70(%rbp), %r9
callq 0x2ef8
movq -0x38(%rbp), %r15
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23a0
movq %r15, %rdi
leaq 0x6e8e(%rip), %rsi      # 0xb32b
callq 0x23b0
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x44ba
callq 0x21c0
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x33f8
callq 0x21c0
jmp 0x33f8
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0x58(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6c54(%rip), %rsi      # 0xb176
callq 0x23b0
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4539
callq 0x21c0
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x4551
callq 0x21c0
addq $0x60, %rbx
movq %rbx, %rdi
leaq 0x6c06(%rip), %rsi      # 0xb165
callq 0x2080
testl %eax, %eax
je 0x41c7
movq %rbx, %rdi
leaq 0x6bf1(%rip), %rsi      # 0xb167
callq 0x2080
testl %eax, %eax
je 0x45e4
movq %rbx, %rdi
leaq 0x6aea(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x45e4
movq %r15, %rdi
leaq 0x6c81(%rip), %rsi      # 0xb21d
callq 0x23b0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6ba8(%rip), %rsi      # 0xb169
callq 0x23b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6b96(%rip), %rsi      # 0xb175
callq 0x23b0
addq $0x20, %rbx
jmp 0x4555
movq -0xf8(%rbp), %r14
leaq 0x20(%r14), %rdi
movq 0x28(%r14), %rdx
leaq 0x6c1b(%rip), %rcx      # 0xb21e
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2310
movq -0xf0(%rbp), %rsi
addq $0x20, %rsi
movq %r14, %rdi
callq 0x2110
movq -0xf0(%rbp), %r13
leaq 0x6b35(%rip), %rbx      # 0xb163
movq %r13, %rdi
addq $0x20, %r13
movq %rbx, %rsi
callq 0x2080
testl %eax, %eax
jne 0x462e
movq -0xf0(%rbp), %rbx
addq $0x60, %rbx
leaq 0x40(%r14), %rax
movq %rax, -0x120(%rbp)
leaq -0x198(%rbp), %r14
leaq -0x90(%rbp), %r15
leaq -0xd0(%rbp), %r12
movq %rbx, %rdi
leaq 0x69fd(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x4748
movq %rbx, %rdi
leaq 0x698c(%rip), %rsi      # 0xb019
callq 0x2080
testl %eax, %eax
je 0x2f6d
leaq -0x188(%rbp), %rax
movq %rax, -0x198(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4d94
movq %r15, %rdi
movq %r14, %rsi
movq -0x40(%rbp), %rdx
callq 0x2cfa
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4c8e
movq -0x120(%rbp), %rdi
movq %r12, %rsi
callq 0x5742
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0x46ff
callq 0x21c0
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x4717
callq 0x21c0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x472c
callq 0x21c0
movq -0x198(%rbp), %rdi
leaq -0x188(%rbp), %rax
cmpq %rax, %rdi
je 0x4744
callq 0x21c0
addq $0x20, %r13
addq $0x20, %rbx
jmp 0x466c
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x38(%rbp), %r14
movq 0x8(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23a0
leaq 0x692b(%rip), %rsi      # 0xb0ab
movq %r14, %rdi
callq 0x23b0
leaq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
movq %rax, (%rdi)
leaq 0x6a7e(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e32
addq $0x20, %rbx
leaq 0x69b0(%rip), %r14      # 0xb163
leaq -0xd0(%rbp), %r15
movq -0xe8(%rbp), %r12
cmpq %r12, %rbx
je 0x47ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2080
testl %eax, %eax
je 0x47ea
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq $0x20, %rbx
movq %r15, %rdi
callq 0x2090
jmp 0x47ba
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x2090
leaq 0x691c(%rip), %rsi      # 0xb127
movq %r14, %rdi
callq 0x23b0
leaq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x2928
leaq 0x69ed(%rip), %rsi      # 0xb21e
leaq -0x90(%rbp), %r15
movq %r15, %rdi
callq 0x2080
movl %eax, %r14d
movq (%r15), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x4854
callq 0x21c0
testl %r14d, %r14d
je 0x489d
leaq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x2928
movq -0xf8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x90(%rbp), %rbx
movq %rbx, %rsi
callq 0x2290
movq (%rbx), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x48b9
callq 0x21c0
jmp 0x48b9
cmpq %r12, %rbx
je 0x48b9
addq $0x20, %rbx
movq -0xf8(%rbp), %rdi
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x2110
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x2fb3
callq 0x21c0
jmp 0x2fb3
movq 0xa6f7(%rip), %rdi      # 0xefd8
leaq 0x6828(%rip), %rsi      # 0xb110
movl $0x12, %edx
callq 0x2250
movq 0xa6df(%rip), %rdi      # 0xefd8
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x2350
movq %rax, %rdi
callq 0x20e0
xorl %edi, %edi
callq 0x2280
jmp 0x49b7
jmp 0x4a75
jmp 0x4ae4
movq %rax, %rbx
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x4941
callq 0x21c0
jmp 0x4941
movq %rax, %rbx
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
jmp 0x4a49
jmp 0x4a75
jmp 0x4ae4
jmp 0x4ae4
jmp 0x4b07
jmp 0x4ae4
jmp 0x4ae4
jmp 0x4ae4
jmp 0x49a0
jmp 0x4b07
jmp 0x4b00
jmp 0x49a0
jmp 0x49b7
jmp 0x4ae4
jmp 0x4ae4
jmp 0x4b07
jmp 0x4b00
jmp 0x4ae4
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x49ba
callq 0x21c0
jmp 0x49ba
movq %rax, %rbx
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
jmp 0x4a80
jmp 0x4ae4
jmp 0x4b00
jmp 0x4b07
jmp 0x4ae4
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x49fb
callq 0x21c0
jmp 0x49fb
movq %rax, %rbx
movq -0x178(%rbp), %rdi
leaq -0x168(%rbp), %rax
jmp 0x4a80
jmp 0x4ae4
jmp 0x4ae4
jmp 0x4ae4
jmp 0x4b00
jmp 0x4ae4
jmp 0x4ae4
jmp 0x4b07
jmp 0x4b00
jmp 0x4b00
movq %rax, %rbx
movq -0x118(%rbp), %rdi
leaq -0x108(%rbp), %rax
cmpq %rax, %rdi
je 0x4a78
callq 0x21c0
jmp 0x4a78
jmp 0x4b00
jmp 0x4a75
jmp 0x4ae4
jmp 0x4b07
jmp 0x4b07
jmp 0x4b00
jmp 0x4b00
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4ae7
callq 0x21c0
jmp 0x4ae7
jmp 0x4ae4
jmp 0x4b07
jmp 0x4b00
jmp 0x4ae4
jmp 0x4ae4
jmp 0x4b07
jmp 0x4b07
jmp 0x4b00
jmp 0x4ae4
jmp 0x4b00
jmp 0x4b00
movq %rax, %rbx
jmp 0x4ad0
movq %rax, %rbx
jmp 0x4abb
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x4cf8
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x4ad0
callq 0x21c0
movq -0x198(%rbp), %rdi
leaq -0x188(%rbp), %rax
jmp 0x4b18
jmp 0x4b00
jmp 0x4b00
movq %rax, %rbx
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x4b0a
callq 0x21c0
jmp 0x4b0a
jmp 0x4b00
movq %rax, %rbx
jmp 0x4b22
jmp 0x4b07
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x4b22
callq 0x21c0
leaq -0xf0(%rbp), %rdi
callq 0x4d2e
movq %rbx, %rdi
callq 0x2370