// File: /workspace/github_cpp_makefile_star2_O2/MarkCBell[P]twister/./twister/kernel/manifold.cpp
// Function: initialise_manifold(manifold&, std::vector<annulus, std::allocator<annulus>>&, std::vector<rectangle, std::allocator<rectangle>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void initialise_manifold(manifold &M, 
	std::vector<annulus> &annuli,
	std::vector<rectangle> &rectangles,
	std::vector<std::string> &annulus_name,
	std::vector<std::string> &annulus_name_inverse,
	std::vector<std::string> &rectangle_name,
	std::vector<std::string> &rectangle_name_inverse,
	std::vector<std::string> &macro_name,
	std::vector<std::string> &macro,
	std::string surface_file_contents)
{
	// Check that we actually got the contents of a surface file.
	if (surface_file_contents.substr(0,24) != "# A Twister surface file")
		output_error("A surface file must start with \"# A Twister surface file\".");
	
	std::vector<std::string> surface_description;
	
	{
		size_t marker = 0;
		std::string parsed_line = "";
		surface_file_contents += "\n";  // We add one extra new line, just to make sure / our lives easier.
		for (std::string line = find_next_substring(surface_file_contents, "\n", marker); marker != 0; line = find_next_substring(surface_file_contents, "\n", marker))
		{
			size_t marker2 = 0;
			parsed_line += find_next_substring(line, comment, marker2);  // Remove comments.
			if ((count_substring(line, comment) != 0) && (parsed_line != ""))
			{
				std::string cleaned_line = remove_whitespace(parsed_line);  // Clean up the information that we got.
				if (cleaned_line != "") surface_description.push_back(cleaned_line);
				output_debugging("Parsed line: " + cleaned_line + "\n", 1);
				parsed_line = "";
			}
		}
	}
	
	if (surface_description.size() == 0) output_error("Empty surface description.");
	
	// Determine the number of cubes needed.
	// int num_cubes = atoi((char *) surface_description[0].c_str());
	
	// Determine the number of cubes needed by finding the largest cube number referenced.
	int num_cubes = 0;
	int size = int(surface_description.size());
	for (int i = 0; i < size; i++)
	{
		size_t marker = 0;
		std::string line = surface_description[i];
		
		// Get information about this line.
		std::string type = find_next_substring(line, delimiter, marker);
		if ((type == "annulus") || (type == "rectangle"))
		{
			std::string curve_name = find_next_substring(line, delimiter, marker);
			std::string curve_name_inverse = find_next_substring(line, delimiter, marker);
			
			int sq_num = count_substring(line, delimiter) - 2;  // How many squares there are in this curve.
			if (sq_num < 1) output_error("Invalid curve description.");
			
			// Build the chain.
			for (int j = 0; j < sq_num; j++)
			{
				std::string cube_description = find_next_substring(line, delimiter, marker);
				
				bool orientation = true;
				int number = extract_info(cube_description, orientation);
				if (number+1 >  num_cubes)
					num_cubes = number + 1;
			}
		}
	}
	
	if (num_cubes == 0) output_error("No cubes requested.");
	
	for (int i = 0; i < num_cubes; i++)
		M.cubes.push_back(new cube(M));
	
	// If the manifold we're in is a surface bundle, close
	// up the cube (top to bottom) to get a solid torus. 
	if (M.get_manifold_type() == bundle)
		for (int i = 0; i < num_cubes; i++)
			M.cubes[i]->closeup_cube();
	
	// For storing the information needed to calculate the boundary component
	// indices of the rectangle names.
	std::vector<int> first_number, last_number;  // The first / last cube number of the thickened rectangles.
	std::vector<bool> first_orientation, last_orientation;  // The first / last cube orientations of the thickened rectangles.
	
	std::vector<bool> glued_edges (4*num_cubes, false);
	std::vector<int> vertex_indices;
	vertex_indices.reserve(4*num_cubes);
	for (int i = 0; i < 4*num_cubes; i++)
		vertex_indices.push_back(i);
	
	// Read in each line.
	for (int i = 0; i < size; i++)
	{
		size_t marker = 0;
		std::string line = surface_description[i];
		
		// Get information about this line.
		std::string type = find_next_substring(line, delimiter, marker);
		
		// We extract lines labelled "macro" - these are for parsing shortcuts.
		if (type == "macro")
		{
			macro_name.push_back(find_next_substring(line, delimiter, marker));  // curve_name
			macro.push_back(find_next_substring(line, delimiter, marker));  
		}
		else if ((type == "annulus") || (type == "rectangle"))
		{
			std::string curve_name = find_next_substring(line, delimiter, marker);
			std::string curve_name_inverse = find_next_substring(line, delimiter, marker);
			
			std::vector<int> chain_indices;
			std::vector<cube*> chain_cubes;
			std::vector<bool> chain_upright;
			
			int sq_num = count_substring(line, delimiter) - 2;  // How many squares there are in this curve.
			if (sq_num < 1) output_error("Invalid curve description.");
			chain_cubes.reserve(sq_num);
			chain_upright.reserve(sq_num);
			
			// Build the chain.
			for (int j = 0; j < sq_num; j++)
			{
				std::string cube_description = find_next_substring(line, delimiter, marker);
				
				bool orientation = true;
				int number = extract_info(cube_description, orientation);
				if (number >= num_cubes) output_error(curve_name + " uses a cube that does not exist.");
				chain_indices.push_back(number);
				chain_cubes.push_back(M.cubes[number]);
				chain_upright.push_back(orientation);
			}
			
			// Glue up the edges / vertices as needed.
			for (int j = 0; j < ((type == "annulus") ? sq_num : sq_num-1); j++)
			{
				glued_edges[4*chain_indices[j] + ((chain_upright[j]) ? 1 : 0)] = true;
				glued_edges[4*chain_indices[(j+1) % sq_num] + ((chain_upright[(j+1) % sq_num]) ? 3 : 2)] = true;
				
				int a = vertex_indices[4*chain_indices[j] + ((chain_upright[j]) ? 1 : 0)];
				int b = vertex_indices[4*chain_indices[(j+1) % sq_num] + ((chain_upright[(j+1) % sq_num]) ? 0 : 3)];
				
				// Replace max(a,b) with min(a,b).
				for (int k = 0; k < 4*num_cubes; k++)
					if (vertex_indices[k] == ((a < b) ? b : a)) vertex_indices[k] = ((a < b) ? a : b);
				
				a = vertex_indices[4*chain_indices[j] + ((chain_upright[j]) ? 2 : 1)];
				b = vertex_indices[4*chain_indices[(j+1) % sq_num] + ((chain_upright[(j+1) % sq_num]) ? 3 : 2)];
				
				// Replace max(a,b) with min(a,b).
				for (int k = 0; k < 4*num_cubes; k++)
					if (vertex_indices[k] == ((a < b) ? b : a)) vertex_indices[k] = ((a < b) ? a : b);
			}
			
			// Store it according to its type.
			if (type == "annulus")
			{
				annulus_name.push_back(curve_name);
				annulus_name_inverse.push_back(curve_name_inverse);
				annuli.push_back(annulus(chain_cubes, chain_upright));
			}
			else if (type == "rectangle")
			{
				rectangle_name.push_back(curve_name);
				rectangle_name_inverse.push_back(curve_name_inverse);
				rectangles.push_back(rectangle(chain_cubes, chain_upright));
				
				// Push the first / last cube info onto the relevant lists.
				first_orientation.push_back(chain_upright[0]);
				first_number.push_back(chain_indices[0]);
				last_orientation.push_back(chain_upright[sq_num-1]);
				last_number.push_back(chain_indices[sq_num-1]);
			}
		}
		else
		{
			output_error("Invalid curve or macro description.");
		}
	}
	
	// Now we collate together all of the gluing information to determine the
	// boundary component index of each unglued edge.
	std::vector<int> boundary_index (4*num_cubes, -1);
	int boundary_components = 0;
	for (int i = 0; i < 4*num_cubes; i++)
	{
		if (glued_edges[i]) continue;
		if (boundary_index[i] != -1) continue;
		
		int start_index = vertex_indices[i];
		int current_index = start_index;
		do
		{
			for (int j = 0; j < 4*num_cubes; j++)
			{
				if (glued_edges[j]) continue;
				if (boundary_index[j] != -1) continue;
				if (vertex_indices[j] != current_index) continue;
				
				current_index = vertex_indices[j + ((j % 4 == 3) ? -3 : 1)];  // Move on to the next vertex
				boundary_index[j] = boundary_components;  // Remember to write down the boundary index for that component.
				break;
			}
		} while (current_index != start_index);
		boundary_components++;
	}
	
	// Create the needed marked points.
	for (int i = 0; i < boundary_components; i++)
		M.marked_points.push_back(half_twisted);
	
	// Set the front and back boundary component indices of each rectangle.
	for (int i = 0; i < int(rectangles.size()); i++)
	{
		rectangles[i].set_front(boundary_index[4*first_number[i] + ((first_orientation[i]) ? 3 : 2)]);
		rectangles[i].set_back(boundary_index[4*last_number[i] + ((last_orientation[i]) ? 1 : 0)]);
		rectangles[i].set_one_ended(rectangles[i].get_front() == rectangles[i].get_back());
	}
	
	// Collate all names together.
	std::vector<std::string> arc_names;
	arc_names.insert(arc_names.end(), annulus_name.begin(), annulus_name.end());
	arc_names.insert(arc_names.end(), annulus_name_inverse.begin(), annulus_name_inverse.end());
	arc_names.insert(arc_names.end(), rectangle_name.begin(), rectangle_name.end());
	arc_names.insert(arc_names.end(), rectangle_name_inverse.begin(), rectangle_name_inverse.end());
	arc_names.insert(arc_names.end(), macro_name.begin(), macro_name.end());
	
	// And check that they are a valid collection of names.
	check_valid_names(arc_names);
	
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7e8, %rsp            # imm = 0x7E8
movq %r9, 0x170(%rsp)
movq %r8, 0x178(%rsp)
movq %rcx, 0x180(%rsp)
movq %rdx, 0xf8(%rsp)
movq %rsi, 0x210(%rsp)
movq %rdi, 0x70(%rsp)
movq 0x838(%rsp), %r14
leaq 0x48(%rsp), %rbx
pushq $0x18
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3260
leaq 0xd066(%rip), %rsi      # 0x110b0
movq %rbx, %rdi
callq 0x62e5
movl %eax, %ebx
leaq 0x48(%rsp), %rdi
callq 0x3458
testb %bl, %bl
je 0x4095
leaq 0xd060(%rip), %rsi      # 0x110c9
leaq 0x3c8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x3e82
leaq 0x3c8(%rsp), %rdi
callq 0x3dec
leaq 0x3c8(%rsp), %rdi
callq 0x3458
xorps %xmm0, %xmm0
andq $0x0, 0x140(%rsp)
movaps %xmm0, 0x130(%rsp)
andq $0x0, 0x90(%rsp)
leaq 0xd256(%rip), %rsi      # 0x1130f
leaq 0x48(%rsp), %rdi
leaq 0x108(%rsp), %rdx
callq 0x3e82
leaq 0xcf8d(%rip), %rsi      # 0x1105f
movq %r14, %rdi
callq 0x3400
leaq 0x3a8(%rsp), %rdi
movq %r14, %rsi
callq 0x32e0
leaq 0xcf6e(%rip), %rsi      # 0x1105f
leaq 0x388(%rsp), %rdi
leaq 0x1a8(%rsp), %rdx
callq 0x3e82
leaq 0x108(%rsp), %rdi
leaq 0x3a8(%rsp), %rsi
leaq 0x388(%rsp), %rdx
leaq 0x90(%rsp), %rcx
callq 0x8133
leaq 0x388(%rsp), %rdi
callq 0x3458
leaq 0x3a8(%rsp), %rdi
callq 0x3458
leaq 0x7c8(%rsp), %r12
leaq 0x1a8(%rsp), %rbp
leaq 0x768(%rsp), %r15
leaq 0x20(%rsp), %rbx
cmpq $0x0, 0x90(%rsp)
je 0x4398
andq $0x0, 0xd8(%rsp)
leaq 0x368(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x32e0
movq %r12, %r13
movq %r12, %rdi
leaq 0x1522c(%rip), %rsi     # 0x193c8
callq 0x32e0
movq %rbp, %rdi
leaq 0x368(%rsp), %rsi
movq %r13, %rdx
leaq 0xd8(%rsp), %rcx
callq 0x8133
leaq 0x48(%rsp), %rdi
movq %rbp, %rsi
callq 0x3420
movq %rbp, %rdi
callq 0x3458
movq %r12, %rdi
callq 0x3458
leaq 0x368(%rsp), %rdi
callq 0x3458
leaq 0x288(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x32e0
leaq 0x348(%rsp), %r13
movq %r13, %rdi
leaq 0x151bb(%rip), %rsi     # 0x193c8
callq 0x32e0
leaq 0x288(%rsp), %rdi
movq %r13, %rsi
callq 0x80f9
testl %eax, %eax
je 0x430c
leaq 0x48(%rsp), %rdi
leaq 0xd0d9(%rip), %rsi      # 0x1130f
callq 0x62e5
movl %eax, %r13d
leaq 0x348(%rsp), %rdi
callq 0x3458
leaq 0x288(%rsp), %rdi
callq 0x3458
testb %r13b, %r13b
je 0x4326
leaq 0x7a8(%rsp), %r13
movq %r13, %rdi
leaq 0x48(%rsp), %rsi
callq 0x32e0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x81d5
movq %r13, %rdi
callq 0x3458
movq %rbp, %rdi
leaq 0xd07c(%rip), %rsi      # 0x1130f
callq 0x62e5
testb %al, %al
je 0x42ac
leaq 0x130(%rsp), %rdi
movq %rbp, %rsi
callq 0x62f0
movq %rbx, %r13
movq %rbx, %rdi
leaq 0xce4b(%rip), %rsi      # 0x11104
movq %rbp, %rdx
callq 0x3ebd
leaq 0x788(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
leaq 0xcd89(%rip), %rdx      # 0x1105f
callq 0x3f33
movq %r14, %rdi
pushq $0x1
popq %rsi
callq 0x3d1a
movq %r14, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
leaq 0x48(%rsp), %rdi
leaq 0xd00d(%rip), %rsi      # 0x1130f
callq 0x3410
movq %rbp, %rdi
jmp 0x4321
leaq 0x348(%rsp), %rdi
callq 0x3458
leaq 0x288(%rsp), %rdi
callq 0x3458
leaq 0x568(%rsp), %rdi
movq 0x838(%rsp), %rsi
callq 0x32e0
movq %r15, %rdi
leaq 0xcd1a(%rip), %rsi      # 0x1105f
movq %rbx, %rdx
callq 0x3e82
movq %rbp, %rdi
leaq 0x568(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
leaq 0x90(%rsp), %rcx
callq 0x8133
leaq 0x108(%rsp), %rdi
movq %rbp, %rsi
callq 0x32a0
movq %rbp, %rdi
callq 0x3458
movq %r15, %rdi
callq 0x3458
movq %r14, %rdi
callq 0x3458
jmp 0x4162
leaq 0x108(%rsp), %rdi
callq 0x3458
leaq 0x48(%rsp), %rdi
callq 0x3458
movq 0x130(%rsp), %rax
movq 0x138(%rsp), %rcx
cmpq %rax, %rcx
jne 0x4407
leaq 0xcd47(%rip), %rsi      # 0x11112
leaq 0x328(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x3e82
leaq 0x328(%rsp), %rdi
callq 0x3dec
leaq 0x328(%rsp), %rdi
callq 0x3458
movq 0x130(%rsp), %rax
movq 0x138(%rsp), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movq %rcx, 0x188(%rsp)
leaq 0x90(%rsp), %r14
leaq 0x6a8(%rsp), %r13
leaq 0x688(%rsp), %rbp
xorl %esi, %esi
movq $0x0, 0x10(%rsp)
cmpq 0x188(%rsp), %rsi
je 0x4725
andq $0x0, 0xd8(%rsp)
movq %rsi, 0x18(%rsp)
shlq $0x5, %rsi
addq 0x130(%rsp), %rsi
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x32e0
leaq 0x548(%rsp), %rdi
movq %rbx, %rsi
callq 0x32e0
leaq 0x748(%rsp), %r15
movq %r15, %rdi
leaq 0x14f11(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x108(%rsp), %r12
movq %r12, %rdi
leaq 0x548(%rsp), %rbx
movq %rbx, %rsi
movq %r15, %rdx
leaq 0xd8(%rsp), %rcx
callq 0x8133
movq %r15, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
movq %r12, %rdi
leaq 0xcc51(%rip), %rsi      # 0x1112d
callq 0x631c
testb %al, %al
jne 0x4501
leaq 0x108(%rsp), %rdi
leaq 0xcc41(%rip), %rsi      # 0x11135
callq 0x631c
testb %al, %al
je 0x4701
leaq 0x528(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x32e0
leaq 0x728(%rsp), %r15
movq %r15, %rdi
leaq 0x14e83(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x1a8(%rsp), %rdi
leaq 0x528(%rsp), %rbx
movq %rbx, %rsi
movq %r15, %rdx
leaq 0xd8(%rsp), %rcx
callq 0x8133
movq %r15, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
leaq 0x508(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x32e0
leaq 0x708(%rsp), %r15
movq %r15, %rdi
leaq 0x14e27(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x20(%rsp), %rdi
leaq 0x508(%rsp), %rbx
movq %rbx, %rsi
movq %r15, %rdx
leaq 0xd8(%rsp), %rcx
callq 0x8133
movq %r15, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
leaq 0x4e8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x32e0
leaq 0x6e8(%rsp), %r12
movq %r12, %rdi
leaq 0x14dce(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x4e8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x80f9
movl %eax, %r15d
movq %r12, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
cmpl $0x2, %r15d
jg 0x4635
leaq 0x6c8(%rsp), %rbx
movq %rbx, %rdi
leaq 0xcb22(%rip), %rsi      # 0x1113f
movq %r14, %rdx
callq 0x3e82
movq %rbx, %rdi
callq 0x3dec
movq %rbx, %rdi
callq 0x3458
addl $-0x2, %r15d
testl %r15d, %r15d
movl $0x0, %eax
cmovlel %eax, %r15d
subl $0x1, %r15d
leaq 0x48(%rsp), %rsi
jb 0x46ea
leaq 0x4c8(%rsp), %rdi
callq 0x32e0
movq %r13, %rdi
leaq 0x14d3d(%rip), %rsi     # 0x193a8
callq 0x32e0
movq %r14, %rdi
leaq 0x4c8(%rsp), %rbx
movq %rbx, %rsi
movq %r13, %rdx
leaq 0xd8(%rsp), %rcx
callq 0x8133
movq %r13, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
movb $0x1, 0x228(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x32e0
movq %rbp, %rdi
leaq 0x228(%rsp), %rsi
callq 0x817f
movl %eax, %ebx
movq %rbp, %rdi
callq 0x3458
leal 0x1(%rbx), %eax
movq 0x10(%rsp), %rcx
cmpl %ecx, %ebx
cmovgel %eax, %ecx
movq %rcx, 0x10(%rsp)
movq %r14, %rdi
callq 0x3458
jmp 0x4645
leaq 0x20(%rsp), %rdi
callq 0x3458
leaq 0x1a8(%rsp), %rdi
callq 0x3458
leaq 0x108(%rsp), %rdi
callq 0x3458
leaq 0x48(%rsp), %rdi
callq 0x3458
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x4440
movq 0x10(%rsp), %r13
testl %r13d, %r13d
jne 0x4762
leaq 0xca24(%rip), %rsi      # 0x1115a
leaq 0x308(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x3e82
leaq 0x308(%rsp), %rdi
callq 0x3dec
leaq 0x308(%rsp), %rdi
callq 0x3458
xorl %r12d, %r12d
testl %r13d, %r13d
cmovgl %r13d, %r12d
movq 0x70(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x100(%rsp)
pushq $0x40
popq %rbx
leaq 0x48(%rsp), %r14
movl %r12d, %ebp
subl $0x1, %ebp
jb 0x47c0
movq %rbx, %rdi
callq 0x3240
movq %rax, %r15
movq %rax, %rdi
movq 0x70(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa926
movq %r15, 0x48(%rsp)
movq 0x100(%rsp), %rdi
movq %r14, %rsi
callq 0x6a7c
jmp 0x4788
movq 0x70(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x47ef
movl %r12d, %ebx
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x47ef
movq 0x100(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r14,8), %rdi
callq 0x632a
incq %r14
jmp 0x47d1
andq $0x0, 0x200(%rsp)
andq $0x0, 0x1e0(%rsp)
andq $0x0, 0x48(%rsp)
andl $0x0, 0x50(%rsp)
andq $0x0, 0x58(%rsp)
andl $0x0, 0x60(%rsp)
andq $0x0, 0x68(%rsp)
andq $0x0, 0x108(%rsp)
andl $0x0, 0x110(%rsp)
andq $0x0, 0x118(%rsp)
xorps %xmm0, %xmm0
andl $0x0, 0x120(%rsp)
movaps %xmm0, 0x1f0(%rsp)
andq $0x0, 0x128(%rsp)
movaps %xmm0, 0x1d0(%rsp)
leal (,%r13,4), %r14d
leaq 0x20(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x1a8(%rsp), %rdi
leaq 0x90(%rsp), %rcx
movq %r14, %rsi
callq 0x63ae
leaq 0x150(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x6412
xorl %eax, %eax
leaq 0x150(%rsp), %rbx
leaq 0x20(%rsp), %r15
movl %eax, 0x20(%rsp)
cmpl %r14d, %eax
jge 0x48c9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64a8
movl 0x20(%rsp), %eax
incl %eax
jmp 0x48ad
xorl %esi, %esi
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
leaq 0x2a8(%rsp), %r12
cmpq 0x188(%rsp), %rsi
je 0x51b1
andq $0x0, 0x80(%rsp)
movq %rsi, 0x218(%rsp)
shlq $0x5, %rsi
addq 0x130(%rsp), %rsi
leaq 0xd8(%rsp), %rbx
movq %rbx, %rdi
callq 0x32e0
leaq 0x4a8(%rsp), %rdi
movq %rbx, %rsi
callq 0x32e0
leaq 0x668(%rsp), %rbp
movq %rbp, %rdi
leaq 0x14a6b(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x228(%rsp), %r15
movq %r15, %rdi
leaq 0x4a8(%rsp), %rbx
movq %rbx, %rsi
movq %rbp, %rdx
leaq 0x80(%rsp), %rcx
callq 0x8133
movq %rbp, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
movq %r15, %rdi
leaq 0xc7ec(%rip), %rsi      # 0x1116e
callq 0x631c
testb %al, %al
je 0x4a89
leaq 0x2e8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x32e0
leaq 0x488(%rsp), %r15
movq %r15, %rdi
leaq 0x149f2(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x80(%rsp), %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
leaq 0x2e8(%rsp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x8133
movq 0x828(%rsp), %rdi
movq %rbp, %rsi
callq 0x6ea6
movq %rbp, %rdi
callq 0x3458
leaq 0x488(%rsp), %rdi
callq 0x3458
leaq 0x2e8(%rsp), %rdi
callq 0x3458
leaq 0x2c8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x32e0
leaq 0x468(%rsp), %rbp
movq %rbp, %rdi
leaq 0x14971(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
leaq 0x2c8(%rsp), %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x8133
movq 0x830(%rsp), %rdi
movq %r15, %rsi
callq 0x6ea6
movq %r15, %rdi
callq 0x3458
leaq 0x468(%rsp), %rdi
callq 0x3458
leaq 0x2c8(%rsp), %rdi
jmp 0x5182
movq %r15, %rdi
leaq 0xc69a(%rip), %rsi      # 0x1112d
callq 0x631c
testb %al, %al
jne 0x4ab8
leaq 0x228(%rsp), %rdi
leaq 0xc68a(%rip), %rsi      # 0x11135
callq 0x631c
testb %al, %al
je 0x515b
leaq 0x448(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x32e0
leaq 0x648(%rsp), %rbp
movq %rbp, %rdi
leaq 0x148c9(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x80(%rsp), %rcx
leaq 0x248(%rsp), %rdi
leaq 0x448(%rsp), %rbx
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x8133
movq %rbp, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
leaq 0x428(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x32e0
leaq 0x628(%rsp), %rbp
movq %rbp, %rdi
leaq 0x1486a(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x268(%rsp), %rdi
leaq 0x428(%rsp), %rbx
movq %rbx, %rsi
movq %rbp, %rdx
leaq 0x80(%rsp), %rcx
callq 0x8133
movq %rbp, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
andq $0x0, 0xd0(%rsp)
andq $0x0, 0x1a0(%rsp)
andq $0x0, 0x20(%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xc0(%rsp)
andl $0x0, 0x38(%rsp)
movaps %xmm0, 0x190(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x408(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x32e0
leaq 0x608(%rsp), %rbp
movq %rbp, %rdi
leaq 0x147ca(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x408(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x80f9
movl %eax, %r15d
movq %rbp, %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x3458
movq %r15, 0x78(%rsp)
cmpl $0x2, %r15d
jg 0x4c43
leaq 0x5e8(%rsp), %rbx
movq %rbx, %rdi
leaq 0xc519(%rip), %rsi      # 0x1113f
leaq 0x90(%rsp), %rdx
callq 0x3e82
movq %rbx, %rdi
callq 0x3dec
movq %rbx, %rdi
callq 0x3458
movq 0x78(%rsp), %rax
addl $-0x2, %eax
movl %eax, 0x18(%rsp)
movslq %eax, %rbx
leaq 0x190(%rsp), %rdi
movq %rbx, %rsi
callq 0x64c6
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x655c
movl 0x18(%rsp), %eax
testl %eax, %eax
movl $0x0, %ebp
cmovgl %eax, %ebp
subl $0x1, %ebp
jb 0x4db0
leaq 0x3e8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x32e0
movq %r12, %rdi
leaq 0x14703(%rip), %rsi     # 0x193a8
callq 0x32e0
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %r15
leaq 0x3e8(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
leaq 0x80(%rsp), %rcx
callq 0x8133
movq %r15, %rdi
callq 0x3458
movq %r12, %rdi
callq 0x3458
movb $0x1, 0xf(%rsp)
leaq 0x5c8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x32e0
leaq 0x5a8(%rsp), %r12
movq %r15, %rdi
leaq 0xf(%rsp), %rsi
callq 0x817f
movl %eax, %ebx
movq %r15, %rdi
callq 0x3458
movl %ebx, 0x8c(%rsp)
cmpl 0x10(%rsp), %ebx
jl 0x4d4e
movq %r12, %rdi
leaq 0x248(%rsp), %rsi
leaq 0xc43b(%rip), %rdx      # 0x11174
callq 0x658d
movq %r12, %rdi
callq 0x3dec
movq %r12, %rdi
callq 0x3458
leaq 0xc0(%rsp), %rdi
leaq 0x8c(%rsp), %rsi
callq 0x64a8
movslq 0x8c(%rsp), %rsi
shlq $0x3, %rsi
movq 0x100(%rsp), %rax
addq (%rax), %rsi
leaq 0x190(%rsp), %rdi
callq 0x65c6
movzbl 0xf(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x65e4
leaq 0x90(%rsp), %rdi
callq 0x3458
leaq 0x2a8(%rsp), %r12
jmp 0x4c7d
movq 0x78(%rsp), %rax
addl $-0x3, %eax
movq %rax, 0x78(%rsp)
xorl %r15d, %r15d
leaq 0x228(%rsp), %rdi
leaq 0xc35e(%rip), %rsi      # 0x1112d
callq 0x631c
testb %al, %al
movq 0x78(%rsp), %rax
cmovnel 0x18(%rsp), %eax
cltq
cmpq %rax, %r15
jge 0x4fb3
movq 0xc0(%rsp), %rax
movslq (%rax,%r15,4), %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6622
xorl %ecx, %ecx
testq %rdx, (%rax)
setne %cl
leaq (%rcx,%rbx,4), %rsi
leaq 0x1a8(%rsp), %rdi
callq 0x6622
movq %r14, %rbx
orq %rdx, (%rax)
leaq 0x1(%r15), %rax
movq %rax, 0x220(%rsp)
cltd
idivl 0x18(%rsp)
movl %edx, %ebp
movq 0xc0(%rsp), %rax
movslq (%rax,%rbp,4), %r14
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6622
shlq $0x2, %r14
andq (%rax), %rdx
cmpq $0x1, %rdx
pushq $0x3
popq %rax
movl %eax, %esi
sbbl $0x0, %esi
orq %r14, %rsi
leaq 0x1a8(%rsp), %rdi
callq 0x6622
orq %rdx, (%rax)
movq 0xc0(%rsp), %rax
movslq (%rax,%r15,4), %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x6622
xorl %ecx, %ecx
testq %rdx, (%rax)
setne %cl
movq 0x150(%rsp), %rax
shlq $0x4, %r14
leaq (%r14,%rcx,4), %rcx
movq %r12, %rdi
movl (%rax,%rcx), %r12d
movq 0xc0(%rsp), %rax
movslq (%rax,%rbp,4), %r14
movq %rbp, %rsi
callq 0x6622
xorl %ecx, %ecx
testq %rdx, (%rax)
sete %cl
movq 0x150(%rsp), %rax
imull $0xc, %ecx, %ecx
shlq $0x4, %r14
orq %rcx, %r14
movl (%rax,%r14), %ecx
cmpl %ecx, %r12d
movl %ecx, %edx
cmovgl %r12d, %edx
cmovll %r12d, %ecx
xorl %esi, %esi
movq %rbx, %r14
cmpq %rsi, %r13
je 0x4f02
cmpl %edx, (%rax,%rsi,4)
jne 0x4efd
movl %ecx, (%rax,%rsi,4)
incq %rsi
jmp 0x4ef0
movq 0xc0(%rsp), %rax
movslq (%rax,%r15,4), %r12
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6622
andq (%rax), %rdx
cmpq $0x1, %rdx
pushq $0x2
popq %rax
sbbl $0x0, %eax
movq 0x150(%rsp), %rcx
shll $0x2, %eax
shlq $0x4, %r12
orq %rax, %r12
movl (%rcx,%r12), %r15d
movq 0xc0(%rsp), %rax
movslq (%rax,%rbp,4), %r12
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6622
andq (%rax), %rdx
cmpq $0x1, %rdx
pushq $0x3
popq %rax
movl %eax, %ecx
sbbl $0x0, %ecx
movq 0x150(%rsp), %rax
shll $0x2, %ecx
shlq $0x4, %r12
orq %rcx, %r12
movl (%rax,%r12), %ecx
cmpl %ecx, %r15d
movl %ecx, %edx
cmovgl %r15d, %edx
cmovll %r15d, %ecx
xorl %esi, %esi
leaq 0x2a8(%rsp), %r12
cmpq %rsi, %r13
je 0x4fa6
cmpl %edx, (%rax,%rsi,4)
jne 0x4fa1
movl %ecx, (%rax,%rsi,4)
incq %rsi
jmp 0x4f94
movq 0x220(%rsp), %r15
jmp 0x4dc0
leaq 0x228(%rsp), %rbx
movq %rbx, %rdi
leaq 0xc168(%rip), %rsi      # 0x1112d
callq 0x631c
testb %al, %al
je 0x5032
movq 0x180(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x62f0
movq 0x178(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x62f0
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
leaq 0x190(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xb6de
movq 0x210(%rsp), %rdi
movq %rbx, %rsi
callq 0x7504
movq %rbx, %rdi
callq 0xb8ae
jmp 0x5120
movq %rbx, %rdi
leaq 0xc0f9(%rip), %rsi      # 0x11135
callq 0x631c
testb %al, %al
je 0x5120
movq 0x170(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x62f0
movq 0x820(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x62f0
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
leaq 0x190(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xca56
movq 0xf8(%rsp), %rdi
movq %rbx, %rsi
callq 0x77a4
movq %rbx, %rdi
callq 0xcc2a
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x6622
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
leaq 0x48(%rsp), %rdi
callq 0x65e4
movq 0xc0(%rsp), %rsi
leaq 0x1f0(%rsp), %rdi
callq 0x64a8
movslq 0x78(%rsp), %rbx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x6622
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
leaq 0x108(%rsp), %rdi
callq 0x65e4
shlq $0x2, %rbx
addq 0xc0(%rsp), %rbx
leaq 0x1d0(%rsp), %rdi
movq %rbx, %rsi
callq 0x64a8
leaq 0x20(%rsp), %rdi
callq 0x665c
leaq 0x190(%rsp), %rdi
callq 0x6f9c
leaq 0xc0(%rsp), %rdi
callq 0x6c0e
leaq 0x268(%rsp), %rdi
callq 0x3458
leaq 0x248(%rsp), %rdi
jmp 0x5182
leaq 0x588(%rsp), %rbx
movq %rbx, %rdi
leaq 0xc029(%rip), %rsi      # 0x11196
leaq 0x20(%rsp), %rdx
callq 0x3e82
movq %rbx, %rdi
callq 0x3dec
movq %rbx, %rdi
callq 0x3458
leaq 0x228(%rsp), %rdi
callq 0x3458
leaq 0xd8(%rsp), %rdi
callq 0x3458
movq 0x218(%rsp), %rsi
incq %rsi
jmp 0x48e0
leaq 0x90(%rsp), %rdx
orl $-0x1, (%rdx)
leaq 0x20(%rsp), %rdi
leaq 0xd8(%rsp), %rcx
movq %r14, %rsi
callq 0x666c
xorl %ebx, %ebx
leaq 0x1a8(%rsp), %r15
movl $0x0, 0x10(%rsp)
cmpq %r13, %rbx
je 0x528c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6622
testq %rdx, (%rax)
jne 0x5284
movq 0x20(%rsp), %rax
cmpl $-0x1, (%rax,%rbx,4)
jne 0x5284
movq 0x150(%rsp), %rax
movq %rbx, 0x18(%rsp)
movl (%rax,%rbx,4), %ebx
movl %ebx, %ebp
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x5277
movq %r15, %rdi
movq %r12, %rsi
callq 0x6622
testq %rdx, (%rax)
jne 0x524f
movq 0x20(%rsp), %rax
cmpl $-0x1, (%rax,%r12,4)
jne 0x524f
movq 0x150(%rsp), %rcx
cmpl %ebp, (%rcx,%r12,4)
je 0x5254
incq %r12
jmp 0x5220
movl %r12d, %edx
notl %edx
xorl %esi, %esi
testb $0x3, %dl
setne %sil
leal (%r12,%rsi,4), %edx
addl $-0x3, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ebp
movl 0x10(%rsp), %ecx
movl %ecx, (%rax,%r12,4)
cmpl %ebx, %ebp
jne 0x521d
incl 0x10(%rsp)
movq 0x18(%rsp), %rbx
incq %rbx
jmp 0x51e3
addq $0x58, 0x70(%rsp)
xorl %ebp, %ebp
movl 0x10(%rsp), %eax
testl %eax, %eax
cmovgl %eax, %ebp
leaq 0x90(%rsp), %rbx
subl $0x1, %ebp
jb 0x52c4
movl $0x2, 0x90(%rsp)
movq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x7abc
jmp 0x52a5
movq 0xf8(%rsp), %r14
movq (%r14), %rbp
xorl %r12d, %r12d
pushq $0x28
popq %r13
xorl %r15d, %r15d
movq 0x8(%r14), %rax
subq %rbp, %rax
cqto
idivq %r13
cltq
cmpq %rax, %r15
jge 0x5390
movq 0x1f0(%rsp), %rax
movslq (%rax,%r15,4), %rbx
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x6622
andq (%rax), %rdx
cmpq $0x1, %rdx
pushq $0x3
popq %rax
sbbl $0x0, %eax
movq 0x20(%rsp), %rcx
shll $0x2, %eax
shlq $0x4, %rbx
orq %rax, %rbx
movl (%rcx,%rbx), %eax
movl %eax, 0x18(%rbp,%r12)
movq 0xf8(%rsp), %r14
movq (%r14), %rbp
movq 0x1d0(%rsp), %rax
movslq (%rax,%r15,4), %rbx
leaq 0x108(%rsp), %rdi
movq %r15, %rsi
callq 0x6622
xorl %ecx, %ecx
testq %rdx, (%rax)
setne %cl
movq 0x20(%rsp), %rax
shlq $0x4, %rbx
leaq (%rbx,%rcx,4), %rcx
movl (%rax,%rcx), %eax
movl %eax, 0x1c(%rbp,%r12)
movq (%r14), %rbp
movl 0x18(%rbp,%r12), %eax
cmpl 0x1c(%rbp,%r12), %eax
sete 0x20(%rbp,%r12)
incq %r15
addq $0x28, %r12
jmp 0x52d9
leaq 0x90(%rsp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq 0x180(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
xorl %esi, %esi
callq 0x66c2
leaq 0x90(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x178(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x66c2
leaq 0x90(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x170(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x66c2
leaq 0x90(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x820(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x66c2
leaq 0x90(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x828(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x66c2
leaq 0x90(%rsp), %rdi
callq 0x828a
leaq 0x90(%rsp), %rdi
callq 0x66e2
leaq 0x20(%rsp), %rdi
callq 0x6c0e
leaq 0x150(%rsp), %rdi
callq 0x6c0e
leaq 0x1a8(%rsp), %rdi
callq 0x665c
leaq 0x108(%rsp), %rdi
callq 0x665c
leaq 0x48(%rsp), %rdi
callq 0x665c
leaq 0x1d0(%rsp), %rdi
callq 0x6c0e
leaq 0x1f0(%rsp), %rdi
callq 0x6c0e
leaq 0x130(%rsp), %rdi
callq 0x66e2
addq $0x7e8, %rsp            # imm = 0x7E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x308(%rsp), %rdi
jmp 0x5960
jmp 0x5891
movq %rax, %rbx
leaq 0x328(%rsp), %rdi
jmp 0x5960
jmp 0x5891
movq %rax, %rbx
leaq 0x3c8(%rsp), %rdi
jmp 0x5570
movq %rax, %rbx
jmp 0x5a39
jmp 0x5510
jmp 0x5510
jmp 0x5510
jmp 0x5510
jmp 0x5510
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x66e2
jmp 0x59d7
jmp 0x57c1
jmp 0x57c1
movq %rax, %rbx
jmp 0x59fb
movq %rax, %rbx
leaq 0x388(%rsp), %rdi
callq 0x3458
jmp 0x554c
movq %rax, %rbx
leaq 0x3a8(%rsp), %rdi
jmp 0x5956
jmp 0x57e1
jmp 0x57e1
jmp 0x5891
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3458
jmp 0x5a39
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xcc2a
jmp 0x597a
jmp 0x58e9
movq %rax, %rbx
leaq 0x588(%rsp), %rdi
jmp 0x59b3
jmp 0x569d
jmp 0x58e9
jmp 0x58e9
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xb8ae
jmp 0x597a
jmp 0x58e9
movq %rax, %rbx
leaq 0x5e8(%rsp), %rdi
jmp 0x5975
jmp 0x58e9
jmp 0x5934
jmp 0x5779
movq %rax, %rbx
leaq 0x7a8(%rsp), %rdi
jmp 0x5949
jmp 0x585a
movq %rax, %rbx
leaq 0x788(%rsp), %rdi
jmp 0x592d
movq %rax, %rbx
jmp 0x59ab
movq %rax, %rbx
jmp 0x5674
movq %rax, %rbx
leaq 0x648(%rsp), %rdi
callq 0x3458
jmp 0x5645
movq %rax, %rbx
leaq 0x628(%rsp), %rdi
callq 0x3458
jmp 0x5655
movq %rax, %rbx
leaq 0x448(%rsp), %rdi
jmp 0x59b3
movq %rax, %rbx
leaq 0x428(%rsp), %rdi
jmp 0x59a6
jmp 0x569d
movq %rax, %rbx
leaq 0x608(%rsp), %rdi
callq 0x3458
leaq 0x408(%rsp), %rdi
jmp 0x5975
movq %rax, %rbx
leaq 0x6c8(%rsp), %rdi
jmp 0x592d
jmp 0x5934
jmp 0x569d
movq %rax, %rbx
jmp 0x56bc
movq %rax, %rbx
jmp 0x59b8
movq %rax, %rbx
jmp 0x56e8
movq %rax, %rbx
jmp 0x56c9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3458
leaq 0x488(%rsp), %rdi
callq 0x3458
leaq 0x2e8(%rsp), %rdi
jmp 0x59b3
movq %rax, %rbx
jmp 0x56f5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3458
leaq 0x468(%rsp), %rdi
callq 0x3458
leaq 0x2c8(%rsp), %rdi
jmp 0x59b3
jmp 0x5891
jmp 0x585a
movq %rax, %rbx
leaq 0x6e8(%rsp), %rdi
callq 0x3458
jmp 0x5721
movq %rax, %rbx
leaq 0x4e8(%rsp), %rdi
jmp 0x592d
jmp 0x5934
movq %rax, %rbx
leaq 0x708(%rsp), %rdi
callq 0x3458
jmp 0x5748
movq %rax, %rbx
leaq 0x508(%rsp), %rdi
jmp 0x593c
jmp 0x5779
movq %rax, %rbx
leaq 0x728(%rsp), %rdi
callq 0x3458
jmp 0x576c
movq %rax, %rbx
leaq 0x528(%rsp), %rdi
jmp 0x5949
movq %rax, %rbx
jmp 0x5941
jmp 0x59d4
jmp 0x59d4
jmp 0x59d4
jmp 0x59d4
movq %rax, %rbx
jmp 0x59c5
movq %rax, %rbx
jmp 0x57b2
movq %rax, %rbx
leaq 0x668(%rsp), %rdi
callq 0x3458
leaq 0x4a8(%rsp), %rdi
jmp 0x59c0
jmp 0x57c1
movq %rax, %rbx
jmp 0x59e1
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x3250
jmp 0x5a2c
jmp 0x5891
movq %rax, %rbx
jmp 0x595b
movq %rax, %rbx
jmp 0x57fe
movq %rax, %rbx
leaq 0x748(%rsp), %rdi
callq 0x3458
leaq 0x548(%rsp), %rdi
jmp 0x5956
movq %rax, %rbx
jmp 0x5822
jmp 0x585a
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
callq 0x3458
leaq 0x7c8(%rsp), %rdi
callq 0x3458
jmp 0x5865
movq %rax, %rbx
jmp 0x5848
jmp 0x585a
movq %rax, %rbx
leaq 0x768(%rsp), %rdi
callq 0x3458
leaq 0x568(%rsp), %rdi
jmp 0x5949
movq %rax, %rbx
jmp 0x5882
movq %rax, %rbx
jmp 0x594e
movq %rax, %rbx
leaq 0x368(%rsp), %rdi
jmp 0x5949
movq %rax, %rbx
leaq 0x348(%rsp), %rdi
callq 0x3458
leaq 0x288(%rsp), %rdi
jmp 0x5949
jmp 0x58e9
movq %rax, %rbx
jmp 0x5a2c
movq %rax, %rbx
leaq 0x5a8(%rsp), %rdi
jmp 0x58dd
jmp 0x58e9
jmp 0x58e9
jmp 0x58e9
jmp 0x58e9
jmp 0x58e9
movq %rax, %rbx
jmp 0x58c5
movq %rax, %rbx
leaq 0x2a8(%rsp), %rdi
callq 0x3458
leaq 0x3e8(%rsp), %rdi
jmp 0x5975
movq %rax, %rbx
leaq 0x5c8(%rsp), %rdi
callq 0x3458
jmp 0x596d
jmp 0x58e9
movq %rax, %rbx
jmp 0x597a
movq %rax, %rbx
jmp 0x5906
movq %rax, %rbx
leaq 0x6a8(%rsp), %rdi
callq 0x3458
leaq 0x4c8(%rsp), %rdi
jmp 0x592d
movq %rax, %rbx
jmp 0x5925
movq %rax, %rbx
leaq 0x688(%rsp), %rdi
callq 0x3458
leaq 0x90(%rsp), %rdi
callq 0x3458
jmp 0x5937
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3458
leaq 0x1a8(%rsp), %rdi
callq 0x3458
leaq 0x108(%rsp), %rdi
callq 0x3458
leaq 0x48(%rsp), %rdi
callq 0x3458
jmp 0x5a2c
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3458
leaq 0x20(%rsp), %rdi
callq 0x665c
leaq 0x190(%rsp), %rdi
callq 0x6f9c
leaq 0xc0(%rsp), %rdi
callq 0x6c0e
leaq 0x268(%rsp), %rdi
callq 0x3458
leaq 0x248(%rsp), %rdi
callq 0x3458
leaq 0x228(%rsp), %rdi
callq 0x3458
leaq 0xd8(%rsp), %rdi
callq 0x3458
jmp 0x59e1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6c0e
leaq 0x150(%rsp), %rdi
callq 0x6c0e
leaq 0x1a8(%rsp), %rdi
callq 0x665c
leaq 0x108(%rsp), %rdi
callq 0x665c
leaq 0x48(%rsp), %rdi
callq 0x665c
leaq 0x1d0(%rsp), %rdi
callq 0x6c0e
leaq 0x1f0(%rsp), %rdi
callq 0x6c0e
leaq 0x130(%rsp), %rdi
callq 0x66e2
movq %rbx, %rdi
callq 0x33d0