// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: manifold::canonical_peripheral_curves(tetra*)
void manifold::canonical_peripheral_curves(tetra *capoff_tetra)
{
	output_debugging("L&M", 2);
	
	if (!last_tetra)  // Empty manifold?
		return;
	
	if (capoff_tetra == NULL)  // We don't want to calculate this or there's no boundary faces.
		return;
	
	// Clear everything.
	for (tetra *current = capoff_tetra; current != NULL; current = current->get_next())
		current->set_temp(-1);
	
	// Start by assuming that we're building a bundle.
	// First we deal with the cusps coming from marked points of the surface.
	// Here the longitude is canonical (coming from the surface) and the 
	// dual 'meridian' slope is chosen to be shortest in the triangulation.
	// The longitude runs clockwise around the marked point (as seen on the surface
	// from above) while the meridian runs upwards (into your eye).
	for (tetra *basepoint = capoff_tetra; basepoint != NULL; basepoint = basepoint->get_next())
	{
		// Non-toroidal cusps have cusp number -1; avoid them.
		if ((basepoint->get_temp() != -1) || (basepoint->get_cusp_number() == -1)) continue;
		
		if (basepoint->get_layer() != num_layers) continue;
		
		// Work out the longitude.
		int bad_dir = 0;  // This will be the direction to move in to get out of this layer.
		for (bad_dir = 0; bad_dir < 3; bad_dir++)  // Work out the starting direction (actually the direction NOT to go in).
			if ((basepoint->get_gluedto(bad_dir))->get_layer() != num_layers) break;
		
		int back_dir = (bad_dir + 2) % 3;  // This will always hold the direction pointing back the way we just moved. Never go back this way.
		
		// Starting at the basepoint, install longitude until we get back to the basepoint.
		// NEVER exit the current layer.
		for (tetra *current = basepoint, *adjacent = NULL; adjacent != basepoint; current = adjacent)
		{
			current->set_temp(-2);
			for (int dir = 0; dir < 3; dir++)
			{
				if (dir == back_dir) continue;  // Don't move backwards.
				adjacent = current->get_gluedto(dir);
				if (adjacent->get_layer() != num_layers) continue;  // Don't move out of this layer.
				
				back_dir = (current->get_gluing(dir))[dir];  // Find out which way will take us backwards.
				current->set_peripheral_curves(longitude, dir, -1);  // Install the longitude in this direction.
				adjacent->set_peripheral_curves(longitude, back_dir, 1);
				break;
			}
		}
		
		// Now work out the meridian.
		// We look for a start and end on opposite sides of the longitude.
		int start_basepoint_dir = bad_dir, end_basepoint_dir = dual_direction(basepoint);
		
		tetra *start_basepoint = basepoint->get_gluedto(start_basepoint_dir);
		tetra *end_basepoint = basepoint->get_gluedto(end_basepoint_dir);
		
		// Start the meridian information.
		basepoint->set_peripheral_curves(meridian, start_basepoint_dir, -1);
		basepoint->set_peripheral_curves(meridian, end_basepoint_dir, 1);
		back_dir = (basepoint->get_gluing(end_basepoint_dir))[end_basepoint_dir];
		end_basepoint->set_peripheral_curves(meridian, back_dir, -1);
		back_dir = (basepoint->get_gluing(start_basepoint_dir))[start_basepoint_dir];
		start_basepoint->set_peripheral_curves(meridian, back_dir, 1);
		
		// Now find a path from start to end without crossing the longitude.
		// Remember, ones in the longitude have a temp of -2.
		
		// Flow distance forwards.
		int old_start_basepoint_temp = start_basepoint->get_temp();
		start_basepoint->set_temp(0);  // Seed flow at start_basepoint.
		int old_end_basepoint_temp = end_basepoint->get_temp();
		end_basepoint->set_temp(-1);  // Must allow the flow into end_basepoint.
		
		std::queue<tetra *> tetra_list;
		tetra_list.push(start_basepoint);
		while ((end_basepoint->get_temp() == -1) && !(tetra_list.empty()))
		{
			tetra *current = tetra_list.front();
			tetra_list.pop();
			for (int i = 0; i < 3; i++)
			{
				tetra *adjacent = current->get_gluedto(i);
				if (adjacent->get_temp() == -1)
				{
					adjacent->set_temp(current->get_temp() + 1);
					tetra_list.push(adjacent);
				}
			}
		}
		
		if (end_basepoint->get_temp() == -1)  // If the longitude was separating then clean up.
		{
			output_debugging("clean", 3);
			start_basepoint->set_temp(old_start_basepoint_temp);
			end_basepoint->set_temp(old_end_basepoint_temp);
			
			for (tetra *current = capoff_tetra; current != NULL; current = current->get_next())
			{
				if (current->get_cusp_number() != basepoint->get_cusp_number()) continue;
				if (current->get_temp() != -2) current->set_temp(-1);  // Leave -2's in as this longitude was separating.
				for (int i = 0; i < 4; i++)
				{
					current->set_peripheral_curves(longitude, i, 0);
					current->set_peripheral_curves(meridian, i, 0);
				}
			}
			continue;
		}
		
		// Flow meridian backwards.
		for (tetra *current = end_basepoint; current != start_basepoint; )
			for (int i = 0; i < 3; i++)
			{
				tetra *adjacent = current->get_gluedto(i);
				if (adjacent->get_temp() != (current->get_temp() - 1)) continue;
				
				current->set_peripheral_curves(meridian, i, 1);
				back_dir = (current->get_gluing(i))[i];
				adjacent->set_peripheral_curves(meridian, back_dir, -1);
				current = adjacent;
				break;
			}
		
		// Clear the temp data now that we're done.
		for (tetra *current = capoff_tetra; current != NULL; current = current->get_next())
			if (current->get_cusp_number() == basepoint->get_cusp_number())
				current->set_temp(-2);
		
		// If the manifold is a splitting we interchange the longitude and meridian. In order
		// to maintain the orientation convention, we flip the orientation of the meridian.
		if (this->get_manifold_type() == splitting)
			for (tetra *current = capoff_tetra; current != NULL; current = current->get_next())
				if (current->get_cusp_number() == basepoint->get_cusp_number())
					for (int i = 0; i < 3; i++)
					{
						int temp = current->get_peripheral_curves(longitude, i);
						current->set_peripheral_curves(longitude, i, current->get_peripheral_curves(meridian, i));
						current->set_peripheral_curves(meridian, i, -temp);
					}
	}
	
	// Now we repeat the whole process filling in the cusps that come from drillings.
	// Here the longitude is horizontal while the meridian goes up, around, down and back.
	for (tetra *basepoint = capoff_tetra; basepoint != NULL; basepoint = basepoint->get_next())
	{
		// Non-toroidal cusps have cusp number -1; avoid them.
		if ((basepoint->get_temp() != -1) || (basepoint->get_cusp_number() == -1)) continue;
		
		// We look for an even more specific type of basepoint.
		// To understand this, see the diagram of the cube.
		// 
		if (((basepoint->get_gluedto(3))->get_category() != gadget_left) || 
			((basepoint->get_gluedto(3))->get_position() != low) || 
			((basepoint->get_gluedto(3))->get_side() != right) ) continue;
		
		// Don't use basepoints that are glued to the end of rectangles (check for adjacent gadget_pups).
		bool good = true;
		for (int i = 0; i < 3; i++)
			if (((basepoint->get_gluedto(i))->get_gluedto(3))->get_category() == gadget_pup)
				good = false;
		
		if (!good) continue;
		
		// Now we work out the meridian starting from this basepoint.
		int back_dir = 0;
		bool upright = (basepoint->get_gluing(3)[3] == 2);  // Determine if the cube we attached to was a plus cube.
		int movements[4] = {3, upright ? 2 : 0, 1, 3};  // Array of movement directions.
		
		perm mount_to_basepoint = basepoint->get_gluing(3).inverse();
		tetra *current = basepoint;
		for (int i = 0; i < 4; i++)
		{
			int real_movement = (current->get_gluing(3).inverse())[movements[i]];
			current->set_temp(-2);
			current->set_peripheral_curves(meridian, real_movement, -1);
			back_dir = (current->get_gluing(real_movement))[real_movement];
			current = current->get_gluedto(real_movement);
			current->set_peripheral_curves(meridian, back_dir, 1);
		}
		if (current != basepoint) output_error("Misaligned meridian on a drilling.");
		
		// Now work out the longitude.
		// We look for a start and end on opposite sides of the meridian.
		
		int start_basepoint_dir = upright ? mount_to_basepoint[0] : mount_to_basepoint[2];
		int end_basepoint_dir = upright ? mount_to_basepoint[1] : mount_to_basepoint[0];
		
		tetra *start_basepoint = basepoint->get_gluedto(start_basepoint_dir);
		tetra *end_basepoint = basepoint->get_gluedto(end_basepoint_dir);
		
		// Start the longitude information.
		basepoint->set_peripheral_curves(longitude, start_basepoint_dir, -1);
		basepoint->set_peripheral_curves(longitude, end_basepoint_dir, 1);
		back_dir = (basepoint->get_gluing(end_basepoint_dir))[end_basepoint_dir];
		end_basepoint->set_peripheral_curves(longitude, back_dir, -1);
		back_dir = (basepoint->get_gluing(start_basepoint_dir))[start_basepoint_dir];
		start_basepoint->set_peripheral_curves(longitude, back_dir, 1);
		
		// Now find a path from start to end without crossing the meridian.
		// Remember, ones in the meridian have temp == -2.
		
		// Flow distance forwards.
		int old_start_basepoint_temp = start_basepoint->get_temp();
		start_basepoint->set_temp(0);  // Seed flow at start_basepoint.
		int old_end_basepoint_temp = end_basepoint->get_temp();
		end_basepoint->set_temp(-1);  // Better allow flow into end_basepoint.
		
		std::queue<tetra *> tetra_list;
		tetra_list.push(start_basepoint);
		while ((end_basepoint->get_temp() == -1) && !(tetra_list.empty()))
		{
			tetra *current = tetra_list.front();
			tetra_list.pop();
			for (int i = 0; i < 3; i++)
			{
				tetra *adjacent = current->get_gluedto(i);
				if (adjacent->get_temp() == -1)
				{
					adjacent->set_temp(current->get_temp() + 1);
					tetra_list.push(adjacent);
				}
			}
		}
		
		if (end_basepoint->get_temp() == -1)  // If the meridian was separating then clean up.
		{
			output_debugging("clean", 3);
			start_basepoint->set_temp(old_start_basepoint_temp);
			end_basepoint->set_temp(old_end_basepoint_temp);
			for (tetra *current = capoff_tetra; current != NULL; current = current->get_next())
			{
				if (current->get_cusp_number() != basepoint->get_cusp_number()) continue;
				if (current->get_temp() != -2) current->set_temp(-1);  // Leave -2's in as this meridian was separating.
				for (int i = 0; i < 4; i++)
				{
					current->set_peripheral_curves(longitude, i, 0);
					current->set_peripheral_curves(meridian, i, 0);
				}
			}
			continue;
		}
		
		// Flow longitude backwards.
		for (tetra *current = end_basepoint, *adjacent = NULL; current != start_basepoint; current = adjacent)
		{
			for (int i = 0; i < 3; i++)
			{
				adjacent = current->get_gluedto(i);
				if (adjacent->get_temp() != (current->get_temp() - 1)) continue;
				
				current->set_peripheral_curves(longitude, i, 1);
				back_dir = (current->get_gluing(i))[i];
				adjacent->set_peripheral_curves(longitude, back_dir, -1);
				break;
			}
		}
		
		// Clear the temp data now that we're done.
		for (tetra *current = capoff_tetra; current != NULL; current = current->get_next())
			if (current->get_cusp_number() == basepoint->get_cusp_number())
				current->set_temp(-2);
	}
	
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x388(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x380(%rbp)
callq 0x3560
movq -0x380(%rbp), %rdx
leaq 0x9005(%rip), %rsi      # 0x27771
leaq -0x30(%rbp), %rdi
callq 0x4e10
jmp 0x1e777
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x4c10
jmp 0x1e787
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3360
movq -0x388(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1e7dd
jmp 0x1fcc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1e7cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3360
jmp 0x1fcca
cmpq $0x0, -0x10(%rbp)
jne 0x1e7e9
jmp 0x1fcc1
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x1e815
movq -0x50(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x21360
movq -0x50(%rbp), %rdi
callq 0x21300
movq %rax, -0x50(%rbp)
jmp 0x1e7f1
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x1f1cc
movq -0x58(%rbp), %rdi
callq 0x21380
cmpl $-0x1, %eax
jne 0x1e844
movq -0x58(%rbp), %rdi
callq 0x21530
cmpl $-0x1, %eax
jne 0x1e849
jmp 0x1f1a9
movq -0x58(%rbp), %rdi
callq 0x211e0
movq -0x388(%rbp), %rcx
cmpl 0x38(%rcx), %eax
je 0x1e863
jmp 0x1f1a9
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x5c(%rbp)
cmpl $0x3, -0x5c(%rbp)
jge 0x1e8a6
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x20b60
movq %rax, %rdi
callq 0x211e0
movq -0x388(%rbp), %rcx
cmpl 0x38(%rcx), %eax
je 0x1e899
jmp 0x1e8a6
jmp 0x1e89b
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x1e871
movl -0x5c(%rbp), %eax
addl $0x2, %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x1e98f
movq -0x68(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x21360
movl $0x0, -0x74(%rbp)
cmpl $0x3, -0x74(%rbp)
jge 0x1e980
movl -0x74(%rbp), %eax
cmpl -0x60(%rbp), %eax
jne 0x1e8fe
jmp 0x1e972
movq -0x68(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x20b60
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x211e0
movq -0x388(%rbp), %rcx
cmpl 0x38(%rcx), %eax
je 0x1e925
jmp 0x1e972
movq -0x68(%rbp), %rsi
movl -0x74(%rbp), %edx
leaq -0x84(%rbp), %rdi
callq 0x20b80
movl -0x74(%rbp), %esi
leaq -0x84(%rbp), %rdi
callq 0x16f80
movl %eax, -0x60(%rbp)
movq -0x68(%rbp), %rdi
movl -0x74(%rbp), %edx
xorl %esi, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x21550
movq -0x70(%rbp), %rdi
movl -0x60(%rbp), %edx
xorl %esi, %esi
movl $0x1, %ecx
callq 0x21550
jmp 0x1e980
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x1e8ea
jmp 0x1e982
movq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x1e8c7
movl -0x5c(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0x58(%rbp), %rdi
callq 0x1e600
movl %eax, -0x8c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x88(%rbp), %esi
callq 0x20b60
movq %rax, -0x98(%rbp)
movq -0x58(%rbp), %rdi
movl -0x8c(%rbp), %esi
callq 0x20b60
movq %rax, -0xa0(%rbp)
movq -0x58(%rbp), %rdi
movl -0x88(%rbp), %edx
movl $0x1, %esi
movl %esi, -0x398(%rbp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, -0x394(%rbp)
callq 0x21550
movl -0x398(%rbp), %ecx
movq -0x58(%rbp), %rdi
movl -0x8c(%rbp), %edx
movl %ecx, %esi
callq 0x21550
movq -0x58(%rbp), %rsi
movl -0x8c(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x3a8(%rbp)
callq 0x20b80
movq -0x3a8(%rbp), %rdi
movl -0x8c(%rbp), %esi
callq 0x16f80
movl -0x398(%rbp), %esi
movl -0x394(%rbp), %ecx
movl %eax, -0x60(%rbp)
movq -0xa0(%rbp), %rdi
movl -0x60(%rbp), %edx
callq 0x21550
movq -0x58(%rbp), %rsi
movl -0x88(%rbp), %edx
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x20b80
movq -0x3a0(%rbp), %rdi
movl -0x88(%rbp), %esi
callq 0x16f80
movl -0x398(%rbp), %ecx
movl %eax, -0x60(%rbp)
movq -0x98(%rbp), %rdi
movl -0x60(%rbp), %edx
movl %ecx, %esi
callq 0x21550
movq -0x98(%rbp), %rdi
callq 0x21380
movl %eax, -0xc4(%rbp)
movq -0x98(%rbp), %rdi
xorl %esi, %esi
callq 0x21360
movq -0xa0(%rbp), %rdi
callq 0x21380
movl -0x394(%rbp), %esi
movl %eax, -0xc8(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x21360
leaq -0x118(%rbp), %rdi
movq %rdi, -0x390(%rbp)
callq 0x213a0
movq -0x390(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x213d0
jmp 0x1eb11
jmp 0x1eb13
movq -0xa0(%rbp), %rdi
callq 0x21380
movl %eax, -0x3ac(%rbp)
jmp 0x1eb27
movl -0x3ac(%rbp), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x3ad(%rbp)
jne 0x1eb5c
leaq -0x118(%rbp), %rdi
callq 0x21400
movb %al, -0x3ae(%rbp)
jmp 0x1eb4e
movb -0x3ae(%rbp), %al
xorb $-0x1, %al
movb %al, -0x3ad(%rbp)
movb -0x3ad(%rbp), %al
testb $0x1, %al
jne 0x1eb6b
jmp 0x1ec79
leaq -0x118(%rbp), %rdi
callq 0x21420
movq %rax, -0x3b8(%rbp)
jmp 0x1eb80
movq -0x3b8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x120(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x21440
jmp 0x1eb9f
movl $0x0, -0x124(%rbp)
cmpl $0x3, -0x124(%rbp)
jge 0x1ec74
movq -0x120(%rbp), %rdi
movl -0x124(%rbp), %esi
callq 0x20b60
movq %rax, -0x3c0(%rbp)
jmp 0x1ebd1
movq -0x3c0(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
callq 0x21380
movl %eax, -0x3c4(%rbp)
jmp 0x1ebf3
movl -0x3c4(%rbp), %eax
cmpl $-0x1, %eax
jne 0x1ec5e
movq -0x130(%rbp), %rax
movq %rax, -0x3d0(%rbp)
movq -0x120(%rbp), %rdi
callq 0x21380
movl %eax, -0x3c8(%rbp)
jmp 0x1ec20
movq -0x3d0(%rbp), %rdi
movl -0x3c8(%rbp), %esi
incl %esi
callq 0x21360
jmp 0x1ec36
leaq -0x118(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x213d0
jmp 0x1ec4b
jmp 0x1ec5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f1bb
jmp 0x1ec60
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x1eba9
jmp 0x1eb13
movq -0xa0(%rbp), %rdi
callq 0x21380
movl %eax, -0x3d4(%rbp)
jmp 0x1ec8d
movl -0x3d4(%rbp), %eax
cmpl $-0x1, %eax
jne 0x1ee6e
leaq -0x151(%rbp), %rdi
movq %rdi, -0x3e0(%rbp)
callq 0x3560
movq -0x3e0(%rbp), %rdx
leaq 0x8ab8(%rip), %rsi      # 0x27775
leaq -0x150(%rbp), %rdi
callq 0x4e10
jmp 0x1eccb
leaq -0x150(%rbp), %rdi
movl $0x3, %esi
callq 0x4c10
jmp 0x1ecde
leaq -0x150(%rbp), %rdi
callq 0x35f8
leaq -0x151(%rbp), %rdi
callq 0x3360
movq -0x98(%rbp), %rdi
movl -0xc4(%rbp), %esi
callq 0x21360
jmp 0x1ed0a
movq -0xa0(%rbp), %rdi
movl -0xc8(%rbp), %esi
callq 0x21360
jmp 0x1ed1e
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
cmpq $0x0, -0x160(%rbp)
je 0x1ee5f
movq -0x160(%rbp), %rdi
callq 0x21530
movl %eax, -0x3e4(%rbp)
jmp 0x1ed4b
movq -0x58(%rbp), %rdi
callq 0x21530
movl %eax, -0x3e8(%rbp)
jmp 0x1ed5c
movl -0x3e4(%rbp), %eax
movl -0x3e8(%rbp), %ecx
cmpl %ecx, %eax
je 0x1eda8
jmp 0x1ee37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1ed97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x35f8
leaq -0x151(%rbp), %rdi
callq 0x3360
jmp 0x1f1bb
movq -0x160(%rbp), %rdi
callq 0x21380
movl %eax, -0x3ec(%rbp)
jmp 0x1edbc
movl -0x3ec(%rbp), %eax
cmpl $-0x2, %eax
je 0x1eddc
movq -0x160(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x21360
jmp 0x1edda
jmp 0x1eddc
movl $0x0, -0x164(%rbp)
cmpl $0x4, -0x164(%rbp)
jge 0x1ee35
movq -0x160(%rbp), %rdi
movl -0x164(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x21550
jmp 0x1ee07
movq -0x160(%rbp), %rdi
movl -0x164(%rbp), %edx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x21550
jmp 0x1ee22
jmp 0x1ee24
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0x1ede6
jmp 0x1ee37
movq -0x160(%rbp), %rdi
callq 0x21300
movq %rax, -0x3f8(%rbp)
jmp 0x1ee4c
movq -0x3f8(%rbp), %rax
movq %rax, -0x160(%rbp)
jmp 0x1ed29
movl $0x7, -0x168(%rbp)
jmp 0x1f18d
movq -0xa0(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
cmpq -0x98(%rbp), %rax
je 0x1ef9c
movl $0x0, -0x174(%rbp)
cmpl $0x3, -0x174(%rbp)
jge 0x1ef97
movq -0x170(%rbp), %rdi
movl -0x174(%rbp), %esi
callq 0x20b60
movq %rax, -0x400(%rbp)
jmp 0x1eec2
movq -0x400(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x180(%rbp), %rdi
callq 0x21380
movl %eax, -0x404(%rbp)
jmp 0x1eee4
movq -0x170(%rbp), %rdi
callq 0x21380
movl %eax, -0x408(%rbp)
jmp 0x1eef8
movl -0x404(%rbp), %eax
movl -0x408(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x1ef0d
jmp 0x1ef83
movq -0x170(%rbp), %rdi
movl -0x174(%rbp), %edx
movl $0x1, %ecx
movl %ecx, %esi
callq 0x21550
jmp 0x1ef28
movq -0x170(%rbp), %rsi
movl -0x174(%rbp), %edx
leaq -0x190(%rbp), %rdi
callq 0x20b80
jmp 0x1ef43
movl -0x174(%rbp), %esi
leaq -0x190(%rbp), %rdi
callq 0x16f80
movl %eax, -0x60(%rbp)
movq -0x180(%rbp), %rdi
movl -0x60(%rbp), %edx
movl $0x1, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x21550
jmp 0x1ef73
movq -0x180(%rbp), %rax
movq %rax, -0x170(%rbp)
jmp 0x1ef97
movl -0x174(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x174(%rbp)
jmp 0x1ee9a
jmp 0x1ee7c
movq -0x10(%rbp), %rax
movq %rax, -0x198(%rbp)
cmpq $0x0, -0x198(%rbp)
je 0x1f022
movq -0x198(%rbp), %rdi
callq 0x21530
movl %eax, -0x40c(%rbp)
jmp 0x1efc5
movq -0x58(%rbp), %rdi
callq 0x21530
movl %eax, -0x410(%rbp)
jmp 0x1efd6
movl -0x40c(%rbp), %eax
movl -0x410(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1effb
movq -0x198(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x21360
jmp 0x1eff9
jmp 0x1effb
jmp 0x1effd
movq -0x198(%rbp), %rdi
callq 0x21300
movq %rax, -0x418(%rbp)
jmp 0x1f012
movq -0x418(%rbp), %rax
movq %rax, -0x198(%rbp)
jmp 0x1efa7
movq -0x388(%rbp), %rdi
callq 0x8d00
movl %eax, -0x41c(%rbp)
jmp 0x1f036
movl -0x41c(%rbp), %eax
cmpl $0x0, %eax
jne 0x1f183
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
cmpq $0x0, -0x1a0(%rbp)
je 0x1f181
movq -0x1a0(%rbp), %rdi
callq 0x21530
movl %eax, -0x420(%rbp)
jmp 0x1f072
movq -0x58(%rbp), %rdi
callq 0x21530
movl %eax, -0x424(%rbp)
jmp 0x1f083
movl -0x420(%rbp), %eax
movl -0x424(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1f157
movl $0x0, -0x1a4(%rbp)
cmpl $0x3, -0x1a4(%rbp)
jge 0x1f155
movq -0x1a0(%rbp), %rdi
movl -0x1a4(%rbp), %edx
xorl %esi, %esi
callq 0x21590
movl %eax, -0x428(%rbp)
jmp 0x1f0ca
movl -0x428(%rbp), %eax
movl %eax, -0x1a8(%rbp)
movq -0x1a0(%rbp), %rdi
movq %rdi, -0x438(%rbp)
movl -0x1a4(%rbp), %edx
movl %edx, -0x430(%rbp)
movl $0x1, %esi
callq 0x21590
movl %eax, -0x42c(%rbp)
jmp 0x1f102
movl -0x42c(%rbp), %ecx
movl -0x430(%rbp), %edx
movq -0x438(%rbp), %rdi
xorl %esi, %esi
callq 0x21550
jmp 0x1f11e
movq -0x1a0(%rbp), %rdi
movl -0x1a4(%rbp), %edx
movl -0x1a8(%rbp), %ecx
negl %ecx
movl $0x1, %esi
callq 0x21550
jmp 0x1f13f
jmp 0x1f141
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x1f0a1
jmp 0x1f157
jmp 0x1f159
movq -0x1a0(%rbp), %rdi
callq 0x21300
movq %rax, -0x440(%rbp)
jmp 0x1f16e
movq -0x440(%rbp), %rax
movq %rax, -0x1a0(%rbp)
jmp 0x1f050
jmp 0x1f183
movl $0x0, -0x168(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x21460
movl -0x168(%rbp), %eax
testl %eax, %eax
je 0x1f1a7
jmp 0x1f1a5
jmp 0x1f1a9
jmp 0x1f1a9
movq -0x58(%rbp), %rdi
callq 0x21300
movq %rax, -0x58(%rbp)
jmp 0x1e81d
leaq -0x118(%rbp), %rdi
callq 0x21460
jmp 0x1fcca
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
cmpq $0x0, -0x1b0(%rbp)
je 0x1fcbf
movq -0x1b0(%rbp), %rdi
callq 0x21380
cmpl $-0x1, %eax
jne 0x1f207
movq -0x1b0(%rbp), %rdi
callq 0x21530
cmpl $-0x1, %eax
jne 0x1f20c
jmp 0x1fc99
movq -0x1b0(%rbp), %rdi
movl $0x3, %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21200
cmpl $0x4, %eax
jne 0x1f266
movq -0x1b0(%rbp), %rdi
movl $0x3, %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21320
cmpl $0x2, %eax
jne 0x1f266
movq -0x1b0(%rbp), %rdi
movl $0x3, %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21340
cmpl $0x1, %eax
je 0x1f26b
jmp 0x1fc99
movb $0x1, -0x1b1(%rbp)
movl $0x0, -0x1b8(%rbp)
cmpl $0x3, -0x1b8(%rbp)
jge 0x1f2cb
movq -0x1b0(%rbp), %rdi
movl -0x1b8(%rbp), %esi
callq 0x20b60
movq %rax, %rdi
movl $0x3, %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21200
cmpl $0x6, %eax
jne 0x1f2b8
movb $0x0, -0x1b1(%rbp)
jmp 0x1f2ba
movl -0x1b8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b8(%rbp)
jmp 0x1f27c
testb $0x1, -0x1b1(%rbp)
jne 0x1f2d9
jmp 0x1fc99
movl $0x0, -0x1bc(%rbp)
movq -0x1b0(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
movl $0x3, %edx
callq 0x20b80
leaq -0x1d0(%rbp), %rdi
movl $0x3, %esi
callq 0x16f80
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movb %al, -0x1bd(%rbp)
movl $0x3, -0x1e0(%rbp)
movb -0x1bd(%rbp), %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x1dc(%rbp)
movl $0x1, -0x1d8(%rbp)
movl $0x3, -0x1d4(%rbp)
movq -0x1b0(%rbp), %rsi
leaq -0x200(%rbp), %rdi
movl $0x3, %edx
callq 0x20b80
leaq -0x1f0(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x16fa0
movq -0x1b0(%rbp), %rax
movq %rax, -0x208(%rbp)
movl $0x0, -0x20c(%rbp)
cmpl $0x4, -0x20c(%rbp)
jge 0x1f490
movq -0x208(%rbp), %rsi
leaq -0x230(%rbp), %rdi
movl $0x3, %edx
callq 0x20b80
leaq -0x220(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x16fa0
movslq -0x20c(%rbp), %rax
movl -0x1e0(%rbp,%rax,4), %esi
leaq -0x220(%rbp), %rdi
callq 0x16f80
movl %eax, -0x210(%rbp)
movq -0x208(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x21360
movq -0x208(%rbp), %rdi
movl -0x210(%rbp), %edx
movl $0x1, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x21550
movq -0x208(%rbp), %rsi
movl -0x210(%rbp), %edx
leaq -0x240(%rbp), %rdi
callq 0x20b80
movl -0x210(%rbp), %esi
leaq -0x240(%rbp), %rdi
callq 0x16f80
movl %eax, -0x1bc(%rbp)
movq -0x208(%rbp), %rdi
movl -0x210(%rbp), %esi
callq 0x20b60
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rdi
movl -0x1bc(%rbp), %edx
movl $0x1, %ecx
movl %ecx, %esi
callq 0x21550
movl -0x20c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20c(%rbp)
jmp 0x1f394
movq -0x208(%rbp), %rax
cmpq -0x1b0(%rbp), %rax
je 0x1f532
leaq -0x261(%rbp), %rdi
movq %rdi, -0x448(%rbp)
callq 0x3560
movq -0x448(%rbp), %rdx
leaq 0x82b6(%rip), %rsi      # 0x2777b
leaq -0x260(%rbp), %rdi
callq 0x4e10
jmp 0x1f4d3
leaq -0x260(%rbp), %rdi
callq 0x4d40
jmp 0x1f4e1
leaq -0x260(%rbp), %rdi
callq 0x35f8
leaq -0x261(%rbp), %rdi
callq 0x3360
jmp 0x1f532
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f521
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x35f8
leaq -0x261(%rbp), %rdi
callq 0x3360
jmp 0x1fcca
testb $0x1, -0x1bd(%rbp)
je 0x1f551
leaq -0x1f0(%rbp), %rdi
xorl %esi, %esi
callq 0x16f80
movl %eax, -0x44c(%rbp)
jmp 0x1f568
leaq -0x1f0(%rbp), %rdi
movl $0x2, %esi
callq 0x16f80
movl %eax, -0x44c(%rbp)
movl -0x44c(%rbp), %eax
movl %eax, -0x268(%rbp)
testb $0x1, -0x1bd(%rbp)
je 0x1f596
leaq -0x1f0(%rbp), %rdi
movl $0x1, %esi
callq 0x16f80
movl %eax, -0x450(%rbp)
jmp 0x1f5aa
leaq -0x1f0(%rbp), %rdi
xorl %esi, %esi
callq 0x16f80
movl %eax, -0x450(%rbp)
movl -0x450(%rbp), %eax
movl %eax, -0x26c(%rbp)
movq -0x1b0(%rbp), %rdi
movl -0x268(%rbp), %esi
callq 0x20b60
movq %rax, -0x278(%rbp)
movq -0x1b0(%rbp), %rdi
movl -0x26c(%rbp), %esi
callq 0x20b60
movq %rax, -0x280(%rbp)
movq -0x1b0(%rbp), %rdi
movl -0x268(%rbp), %edx
xorl %esi, %esi
movl %esi, -0x460(%rbp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, -0x45c(%rbp)
callq 0x21550
movl -0x460(%rbp), %esi
movq -0x1b0(%rbp), %rdi
movl -0x26c(%rbp), %edx
movl $0x1, %ecx
movl %ecx, -0x464(%rbp)
callq 0x21550
movq -0x1b0(%rbp), %rsi
movl -0x26c(%rbp), %edx
leaq -0x290(%rbp), %rdi
movq %rdi, -0x478(%rbp)
callq 0x20b80
movq -0x478(%rbp), %rdi
movl -0x26c(%rbp), %esi
callq 0x16f80
movl -0x460(%rbp), %esi
movl -0x45c(%rbp), %ecx
movl %eax, -0x1bc(%rbp)
movq -0x280(%rbp), %rdi
movl -0x1bc(%rbp), %edx
callq 0x21550
movq -0x1b0(%rbp), %rsi
movl -0x268(%rbp), %edx
leaq -0x2a0(%rbp), %rdi
movq %rdi, -0x470(%rbp)
callq 0x20b80
movq -0x470(%rbp), %rdi
movl -0x268(%rbp), %esi
callq 0x16f80
movl -0x464(%rbp), %ecx
movl -0x460(%rbp), %esi
movl %eax, -0x1bc(%rbp)
movq -0x278(%rbp), %rdi
movl -0x1bc(%rbp), %edx
callq 0x21550
movq -0x278(%rbp), %rdi
callq 0x21380
movl -0x460(%rbp), %esi
movl %eax, -0x2a4(%rbp)
movq -0x278(%rbp), %rdi
callq 0x21360
movq -0x280(%rbp), %rdi
callq 0x21380
movl -0x45c(%rbp), %esi
movl %eax, -0x2a8(%rbp)
movq -0x280(%rbp), %rdi
callq 0x21360
leaq -0x2f8(%rbp), %rdi
movq %rdi, -0x458(%rbp)
callq 0x213a0
movq -0x458(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x213d0
jmp 0x1f74c
jmp 0x1f74e
movq -0x280(%rbp), %rdi
callq 0x21380
movl %eax, -0x47c(%rbp)
jmp 0x1f762
movl -0x47c(%rbp), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x47d(%rbp)
jne 0x1f797
leaq -0x2f8(%rbp), %rdi
callq 0x21400
movb %al, -0x47e(%rbp)
jmp 0x1f789
movb -0x47e(%rbp), %al
xorb $-0x1, %al
movb %al, -0x47d(%rbp)
movb -0x47d(%rbp), %al
testb $0x1, %al
jne 0x1f7a6
jmp 0x1f8b4
leaq -0x2f8(%rbp), %rdi
callq 0x21420
movq %rax, -0x488(%rbp)
jmp 0x1f7bb
movq -0x488(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x300(%rbp)
leaq -0x2f8(%rbp), %rdi
callq 0x21440
jmp 0x1f7da
movl $0x0, -0x304(%rbp)
cmpl $0x3, -0x304(%rbp)
jge 0x1f8af
movq -0x300(%rbp), %rdi
movl -0x304(%rbp), %esi
callq 0x20b60
movq %rax, -0x490(%rbp)
jmp 0x1f80c
movq -0x490(%rbp), %rax
movq %rax, -0x310(%rbp)
movq -0x310(%rbp), %rdi
callq 0x21380
movl %eax, -0x494(%rbp)
jmp 0x1f82e
movl -0x494(%rbp), %eax
cmpl $-0x1, %eax
jne 0x1f899
movq -0x310(%rbp), %rax
movq %rax, -0x4a0(%rbp)
movq -0x300(%rbp), %rdi
callq 0x21380
movl %eax, -0x498(%rbp)
jmp 0x1f85b
movq -0x4a0(%rbp), %rdi
movl -0x498(%rbp), %esi
incl %esi
callq 0x21360
jmp 0x1f871
leaq -0x2f8(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x213d0
jmp 0x1f886
jmp 0x1f899
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1fcb1
jmp 0x1f89b
movl -0x304(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x304(%rbp)
jmp 0x1f7e4
jmp 0x1f74e
movq -0x280(%rbp), %rdi
callq 0x21380
movl %eax, -0x4a4(%rbp)
jmp 0x1f8c8
movl -0x4a4(%rbp), %eax
cmpl $-0x1, %eax
jne 0x1faac
leaq -0x331(%rbp), %rdi
movq %rdi, -0x4b0(%rbp)
callq 0x3560
movq -0x4b0(%rbp), %rdx
leaq 0x7e7d(%rip), %rsi      # 0x27775
leaq -0x330(%rbp), %rdi
callq 0x4e10
jmp 0x1f906
leaq -0x330(%rbp), %rdi
movl $0x3, %esi
callq 0x4c10
jmp 0x1f919
leaq -0x330(%rbp), %rdi
callq 0x35f8
leaq -0x331(%rbp), %rdi
callq 0x3360
movq -0x278(%rbp), %rdi
movl -0x2a4(%rbp), %esi
callq 0x21360
jmp 0x1f945
movq -0x280(%rbp), %rdi
movl -0x2a8(%rbp), %esi
callq 0x21360
jmp 0x1f959
movq -0x10(%rbp), %rax
movq %rax, -0x340(%rbp)
cmpq $0x0, -0x340(%rbp)
je 0x1fa9d
movq -0x340(%rbp), %rdi
callq 0x21530
movl %eax, -0x4b4(%rbp)
jmp 0x1f986
movq -0x1b0(%rbp), %rdi
callq 0x21530
movl %eax, -0x4b8(%rbp)
jmp 0x1f99a
movl -0x4b4(%rbp), %eax
movl -0x4b8(%rbp), %ecx
cmpl %ecx, %eax
je 0x1f9e6
jmp 0x1fa75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f9d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x330(%rbp), %rdi
callq 0x35f8
leaq -0x331(%rbp), %rdi
callq 0x3360
jmp 0x1fcb1
movq -0x340(%rbp), %rdi
callq 0x21380
movl %eax, -0x4bc(%rbp)
jmp 0x1f9fa
movl -0x4bc(%rbp), %eax
cmpl $-0x2, %eax
je 0x1fa1a
movq -0x340(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x21360
jmp 0x1fa18
jmp 0x1fa1a
movl $0x0, -0x344(%rbp)
cmpl $0x4, -0x344(%rbp)
jge 0x1fa73
movq -0x340(%rbp), %rdi
movl -0x344(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x21550
jmp 0x1fa45
movq -0x340(%rbp), %rdi
movl -0x344(%rbp), %edx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x21550
jmp 0x1fa60
jmp 0x1fa62
movl -0x344(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x344(%rbp)
jmp 0x1fa24
jmp 0x1fa75
movq -0x340(%rbp), %rdi
callq 0x21300
movq %rax, -0x4c8(%rbp)
jmp 0x1fa8a
movq -0x4c8(%rbp), %rax
movq %rax, -0x340(%rbp)
jmp 0x1f964
movl $0x2c, -0x168(%rbp)
jmp 0x1fc7d
movq -0x280(%rbp), %rax
movq %rax, -0x350(%rbp)
movq $0x0, -0x358(%rbp)
movq -0x350(%rbp), %rax
cmpq -0x278(%rbp), %rax
je 0x1fbea
movl $0x0, -0x35c(%rbp)
cmpl $0x3, -0x35c(%rbp)
jge 0x1fbd5
movq -0x350(%rbp), %rdi
movl -0x35c(%rbp), %esi
callq 0x20b60
movq %rax, -0x4d0(%rbp)
jmp 0x1fb0b
movq -0x4d0(%rbp), %rax
movq %rax, -0x358(%rbp)
movq -0x358(%rbp), %rdi
callq 0x21380
movl %eax, -0x4d4(%rbp)
jmp 0x1fb2d
movq -0x350(%rbp), %rdi
callq 0x21380
movl %eax, -0x4d8(%rbp)
jmp 0x1fb41
movl -0x4d4(%rbp), %eax
movl -0x4d8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x1fb56
jmp 0x1fbc1
movq -0x350(%rbp), %rdi
movl -0x35c(%rbp), %edx
xorl %esi, %esi
movl $0x1, %ecx
callq 0x21550
jmp 0x1fb71
movq -0x350(%rbp), %rsi
movl -0x35c(%rbp), %edx
leaq -0x36c(%rbp), %rdi
callq 0x20b80
jmp 0x1fb8c
movl -0x35c(%rbp), %esi
leaq -0x36c(%rbp), %rdi
callq 0x16f80
movl %eax, -0x1bc(%rbp)
movq -0x358(%rbp), %rdi
movl -0x1bc(%rbp), %edx
xorl %esi, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x21550
jmp 0x1fbbf
jmp 0x1fbd5
movl -0x35c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x35c(%rbp)
jmp 0x1fae3
jmp 0x1fbd7
movq -0x358(%rbp), %rax
movq %rax, -0x350(%rbp)
jmp 0x1fac5
movq -0x10(%rbp), %rax
movq %rax, -0x378(%rbp)
cmpq $0x0, -0x378(%rbp)
je 0x1fc73
movq -0x378(%rbp), %rdi
callq 0x21530
movl %eax, -0x4dc(%rbp)
jmp 0x1fc13
movq -0x1b0(%rbp), %rdi
callq 0x21530
movl %eax, -0x4e0(%rbp)
jmp 0x1fc27
movl -0x4dc(%rbp), %eax
movl -0x4e0(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1fc4c
movq -0x378(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x21360
jmp 0x1fc4a
jmp 0x1fc4c
jmp 0x1fc4e
movq -0x378(%rbp), %rdi
callq 0x21300
movq %rax, -0x4e8(%rbp)
jmp 0x1fc63
movq -0x4e8(%rbp), %rax
movq %rax, -0x378(%rbp)
jmp 0x1fbf5
movl $0x0, -0x168(%rbp)
leaq -0x2f8(%rbp), %rdi
callq 0x21460
movl -0x168(%rbp), %eax
testl %eax, %eax
je 0x1fc97
jmp 0x1fc95
jmp 0x1fc99
jmp 0x1fc99
movq -0x1b0(%rbp), %rdi
callq 0x21300
movq %rax, -0x1b0(%rbp)
jmp 0x1f1d7
leaq -0x2f8(%rbp), %rdi
callq 0x21460
jmp 0x1fcca
jmp 0x1fcc1
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3550
nopw %cs:(%rax,%rax)