// File: /workspace/github_cpp_makefile_star2_O1/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, -0x90(%rbp)
movq %r8, -0xd8(%rbp)
movq %rcx, -0x30(%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, -0x38(%rbp)
addq (%rdx), %rdi
callq 0x2b6d
movq -0xf0(%rbp), %rdi
leaq 0x80c6(%rip), %rsi      # 0xb06f
callq 0x2080
testl %eax, %eax
je 0x47eb
movq -0xd8(%rbp), %rax
movq 0x40(%rax), %rbx
cmpq 0x48(%rax), %rbx
movq -0x90(%rbp), %r14
je 0x2ff9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c30
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
addq $0x20, %rbx
movq -0xd8(%rbp), %rax
cmpq 0x48(%rax), %rbx
jne 0x2fce
movq -0x40(%rbp), %rax
cmpq -0x130(%rbp), %rax
jbe 0x3024
leaq -0xf0(%rbp), %rdi
callq 0x4d9c
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%r14), %rax
movq %rax, -0x138(%rbp)
movq -0xd8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x118(%rbp)
movq -0xf0(%rbp), %rbx
movq -0xe8(%rbp), %r14
cmpq %rbx, %r14
je 0x3078
movq %rbx, %r15
movq (%r15), %rdi
addq $0x10, %r15
cmpq %r15, %rdi
je 0x3068
callq 0x21c0
addq $0x10, %r15
cmpq %r14, %r15
jne 0x3057
movq %rbx, -0xe8(%rbp)
movq -0x40(%rbp), %rax
leaq (%rax,%rax,4), %r12
leaq (,%r12,8), %rdi
movq -0x38(%rbp), %rax
addq (%rax), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2b6d
movq -0xf0(%rbp), %r14
movq %r14, %rdi
leaq 0x7fcb(%rip), %rsi      # 0xb077
callq 0x2080
testl %eax, %eax
je 0x3265
movq %r14, %rdi
leaq 0x7fb2(%rip), %rsi      # 0xb075
callq 0x2080
testl %eax, %eax
je 0x3265
movq %r14, %rdi
leaq 0x7faf(%rip), %rsi      # 0xb089
callq 0x2080
testl %eax, %eax
je 0x34af
movq %r14, %rdi
leaq 0x7fb3(%rip), %rsi      # 0xb0a4
callq 0x2080
testl %eax, %eax
je 0x35a5
movq %r14, %rdi
leaq 0x7fab(%rip), %rsi      # 0xb0b3
callq 0x2080
testl %eax, %eax
je 0x36f7
movq %r14, %rdi
leaq 0x7f9f(%rip), %rsi      # 0xb0be
callq 0x2080
testl %eax, %eax
je 0x382a
movq %r14, %rdi
leaq 0x7f95(%rip), %rsi      # 0xb0cb
callq 0x2080
testl %eax, %eax
je 0x3a0c
movq %r14, %rdi
leaq 0x7f22(%rip), %rsi      # 0xb06f
callq 0x2080
testl %eax, %eax
je 0x3ce4
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xd0(%rbp), %rdi
callq 0x4df8
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x88(%rbp), %rdi
leaq 0x8087(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e92
leaq 0x20(%r14), %rdi
leaq 0x7f55(%rip), %rsi      # 0xb0ff
callq 0x2080
movl %eax, %r13d
xorl %ebx, %ebx
testl %eax, %eax
sete %r15b
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
leaq 0x7f37(%rip), %rdx      # 0xb106
callq 0x5a49
movb %r15b, %bl
shll $0x6, %ebx
addq %rbx, %r14
movq -0xe8(%rbp), %rcx
cmpq %rcx, %rax
je 0x3ee1
leaq -0x20(%rcx), %rax
movq %rax, -0xe8(%rbp)
movq -0x20(%rcx), %rdi
addq $-0x10, %rcx
cmpq %rcx, %rdi
je 0x320a
callq 0x21c0
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
leaq -0x88(%rbp), %rdi
callq 0x2090
movq -0x90(%rbp), %r12
addq $0x60, %r14
xorl %ebx, %ebx
movl $0x20, %r15d
movq %r14, %rdi
leaq 0x7f22(%rip), %rsi      # 0xb163
callq 0x2080
testl %eax, %eax
je 0x3ba3
incl %ebx
addq $0x20, %r14
addq $0x28, %r15
cmpl $0xf4240, %ebx          # imm = 0xF4240
jne 0x3237
jmp 0x495a
leaq 0x20(%r14), %r15
movq %r15, %rdi
leaq 0x7e07(%rip), %rsi      # 0xb07a
callq 0x2080
movl %eax, %ebx
leaq 0x40(%r14), %r13
testl %eax, %eax
cmovneq %r15, %r13
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0xd0(%rbp), %rdi
leaq 0x7f7e(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e92
testl %ebx, %ebx
jne 0x32bf
leaq -0xd0(%rbp), %rdi
leaq 0x7dc4(%rip), %rsi      # 0xb07e
callq 0x23c0
movq -0xe8(%rbp), %rax
addq $-0x20, %rax
cmpq %rax, %r13
je 0x32ec
leaq 0x20(%r13), %rbx
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq -0xd0(%rbp), %rdi
callq 0x2090
movq %rbx, %r13
jmp 0x32bf
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %r15
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq %r14, %rdi
leaq 0x7d59(%rip), %rsi      # 0xb077
callq 0x2080
testl %eax, %eax
leaq 0x7d54(%rip), %rsi      # 0xb080
leaq 0x7d52(%rip), %rax      # 0xb085
cmoveq %rax, %rsi
movq %r15, %rdi
callq 0x23c0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
movq %r15, %rdi
leaq 0x7da4(%rip), %rsi      # 0xb103
callq 0x23c0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq -0x38(%rbp), %r14
movq (%r14), %rax
movslq 0x20(%rax,%r12,8), %rbx
movq %r15, %rdi
leaq 0x7f75(%rip), %rsi      # 0xb313
callq 0x23c0
movq (%r14), %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 0x33b5
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x0, -0x80(%rbp)
movb $0x0, -0x78(%rbp)
movq -0x40(%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 -0x88(%rbp), %rcx
movq -0xd8(%rbp), %r8
movq -0x90(%rbp), %r9
callq 0x2f41
movq -0x30(%rbp), %r15
movq -0x88(%rbp), %rsi
movq -0x80(%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 0x23b0
movq %r15, %rdi
leaq 0x7eda(%rip), %rsi      # 0xb32b
callq 0x23c0
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x346b
callq 0x21c0
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x3483
callq 0x21c0
movl $0xb, %eax
movq %r14, -0x40(%rbp)
cmpl $0xb, %eax
je 0x3499
testl %eax, %eax
jne 0x3006
movq -0x40(%rbp), %rax
cmpq -0x130(%rbp), %rax
jbe 0x3041
jmp 0x3006
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %r15
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq %r15, %rdi
leaq 0x7bae(%rip), %rsi      # 0xb08f
callq 0x23c0
addq $0x20, %r14
cmpq -0xe8(%rbp), %r14
je 0x3588
movl $0x1, %ebx
movq %r14, %rdi
leaq 0x7bc3(%rip), %rsi      # 0xb0c9
callq 0x2080
testl %eax, %eax
je 0x3522
movq %r14, %rdi
leaq 0x7b00(%rip), %rsi      # 0xb019
callq 0x2080
testl %eax, %eax
jne 0x352b
xorl %eax, %eax
testl %ebx, %ebx
sete %al
movl %eax, %ebx
testl %ebx, %ebx
je 0x3542
movq %r14, %rdi
leaq 0x7b3a(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x3551
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2090
testl %ebx, %ebx
je 0x3577
movq %r14, %rdi
leaq 0x7b14(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
jne 0x3577
movq %r15, %rdi
leaq 0x7b29(%rip), %rsi      # 0xb09b
callq 0x23c0
addq $0x20, %r14
cmpq -0xe8(%rbp), %r14
jne 0x34fc
movq %r15, %rdi
leaq 0x7b95(%rip), %rsi      # 0xb127
callq 0x23c0
incq -0x40(%rbp)
movl $0xb, %eax
jmp 0x348c
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq %rbx, %rdi
leaq 0x7ad4(%rip), %rsi      # 0xb0ab
callq 0x23c0
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0xd0(%rbp), %rdi
leaq 0x7c26(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e92
addq $0x20, %r14
movq -0x90(%rbp), %r12
movq -0xe8(%rbp), %r15
cmpq %r15, %r14
je 0x3643
movq %r14, %rdi
leaq 0x7b42(%rip), %rsi      # 0xb163
callq 0x2080
testl %eax, %eax
je 0x3643
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq $0x20, %r14
leaq -0xd0(%rbp), %rdi
callq 0x2090
jmp 0x360b
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x2090
movq -0x30(%rbp), %rdi
leaq 0x7ac2(%rip), %rsi      # 0xb127
callq 0x23c0
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
movq %r12, %rdx
callq 0x293e
movq %rbx, %rdi
leaq 0x7b91(%rip), %rsi      # 0xb21e
callq 0x2080
movl %eax, %ebx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x36a9
callq 0x21c0
testl %ebx, %ebx
je 0x39d2
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
movq %r12, %rdx
callq 0x293e
movq -0x118(%rbp), %rdi
movq %rbx, %rsi
callq 0x2290
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x39ea
callq 0x21c0
jmp 0x39ea
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq %rbx, %rdi
leaq 0x798f(%rip), %rsi      # 0xb0b8
callq 0x23c0
movq -0x38(%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 0x23b0
movq %rbx, %rdi
leaq 0x7bb7(%rip), %rsi      # 0xb313
callq 0x23c0
movq -0x38(%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 0x3778
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 -0x38(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0xd8(%rbp), %r8
movq -0x90(%rbp), %r9
callq 0x2f41
movq -0x30(%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 0x23b0
movq %r15, %rdi
leaq 0x7b0b(%rip), %rsi      # 0xb32b
callq 0x23c0
jmp 0x346b
leaq 0x20(%r14), %r15
movq %r15, %rdi
leaq 0x7842(%rip), %rsi      # 0xb07a
callq 0x2080
movl %eax, %ebx
addq $0x40, %r14
testl %eax, %eax
cmovneq %r15, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %r15
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq %r15, %rdi
leaq 0x7849(%rip), %rsi      # 0xb0c4
callq 0x23c0
testl %ebx, %ebx
jne 0x38a9
movq %r15, %rdi
leaq 0x77f0(%rip), %rsi      # 0xb07e
callq 0x23c0
jmp 0x38a9
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq -0x30(%rbp), %rdi
callq 0x2090
addq $0x20, %r14
movq %r14, %rdi
leaq 0x78b0(%rip), %rsi      # 0xb163
callq 0x2080
testl %eax, %eax
jne 0x3895
movq -0x30(%rbp), %r14
movq %r14, %rdi
leaq 0x7839(%rip), %rsi      # 0xb103
callq 0x23c0
movq -0x38(%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 0x23b0
movq -0x38(%rbp), %r15
movq (%r15), %rax
movslq 0x20(%rax,%r12,8), %rbx
movq %r14, %rdi
leaq 0x7a0a(%rip), %rsi      # 0xb313
callq 0x23c0
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 0x3920
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 -0x38(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0xd8(%rbp), %r8
movq -0x90(%rbp), %r9
callq 0x2f41
movq -0x30(%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 0x23b0
movq %r15, %rdi
leaq 0x7963(%rip), %rsi      # 0xb32b
callq 0x23c0
jmp 0x346b
cmpq %r15, %r14
je 0x39ea
addq $0x20, %r14
movq -0x118(%rbp), %rdi
movq %r14, %rsi
callq 0x2110
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x3a02
callq 0x21c0
movl $0xa, %eax
jmp 0x348c
movq -0xf0(%rbp), %rbx
movq -0xe8(%rbp), %r15
cmpq %r15, %rbx
je 0x3cef
movq %r12, -0x120(%rbp)
xorl %r13d, %r13d
leaq 0x769b(%rip), %r12      # 0xb0cf
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2080
cmpl $0x1, %eax
adcq $0x0, %r13
addq $0x20, %rbx
cmpq %r15, %rbx
jne 0x3a34
testq %r13, %r13
movq -0x120(%rbp), %r12
je 0x3cef
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq %rbx, %rdi
leaq 0x765a(%rip), %rsi      # 0xb0eb
callq 0x23c0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x2090
leaq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0xd0(%rbp), %rdi
callq 0x4df8
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x88(%rbp), %rdi
leaq 0x7615(%rip), %rsi      # 0xb0f9
leaq 0x760f(%rip), %rdx      # 0xb0fa
callq 0x4e92
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x771b(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e92
leaq 0x60(%r14), %rdi
leaq 0x75b9(%rip), %rsi      # 0xb0cf
callq 0x2080
testl %eax, %eax
jne 0x450b
leaq 0x80(%r14), %rdi
leaq 0x7598(%rip), %rsi      # 0xb0c9
callq 0x2080
testl %eax, %eax
jne 0x450b
leaq 0xa0(%r14), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2110
leaq 0xc0(%r14), %rdi
leaq 0x7514(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x44f8
leaq -0x88(%rbp), %rdi
leaq 0x7581(%rip), %rsi      # 0xb0fb
callq 0x23c0
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x2110
leaq -0x88(%rbp), %rdi
leaq 0x7560(%rip), %rsi      # 0xb0f9
callq 0x22c0
jmp 0x450b
leaq -0x168(%rbp), %rax
movq %rax, -0x178(%rbp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x178(%rbp), %r14
movq %r14, %rdi
callq 0x4df8
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2d43
movq %r12, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4c30
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x2290
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x3c06
callq 0x21c0
movq -0x178(%rbp), %rdi
leaq -0x168(%rbp), %rax
cmpq %rax, %rdi
je 0x3c1e
callq 0x21c0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq %r12, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4c30
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x2090
movq %r12, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4c30
movq %rax, %rdi
leaq 0x73a4(%rip), %rsi      # 0xb020
callq 0x2080
testl %eax, %eax
je 0x4054
leaq -0x110(%rbp), %r14
movq %r14, %rdi
leaq 0x7594(%rip), %rsi      # 0xb22e
leaq -0xd0(%rbp), %rdx
callq 0x4ba5
movq -0x30(%rbp), %rbx
movq %r14, %rdi
leaq 0x7473(%rip), %rsi      # 0xb127
callq 0x23c0
leaq -0x50(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x40af
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x40b5
incq -0x40(%rbp)
xorl %eax, %eax
jmp 0x348c
movl $0x4, %edx
movq 0xb2dd(%rip), %rdi      # 0xefd8
leaq 0x73d3(%rip), %rsi      # 0xb0d5
callq 0x2250
movq -0x30(%rbp), %r14
movq -0xf0(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq 0xb2b7(%rip), %rdi      # 0xefd8
callq 0x2250
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x74f5(%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 0x74ba(%rip), %rsi      # 0xb21d
callq 0x2250
movq -0x38(%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 0x23b0
movq %r14, %rdi
leaq 0x7344(%rip), %rsi      # 0xb0da
callq 0x23c0
movq -0xf0(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x732b(%rip), %rsi      # 0xb0e7
callq 0x23c0
movq -0xf0(%rbp), %rcx
movq 0x60(%rcx), %rsi
movq 0x68(%rcx), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x7237(%rip), %rsi      # 0xb019
callq 0x23c0
movq -0x38(%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 0x23b0
movq %r14, %rdi
leaq 0x74fb(%rip), %rsi      # 0xb313
callq 0x23c0
movq -0x38(%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 0x3e33
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 -0x38(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movq -0xd8(%rbp), %r8
movq -0x90(%rbp), %r9
callq 0x2f41
movq -0x30(%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 0x23b0
movq %r15, %rdi
leaq 0x7454(%rip), %rsi      # 0xb32b
callq 0x23c0
jmp 0x346b
testl %r13d, %r13d
je 0x3f25
cmpq -0xe8(%rbp), %r14
je 0x3f41
leaq 0x20(%r14), %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x88(%rbp), %rdi
callq 0x2090
movq %rbx, %r14
jmp 0x3ee6
leaq 0x20(%r14), %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x88(%rbp), %rdi
callq 0x2090
movq %rbx, %r14
movq %r14, %rdi
leaq 0x7234(%rip), %rsi      # 0xb163
callq 0x2080
testl %eax, %eax
je 0x3f41
cmpq -0xe8(%rbp), %r14
jne 0x3f0b
movq %r12, -0x120(%rbp)
movq -0xe8(%rbp), %r12
movl %r13d, -0x124(%rbp)
testl %r13d, %r13d
jne 0x3fb2
cmpq %r12, %r14
jne 0x3fb2
movl $0x29, %edx
movq 0xb06c(%rip), %rdi      # 0xefd8
leaq 0x71c2(%rip), %rsi      # 0xb135
callq 0x2250
movq 0xb059(%rip), %rdi      # 0xefd8
movq -0x40(%rbp), %rsi
callq 0x2130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
xorl %ebx, %ebx
movq %r12, %r15
cmpq %r12, %r14
setne -0x61(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, %rdi
leaq -0x88(%rbp), %r13
movq %r13, %rsi
callq 0x273c
movq %r13, %rdi
movq %r12, %rsi
callq 0x2290
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x3ff1
callq 0x21c0
cmpl $0x0, -0x124(%rbp)
movq -0x120(%rbp), %r12
je 0x40e1
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %rbx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x70dd(%rip), %rsi      # 0xb127
callq 0x23c0
jmp 0x424b
leaq -0x110(%rbp), %r14
movq %r14, %rdi
leaq 0x71c9(%rip), %rsi      # 0xb22e
leaq -0xd0(%rbp), %rdx
callq 0x4ba5
movq -0x30(%rbp), %rbx
movq %r14, %rdi
leaq 0x70a4(%rip), %rsi      # 0xb123
callq 0x23c0
leaq -0x50(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4149
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x414f
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 0x4176
movq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x5b3c
movq %rax, %r13
cmpq %r15, %r14
je 0x4310
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x710b(%rip), %rdx      # 0xb21e
movq %rdx, %rsi
callq 0x4e92
movb -0x61(%rbp), %al
movb %al, %bl
shll $0x5, %ebx
addq %rbx, %r14
cmpq -0xe8(%rbp), %r14
je 0x4281
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x60(%rbp), %rdi
callq 0x2090
addq $0x20, %r14
jmp 0x4126
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 0x4188
callq 0x21c0
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x41a0
callq 0x21c0
movq -0x38(%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 0x23b0
movq %rbx, %rdi
leaq 0x6ec2(%rip), %rsi      # 0xb08f
callq 0x23c0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6f38(%rip), %rsi      # 0xb127
callq 0x23c0
movq -0x38(%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 0x23b0
movq %rbx, %rdi
leaq 0x6f09(%rip), %rsi      # 0xb12a
callq 0x23c0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6ee1(%rip), %rsi      # 0xb127
callq 0x23c0
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x4260
callq 0x21c0
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x3597
callq 0x21c0
jmp 0x3597
leaq -0x148(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
leaq -0x158(%rbp), %rbx
movq %rbx, %rdi
callq 0x4df8
leaq -0x110(%rbp), %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rdx
callq 0x2d43
movq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4c30
movq %rax, %rdi
leaq -0x110(%rbp), %rsi
callq 0x2290
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x42f6
callq 0x21c0
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x4345
callq 0x21c0
jmp 0x4345
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rbx
movq %rbx, %rdx
callq 0x293e
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4c30
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x2290
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4357
callq 0x21c0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rcx
shlq $0x2, %rcx
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rsi
xorl %edx, %edx
movl $0x20, %r8d
callq 0x23b0
movq -0x90(%rbp), %r15
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
leaq -0x88(%rbp), %rsi
movq %r15, %rdx
callq 0x293e
movq %rbx, %rdi
leaq 0x6c78(%rip), %rsi      # 0xb01b
callq 0x2080
movl %eax, %ebx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
movq -0x30(%rbp), %r12
je 0x43c0
callq 0x21c0
testl %ebx, %ebx
je 0x448f
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
leaq -0x88(%rbp), %rsi
movq %r15, %rdx
callq 0x293e
movq %rbx, %rdi
leaq 0x6c33(%rip), %rsi      # 0xb01b
callq 0x2080
movl %eax, %ebx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4401
callq 0x21c0
testl %ebx, %ebx
movq -0x30(%rbp), %rbx
je 0x424b
cmpq -0x138(%rbp), %r13
jne 0x4434
movq %r15, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4c30
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6df0(%rip), %rsi      # 0xb22e
callq 0x23c0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6d15(%rip), %rsi      # 0xb178
callq 0x23c0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x6ca2(%rip), %rsi      # 0xb127
callq 0x23c0
jmp 0x424b
movq -0xf0(%rbp), %r14
movq %r15, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x4c30
leaq -0x110(%rbp), %rbx
movq %rbx, %rdi
leaq 0x6ca9(%rip), %rsi      # 0xb15f
movq %rax, %rdx
callq 0x4ba5
movq %rbx, %rdi
leaq 0x6d66(%rip), %rsi      # 0xb22e
callq 0x23c0
leaq -0x50(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x46d3
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x46d9
addq $0xe0, %r14
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x2110
movq -0x30(%rbp), %rdi
leaq 0x6be9(%rip), %rsi      # 0xb0ff
callq 0x23c0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x2090
movq -0x30(%rbp), %rdi
leaq 0x6c3c(%rip), %rsi      # 0xb176
callq 0x23c0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6b9f(%rip), %rsi      # 0xb0fe
callq 0x23c0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6bf8(%rip), %rsi      # 0xb176
callq 0x23c0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6b5d(%rip), %rsi      # 0xb101
callq 0x23c0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x20(%rax,%r12,8), %rbx
shlq $0x2, %rbx
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rsi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23b0
movq -0x30(%rbp), %rdi
leaq 0x6d37(%rip), %rsi      # 0xb313
callq 0x23c0
movq -0x38(%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 0x45f7
leaq -0x100(%rbp), %rax
movq %rax, -0x110(%rbp)
movq $0x0, -0x108(%rbp)
movb $0x0, -0x100(%rbp)
movq -0x40(%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 -0x110(%rbp), %rcx
movq -0xd8(%rbp), %r8
movq -0x90(%rbp), %r9
callq 0x2f41
movq -0x30(%rbp), %r15
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
movq %r15, %rdi
callq 0x2090
movq 0x8(%r15), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movl $0x20, %r8d
callq 0x23b0
movq %r15, %rdi
leaq 0x6c90(%rip), %rsi      # 0xb32b
callq 0x23c0
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x46b8
callq 0x21c0
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x3456
callq 0x21c0
jmp 0x3456
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 %r12, %rdi
callq 0x2090
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6a56(%rip), %rsi      # 0xb176
callq 0x23c0
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4737
callq 0x21c0
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x474f
callq 0x21c0
addq $0x60, %r14
movq %r14, %rdi
leaq 0x6a08(%rip), %rsi      # 0xb165
callq 0x2080
testl %eax, %eax
je 0x43c8
movq %r14, %rdi
leaq 0x69f3(%rip), %rsi      # 0xb167
callq 0x2080
testl %eax, %eax
je 0x47e2
movq %r14, %rdi
leaq 0x68ec(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x47e2
movq %r12, %rdi
leaq 0x6a83(%rip), %rsi      # 0xb21d
callq 0x23c0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x69aa(%rip), %rsi      # 0xb169
callq 0x23c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x6998(%rip), %rsi      # 0xb175
callq 0x23c0
addq $0x20, %r14
jmp 0x4753
movq -0xd8(%rbp), %rax
leaq 0x20(%rax), %rdi
movq 0x28(%rax), %rdx
leaq 0x6a1d(%rip), %rcx      # 0xb21e
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2310
movq -0xf0(%rbp), %rsi
addq $0x20, %rsi
movq -0xd8(%rbp), %rdi
callq 0x2110
movq -0xf0(%rbp), %r13
leaq 0x6933(%rip), %rbx      # 0xb163
movq %r13, %rdi
addq $0x20, %r13
movq %rbx, %rsi
callq 0x2080
testl %eax, %eax
jne 0x4830
movq -0xf0(%rbp), %r14
addq $0x60, %r14
movq -0xd8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x118(%rbp)
leaq -0x198(%rbp), %rbx
leaq -0x88(%rbp), %r15
leaq -0xd0(%rbp), %r12
movq %r14, %rdi
leaq 0x67f4(%rip), %rsi      # 0xb073
callq 0x2080
testl %eax, %eax
je 0x4951
movq %r14, %rdi
leaq 0x6783(%rip), %rsi      # 0xb019
callq 0x2080
testl %eax, %eax
je 0x2fb6
leaq -0x188(%rbp), %rax
movq %rax, -0x198(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4df8
movq %r15, %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rdx
callq 0x2d43
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4cfc
movq -0x118(%rbp), %rdi
movq %r12, %rsi
callq 0x57da
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0x4908
callq 0x21c0
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x4920
callq 0x21c0
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x4935
callq 0x21c0
movq -0x198(%rbp), %rdi
leaq -0x188(%rbp), %rax
cmpq %rax, %rdi
je 0x494d
callq 0x21c0
addq $0x20, %r13
addq $0x20, %r14
jmp 0x4875
movq 0xa677(%rip), %rdi      # 0xefd8
leaq 0x67a8(%rip), %rsi      # 0xb110
movl $0x12, %edx
callq 0x2250
movq 0xa65f(%rip), %rdi      # 0xefd8
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x2360
movq %rax, %rdi
callq 0x20e0
xorl %edi, %edi
callq 0x2280
jmp 0x4a28
jmp 0x4adc
jmp 0x4b53
movq %rax, %rbx
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x49c1
callq 0x21c0
jmp 0x49c1
movq %rax, %rbx
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
jmp 0x4ab0
jmp 0x4adc
jmp 0x4b53
jmp 0x4b53
jmp 0x4b53
jmp 0x4b53
jmp 0x4b53
jmp 0x4a11
jmp 0x4a11
jmp 0x4a28
jmp 0x4b53
jmp 0x4b53
jmp 0x4b53
jmp 0x4b76
jmp 0x4b71
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4a2b
callq 0x21c0
jmp 0x4a2b
movq %rax, %rbx
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
jmp 0x4ae7
jmp 0x4b53
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4a5d
callq 0x21c0
jmp 0x4a5d
movq %rax, %rbx
movq -0x178(%rbp), %rdi
leaq -0x168(%rbp), %rax
jmp 0x4ae7
jmp 0x4b53
jmp 0x4b53
jmp 0x4b53
jmp 0x4b53
jmp 0x4b71
jmp 0x4b53
jmp 0x4b53
jmp 0x4b76
jmp 0x4b71
jmp 0x4b71
movq %rax, %rbx
movq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rax
cmpq %rax, %rdi
je 0x4adf
callq 0x21c0
jmp 0x4adf
jmp 0x4b71
jmp 0x4adc
jmp 0x4b53
jmp 0x4b76
jmp 0x4b76
jmp 0x4b76
jmp 0x4b71
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4b56
callq 0x21c0
jmp 0x4b56
jmp 0x4b53
jmp 0x4b76
jmp 0x4b71
jmp 0x4b71
jmp 0x4b71
jmp 0x4b53
jmp 0x4b53
jmp 0x4b76
jmp 0x4b76
jmp 0x4b53
jmp 0x4b76
jmp 0x4b71
jmp 0x4b71
jmp 0x4b71
jmp 0x4b71
jmp 0x4b71
movq %rax, %rbx
jmp 0x4b41
movq %rax, %rbx
jmp 0x4b2c
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x4d66
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x4b41
callq 0x21c0
movq -0x198(%rbp), %rdi
leaq -0x188(%rbp), %rax
jmp 0x4b87
jmp 0x4b76
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x4b79
callq 0x21c0
jmp 0x4b79
jmp 0x4b71
jmp 0x4b76
movq %rax, %rbx
jmp 0x4b91
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
leaq -0xc0(%rbp), %rax
cmpq %rax, %rdi
je 0x4b91
callq 0x21c0
leaq -0xf0(%rbp), %rdi
callq 0x4d9c
movq %rbx, %rdi
callq 0x2380