// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::add_interface_block(spv::StorageClass)
uint32_t CompilerMSL::add_interface_block(StorageClass storage)
{
	// Accumulate the variables that should appear in the interface struct
	vector<SPIRVariable *> vars;
	bool incl_builtins = (storage == StorageClassOutput);
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeVariable)
		{
			auto &var = id.get<SPIRVariable>();
			auto &type = get<SPIRType>(var.basetype);
			if (var.storage == storage && interface_variable_exists_in_entry_point(var.self) &&
			    !is_hidden_variable(var, incl_builtins) && type.pointer)
			{
				vars.push_back(&var);
			}
		}
	}

	// If no variables qualify, leave
	if (vars.empty())
		return 0;

	// Add a new typed variable for this interface structure.
	// The initializer expression is allocated here, but populated when the function
	// declaraion is emitted, because it is cleared after each compilation pass.
	uint32_t next_id = ir.increase_bound_by(3);
	uint32_t ib_type_id = next_id++;
	auto &ib_type = set<SPIRType>(ib_type_id);
	ib_type.basetype = SPIRType::Struct;
	ib_type.storage = storage;
	set_decoration(ib_type_id, DecorationBlock);

	uint32_t ib_var_id = next_id++;
	auto &var = set<SPIRVariable>(ib_var_id, ib_type_id, storage, 0);
	var.initializer = next_id++;

	string ib_var_ref;
	switch (storage)
	{
	case StorageClassInput:
		ib_var_ref = stage_in_var_name;
		break;

	case StorageClassOutput:
	{
		ib_var_ref = stage_out_var_name;

		// Add the output interface struct as a local variable to the entry function.
		// If the entry point should return the output struct, set the entry function
		// to return the output interface struct, otherwise to return nothing.
		// Indicate the output var requires early initialization.
		bool ep_should_return_output = !get_is_rasterization_disabled();
		uint32_t rtn_id = ep_should_return_output ? ib_var_id : 0;
		auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
		entry_func.add_local_variable(ib_var_id);
		for (auto &blk_id : entry_func.blocks)
		{
			auto &blk = get<SPIRBlock>(blk_id);
			if (blk.terminator == SPIRBlock::Return)
				blk.return_value = rtn_id;
		}
		vars_needing_early_declaration.push_back(ib_var_id);
		break;
	}

	default:
		break;
	}

	set_name(ib_type_id, to_name(ir.default_entry_point) + "_" + ib_var_ref);
	set_name(ib_var_id, ib_var_ref);

	auto &entry_func = get<SPIRFunction>(ir.default_entry_point);

	for (auto p_var : vars)
	{
		uint32_t type_id = p_var->basetype;
		auto &type = get<SPIRType>(type_id);

		if (type.basetype == SPIRType::Struct)
		{
			if (!is_builtin_type(type))
			{
				// For I/O blocks or structs, we will need to pass the block itself around
				// to functions if they are used globally in leaf functions.
				// Rather than passing down member by member,
				// we unflatten I/O blocks while running the shader,
				// and pass the actual struct type down to leaf functions.
				// We then unflatten inputs, and flatten outputs in the "fixup" stages.
				entry_func.add_local_variable(p_var->self);
				vars_needing_early_declaration.push_back(p_var->self);
			}

			// Flatten the struct members into the interface struct
			uint32_t mbr_idx = 0;
			for (auto &mbr_type_id : type.member_types)
			{
				BuiltIn builtin;
				bool is_builtin = is_member_builtin(type, mbr_idx, &builtin);
				bool is_flat = has_member_decoration(type.self, mbr_idx, DecorationFlat) ||
				               has_decoration(p_var->self, DecorationFlat);
				bool is_noperspective = has_member_decoration(type.self, mbr_idx, DecorationNoPerspective) ||
				                        has_decoration(p_var->self, DecorationNoPerspective);
				bool is_centroid = has_member_decoration(type.self, mbr_idx, DecorationCentroid) ||
				                   has_decoration(p_var->self, DecorationCentroid);
				bool is_sample = has_member_decoration(type.self, mbr_idx, DecorationSample) ||
				                 has_decoration(p_var->self, DecorationSample);

				if (!is_builtin || has_active_builtin(builtin, storage))
				{
					// Add a reference to the member to the interface struct.
					uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
					mbr_type_id = ensure_correct_builtin_type(mbr_type_id, builtin);
					type.member_types[mbr_idx] = mbr_type_id;
					ib_type.member_types.push_back(mbr_type_id);

					// Give the member a name
					string mbr_name = ensure_valid_name(to_qualified_member_name(type, mbr_idx), "m");
					set_member_name(ib_type_id, ib_mbr_idx, mbr_name);

					// Update the original variable reference to include the structure reference
					string qual_var_name = ib_var_ref + "." + mbr_name;

					if (is_builtin)
					{
						// For the builtin gl_PerVertex, we cannot treat it as a block anyways,
						// so redirect to qualified name.
						set_member_qualified_name(type_id, mbr_idx, qual_var_name);
					}
					else
					{
						// Unflatten or flatten from [[stage_in]] or [[stage_out]] as appropriate.
						switch (storage)
						{
						case StorageClassInput:
							entry_func.fixup_hooks_in.push_back([=]() {
								statement(to_name(p_var->self), ".", to_member_name(type, mbr_idx), " = ",
								          qual_var_name, ";");
							});
							break;

						case StorageClassOutput:
							entry_func.fixup_hooks_out.push_back([=]() {
								statement(qual_var_name, " = ", to_name(p_var->self), ".",
								          to_member_name(type, mbr_idx), ";");
							});
							break;

						default:
							break;
						}
					}

					// Copy the variable location from the original variable to the member
					if (has_member_decoration(type_id, mbr_idx, DecorationLocation))
					{
						uint32_t locn = get_member_decoration(type_id, mbr_idx, DecorationLocation);
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
						mark_location_as_used_by_shader(locn, storage);
					}
					else if (has_decoration(p_var->self, DecorationLocation))
					{
						// The block itself might have a location and in this case, all members of the block
						// receive incrementing locations.
						uint32_t locn = get_decoration(p_var->self, DecorationLocation) + mbr_idx;
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
						mark_location_as_used_by_shader(locn, storage);
					}

					// Copy the component location, if present.
					if (has_member_decoration(type_id, mbr_idx, DecorationComponent))
					{
						uint32_t comp = get_member_decoration(type_id, mbr_idx, DecorationComponent);
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationComponent, comp);
					}

					// Mark the member as builtin if needed
					if (is_builtin)
					{
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationBuiltIn, builtin);
						if (builtin == BuiltInPosition)
							qual_pos_var_name = qual_var_name;
					}

					// Copy interpolation decorations if needed
					if (is_flat)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationFlat);
					if (is_noperspective)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationNoPerspective);
					if (is_centroid)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationCentroid);
					if (is_sample)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationSample);
				}
				mbr_idx++;
			}
		}
		else if (type.basetype == SPIRType::Boolean || type.basetype == SPIRType::Char ||
		         type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt ||
		         type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64 ||
		         type_is_floating_point(type) || type.basetype == SPIRType::Boolean)
		{
			bool is_builtin = is_builtin_variable(*p_var);
			BuiltIn builtin = BuiltIn(get_decoration(p_var->self, DecorationBuiltIn));
			bool is_flat = has_decoration(p_var->self, DecorationFlat);
			bool is_noperspective = has_decoration(p_var->self, DecorationNoPerspective);
			bool is_centroid = has_decoration(p_var->self, DecorationCentroid);
			bool is_sample = has_decoration(p_var->self, DecorationSample);

			if (!is_builtin || has_active_builtin(builtin, storage))
			{
				// MSL does not allow matrices or arrays in input or output variables, so need to handle it specially.
				if (!is_builtin && (storage == StorageClassInput || storage == StorageClassOutput) &&
				    (is_matrix(type) || is_array(type)))
				{
					uint32_t elem_cnt = 0;

					if (is_matrix(type))
					{
						if (is_array(type))
							SPIRV_CROSS_THROW("MSL cannot emit arrays-of-matrices in input and output variables.");

						elem_cnt = type.columns;
					}
					else if (is_array(type))
					{
						if (type.array.size() != 1)
							SPIRV_CROSS_THROW("MSL cannot emit arrays-of-arrays in input and output variables.");

						elem_cnt = type.array_size_literal.back() ? type.array.back() :
						                                            get<SPIRConstant>(type.array.back()).scalar();
					}

					auto *usable_type = &type;
					while (is_array(*usable_type) || is_matrix(*usable_type))
						usable_type = &get<SPIRType>(usable_type->parent_type);

					entry_func.add_local_variable(p_var->self);

					// We need to declare the variable early and at entry-point scope.
					vars_needing_early_declaration.push_back(p_var->self);

					for (uint32_t i = 0; i < elem_cnt; i++)
					{
						// Add a reference to the variable type to the interface struct.
						uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
						ib_type.member_types.push_back(usable_type->self);

						// Give the member a name
						string mbr_name = ensure_valid_name(join(to_expression(p_var->self), "_", i), "m");
						set_member_name(ib_type_id, ib_mbr_idx, mbr_name);

						// There is no qualified alias since we need to flatten the internal array on return.
						if (get_decoration_bitset(p_var->self).get(DecorationLocation))
						{
							uint32_t locn = get_decoration(p_var->self, DecorationLocation) + i;
							set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
							mark_location_as_used_by_shader(locn, storage);
						}

						if (get_decoration_bitset(p_var->self).get(DecorationIndex))
						{
							uint32_t index = get_decoration(p_var->self, DecorationIndex);
							set_member_decoration(ib_type_id, ib_mbr_idx, DecorationIndex, index);
						}

						// Copy interpolation decorations if needed
						if (is_flat)
							set_member_decoration(ib_type_id, ib_mbr_idx, DecorationFlat);
						if (is_noperspective)
							set_member_decoration(ib_type_id, ib_mbr_idx, DecorationNoPerspective);
						if (is_centroid)
							set_member_decoration(ib_type_id, ib_mbr_idx, DecorationCentroid);
						if (is_sample)
							set_member_decoration(ib_type_id, ib_mbr_idx, DecorationSample);

						switch (storage)
						{
						case StorageClassInput:
							entry_func.fixup_hooks_in.push_back([=]() {
								statement(to_name(p_var->self), "[", i, "] = ", ib_var_ref, ".", mbr_name, ";");
							});
							break;

						case StorageClassOutput:
							entry_func.fixup_hooks_out.push_back([=]() {
								statement(ib_var_ref, ".", mbr_name, " = ", to_name(p_var->self), "[", i, "];");
							});
							break;

						default:
							break;
						}
					}
				}
				else
				{
					// Add a reference to the variable type to the interface struct.
					uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
					type_id = ensure_correct_builtin_type(type_id, builtin);
					p_var->basetype = type_id;
					ib_type.member_types.push_back(type_id);

					// Give the member a name
					string mbr_name = ensure_valid_name(to_expression(p_var->self), "m");
					set_member_name(ib_type_id, ib_mbr_idx, mbr_name);

					// Update the original variable reference to include the structure reference
					string qual_var_name = ib_var_ref + "." + mbr_name;
					ir.meta[p_var->self].decoration.qualified_alias = qual_var_name;

					// Copy the variable location from the original variable to the member
					if (get_decoration_bitset(p_var->self).get(DecorationLocation))
					{
						uint32_t locn = get_decoration(p_var->self, DecorationLocation);
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
						mark_location_as_used_by_shader(locn, storage);
					}

					if (get_decoration_bitset(p_var->self).get(DecorationComponent))
					{
						uint32_t comp = get_decoration(p_var->self, DecorationComponent);
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationComponent, comp);
					}

					if (get_decoration_bitset(p_var->self).get(DecorationIndex))
					{
						uint32_t index = get_decoration(p_var->self, DecorationIndex);
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationIndex, index);
					}

					// Mark the member as builtin if needed
					if (is_builtin)
					{
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationBuiltIn, builtin);
						if (builtin == BuiltInPosition)
							qual_pos_var_name = qual_var_name;
					}

					// Copy interpolation decorations if needed
					if (is_flat)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationFlat);
					if (is_noperspective)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationNoPerspective);
					if (is_centroid)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationCentroid);
					if (is_sample)
						set_member_decoration(ib_type_id, ib_mbr_idx, DecorationSample);
				}
			}
		}
	}

	// Sort the members of the structure by their locations.
	MemberSorter member_sorter(ib_type, ir.meta[ib_type_id], MemberSorter::Location);
	member_sorter.sort();

	return ib_var_id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp            # imm = 0x318
movl %esi, 0x14(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x1e0(%rsp)
movq $0x0, 0x1f0(%rsp)
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r14
cmpq %r14, %r15
je 0x89f68
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
cmpl $0x2, 0x8(%r15)
jne 0x89e3c
movq %r15, %rdi
callq 0xb2a4
movq %rax, %r12
movl 0xc(%rax), %esi
movq %rbx, %rdi
callq 0xa3ea
movq %rax, %r13
movl 0x10(%r12), %eax
cmpl 0x14(%rsp), %eax
jne 0x89e3c
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x13e3a
testb %al, %al
je 0x89e3c
xorl %edx, %edx
cmpl $0x3, %ebp
sete %dl
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13202
testb %al, %al
jne 0x89e3c
cmpb $0x1, 0x60(%r13)
jne 0x89e3c
movq %r12, 0xa8(%rsp)
movq 0x1e8(%rsp), %rsi
cmpq 0x1f0(%rsp), %rsi
je 0x89e27
movq %r12, (%rsi)
addq $0x8, 0x1e8(%rsp)
jmp 0x89e3c
leaq 0x1e0(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x7e400
addq $0x10, %r15
cmpq %r14, %r15
jne 0x89da1
movq 0x1e0(%rsp), %rdi
cmpq 0x1e8(%rsp), %rdi
je 0x89f6f
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x24f8a
movl %eax, %r14d
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movl %eax, %esi
callq 0x1bafc
movq %rax, %r15
movl $0xc, 0xc(%rax)
movl 0x14(%rsp), %eax
movl %eax, 0x64(%r15)
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x14d16
leal 0x1(%r14), %esi
movl %esi, 0x2c(%rsp)
leaq 0xa8(%rsp), %r8
movl $0x0, (%r8)
leaq 0xc(%rsp), %rdx
leaq 0x14(%rsp), %rcx
movq %rbx, %rdi
callq 0xa35fa
movq %r15, 0x78(%rsp)
addl $0x2, %r14d
movl %r14d, 0x18(%rax)
leaq 0x1d0(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x14(%rsp), %eax
cmpl $0x1, %eax
je 0x89f76
cmpl $0x3, %eax
jne 0x89ffb
leaq 0x980(%rbx), %rsi
leaq 0x1c0(%rsp), %rdi
callq 0x6170
cmpb $0x0, 0x937(%rbx)
je 0x89f32
movq %rbx, %rdi
callq 0x15e8a
movl 0xb8(%rax), %ebp
testl %ebp, %ebp
je 0x89f36
movl 0x2c(%rsp), %ebp
movl 0x108(%rbx), %esi
movq %rbx, %rdi
callq 0xb98a
movq %rax, %r14
movl 0x2c(%rsp), %eax
movl %eax, 0xa8(%rsp)
movq 0x50(%r14), %rsi
cmpq 0x58(%r14), %rsi
je 0x89f8c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%r14)
jmp 0x89fa0
xorl %ebx, %ebx
jmp 0x8bb8d
xorl %ebx, %ebx
jmp 0x8bb78
leaq 0x960(%rbx), %rsi
leaq 0x1c0(%rsp), %rdi
callq 0x6170
jmp 0x89ffb
movq %r14, %rdi
addq $0x48, %rdi
leaq 0xa8(%rsp), %rdx
callq 0x797e
movq 0x68(%r14), %r15
movq 0x70(%r14), %r14
cmpq %r14, %r15
je 0x89fc7
movl (%r15), %esi
movq %rbx, %rdi
callq 0x7870
cmpl $0x4, 0xc(%rax)
jne 0x89fc1
movl %ebp, 0x24(%rax)
addq $0x4, %r15
jmp 0x89fa8
movq 0x8e8(%rbx), %rsi
cmpq 0x8f0(%rbx), %rsi
je 0x89fea
movl 0x2c(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8e8(%rbx)
jmp 0x89ffb
leaq 0x8e0(%rbx), %rdi
leaq 0x2c(%rsp), %rdx
callq 0x797e
movl 0xc(%rsp), %ebp
movl 0x108(%rbx), %edx
movq (%rbx), %rax
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq *0x38(%rax)
leaq 0x33f98(%rip), %rsi     # 0xbdfb7
leaq 0x30(%rsp), %rdi
callq 0x64e0
leaq 0x60(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8a050
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
jmp 0x8a056
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x50(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
callq 0x60b0
leaq 0xb8(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8a0b7
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0x8a0bd
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rsi
leaq 0xa8(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14a44
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8a10b
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x8a127
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a142
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x2c(%rsp), %esi
leaq 0x1c0(%rsp), %rdx
movq %rbx, %rdi
callq 0x14a44
movl 0x108(%rbx), %esi
movq %rbx, %rdi
callq 0xb98a
movq %rax, 0x1f8(%rsp)
movq 0x1e0(%rsp), %rsi
movq 0x1e8(%rsp), %rax
movq %rax, 0x2a0(%rsp)
cmpq %rax, %rsi
je 0x8bb17
movq 0x1f8(%rsp), %rdx
leaq 0x48(%rdx), %rax
movq %rax, 0x238(%rsp)
leaq 0x8e0(%rbx), %rax
movq %rax, 0x230(%rsp)
movq 0x78(%rsp), %rax
addq $0x68, %rax
movq %rax, 0x208(%rsp)
movl $0x98, %edi
leaq (%rdx,%rdi), %rax
movq %rax, 0x250(%rsp)
leaq 0xa8(%rsp), %rcx
addq %rcx, %rdi
movq %rdi, 0x298(%rsp)
movl $0xb0, %eax
addq %rax, %rcx
movq %rcx, 0x200(%rsp)
addq %rax, %rdx
movq %rdx, 0x248(%rsp)
leaq 0x721d9(%rip), %rax     # 0xfc3e0
addq $0x10, %rax
movq %rax, 0x1b8(%rsp)
leaq 0x940(%rbx), %rax
movq %rax, 0x240(%rsp)
leaq 0x210(%rsp), %r15
movq %rsi, 0x2a8(%rsp)
movq (%rsi), %rax
movq %rax, 0x20(%rsp)
movl 0xc(%rax), %esi
movl %esi, 0x1c(%rsp)
movq %rbx, %rdi
callq 0xa3ea
movq %rax, %r13
movl 0xc(%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0x6, %ecx
jae 0x8a3a5
movq %rbx, %rdi
movq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x13330
movb %al, 0x18(%rsp)
movl 0x8(%r12), %esi
movq %rbx, %rdi
movl $0xb, %edx
callq 0x14e6e
movl %eax, %r14d
leaq 0x8(%r12), %rbp
movl (%rbp), %esi
movq %rbx, %rdi
movl $0xe, %edx
callq 0x12974
movb %al, 0x10(%rsp)
movl (%rbp), %esi
movq %rbx, %rdi
movl $0xd, %edx
callq 0x12974
movb %al, 0x13(%rsp)
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x12974
movb %al, 0x12(%rsp)
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x11, %edx
callq 0x12974
movb %al, 0x11(%rsp)
movl 0x14(%rsp), %edx
cmpb $0x0, 0x18(%rsp)
je 0x8a2f9
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1a1a0
testb %al, %al
je 0x8baeb
jmp 0x8a35a
andl $-0x3, %edx
cmpl $0x1, %edx
jne 0x8a35a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13470
testb %al, %al
jne 0x8a31f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13482
testb %al, %al
je 0x8a35a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13470
leaq 0xa8(%rsp), %r12
testb %al, %al
je 0x8a769
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13482
testb %al, %al
jne 0x8bba1
movl 0x18(%r13), %eax
movl %eax, 0x18(%rsp)
jmp 0x8a7e4
movq 0x78(%rsp), %rax
movq 0x70(%rax), %r13
subq 0x68(%rax), %r13
movl 0x1c(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x8ec06
leaq 0xa8(%rsp), %r12
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movl %eax, 0xc(%rcx)
movq 0x78(%rsp), %rcx
movq 0x70(%rcx), %rsi
cmpq 0x78(%rcx), %rsi
je 0x8a3fd
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rcx)
jmp 0x8a40f
cmpl $0xc, %eax
jne 0x8a758
movq %rbx, %rdi
movq %r13, %rsi
callq 0x133a6
testb %al, %al
jne 0x8af87
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xa8(%rsp)
movq 0x1f8(%rsp), %rcx
movq 0x50(%rcx), %rsi
cmpq 0x58(%rcx), %rsi
leaq 0xa8(%rsp), %rdx
je 0x8af43
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rcx)
jmp 0x8af50
movq 0x208(%rsp), %rdi
leaq 0x1c(%rsp), %rdx
callq 0x797e
movl (%rbp), %edx
leaq 0x2b8(%rsp), %rdi
movq %rbx, %rsi
callq 0x33f8a
leaq 0x268(%rsp), %rax
movq %rax, 0x258(%rsp)
leaq 0x258(%rsp), %r15
movq %r15, %rdi
leaq 0x30124(%rip), %rsi     # 0xba568
leaq 0x3011e(%rip), %rdx     # 0xba569
callq 0x7be0
movq %r12, %rdi
leaq 0x2b8(%rsp), %rdx
movq %r15, %rcx
callq 0x8eaca
movq 0x258(%rsp), %rdi
leaq 0x268(%rsp), %rax
cmpq %rax, %rdi
je 0x8a488
movq 0x268(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2b8(%rsp), %rdi
leaq 0x2c8(%rsp), %rax
cmpq %rax, %rdi
je 0x8a4ad
movq 0x2c8(%rsp), %rsi
incq %rsi
callq 0x6260
shrq $0x2, %r13
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movq %r12, %rcx
callq 0x14b52
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xe456
movq %r15, %rdi
leaq 0x30352(%rip), %rsi     # 0xba849
callq 0x64e0
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq %r15, %rdi
callq 0x60b0
leaq 0x60(%rsp), %rsi
movq %rsi, 0x50(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
leaq 0x210(%rsp), %r15
je 0x8a544
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
jmp 0x8a54a
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x58(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x8a57e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6260
movl (%rbp), %eax
movq 0x38(%rbx), %rcx
imulq $0x148, %rax, %rax      # imm = 0x148
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
leaq 0x50(%rsp), %rsi
callq 0x6170
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14e50
testb $0x40, 0x3(%rax)
je 0x8a5e8
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x14e6e
movl %eax, %r12d
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x1e, %ecx
movl %eax, %r8d
callq 0x14b48
movl 0x14(%rsp), %edx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x8ebc0
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14e50
testb $-0x80, 0x3(%rax)
je 0x8a620
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x1f, %edx
callq 0x14e6e
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x1f, %ecx
movl %eax, %r8d
callq 0x14b48
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14e50
movabsq $0x100000000, %rcx      # imm = 0x100000000
testq %rcx, (%rax)
je 0x8a661
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x20, %edx
callq 0x14e6e
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x20, %ecx
movl %eax, %r8d
callq 0x14b48
cmpb $0x0, 0x18(%rsp)
je 0x8a696
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0xb, %ecx
movl %r14d, %r8d
callq 0x14b48
testl %r14d, %r14d
jne 0x8a696
movq 0x240(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6170
cmpb $0x0, 0x10(%rsp)
je 0x8a6b4
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x13(%rsp)
je 0x8a6d2
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0xd, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x12(%rsp)
je 0x8a6f0
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x10, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x11(%rsp)
je 0x8a70e
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x11, %ecx
xorl %r8d, %r8d
callq 0x14b48
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x8a72a
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8baeb
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8baeb
addl $-0x9, %eax
cmpl $0x2, %eax
jbe 0x8a25b
jmp 0x8baeb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13482
movl $0x0, 0x18(%rsp)
testb %al, %al
je 0x8a7e4
movq 0x28(%r13), %rax
movq %rax, %rcx
subq 0x20(%r13), %rcx
cmpq $0x4, %rcx
jne 0x8bc0f
movl 0x50(%r13), %ecx
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq 0x48(%r13), %rcx
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
leaq 0x3f(%r8), %rsi
andq %rdx, %rsi
xorl %edi, %edi
cmpq %r8, %rsi
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rdx, %rcx
movl -0x4(%rax), %esi
jae 0x8bb07
movl %esi, 0x18(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13482
testb %al, %al
jne 0x8a802
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13470
testb %al, %al
je 0x8a816
movl 0x9c(%r13), %esi
movq %rbx, %rdi
callq 0xa3ea
movq %rax, %r13
jmp 0x8a7e4
movl (%rbp), %eax
movl %eax, 0xa8(%rsp)
movq 0x1f8(%rsp), %rcx
movq 0x50(%rcx), %rsi
cmpq 0x58(%rcx), %rsi
je 0x8a83e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rcx)
jmp 0x8a84e
movq 0x238(%rsp), %rdi
movq %r12, %rdx
callq 0x797e
movq 0x8e8(%rbx), %rsi
cmpq 0x8f0(%rbx), %rsi
je 0x8a870
movl (%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8e8(%rbx)
jmp 0x8a880
movq 0x230(%rsp), %rdi
movq %rbp, %rdx
callq 0x797e
movl $0x0, 0x80(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x8baeb
addq $0x8, %r13
movq 0x78(%rsp), %rcx
movq 0x70(%rcx), %rsi
movq %rsi, %r15
subq 0x68(%rcx), %r15
cmpq 0x78(%rcx), %rsi
je 0x8a8c0
movl (%r13), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rcx)
jmp 0x8a8d0
movq 0x208(%rsp), %rdi
movq %r13, %rdx
callq 0x797e
movl (%rbp), %edx
movq %r12, %r14
movq %r12, %rdi
movq %rbx, %rsi
callq 0x33f8a
leaq 0x2d8(%rsp), %rdi
movq %r14, %r12
movq %r14, %rsi
leaq 0x336c1(%rip), %rdx     # 0xbdfb7
leaq 0x80(%rsp), %rcx
callq 0xa3641
leaq 0x288(%rsp), %rax
movq %rax, 0x278(%rsp)
leaq 0x278(%rsp), %r14
movq %r14, %rdi
leaq 0x2fc43(%rip), %rsi     # 0xba568
leaq 0x2fc3d(%rip), %rdx     # 0xba569
callq 0x7be0
leaq 0x50(%rsp), %rdi
leaq 0x2d8(%rsp), %rdx
movq %r14, %rcx
callq 0x8eaca
movq 0x278(%rsp), %rdi
leaq 0x288(%rsp), %rax
cmpq %rax, %rdi
je 0x8a96b
movq 0x288(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2d8(%rsp), %rdi
leaq 0x2e8(%rsp), %rax
cmpq %rax, %rdi
je 0x8a990
movq 0x2e8(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8a9b5
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x6260
shrq $0x2, %r15
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
leaq 0x50(%rsp), %rcx
callq 0x14b52
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14e50
testb $0x40, 0x3(%rax)
je 0x8aa1f
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x14e6e
movl %eax, %r14d
addl 0x80(%rsp), %r14d
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x1e, %ecx
movl %r14d, %r8d
callq 0x14b48
movl 0x14(%rsp), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8ebc0
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14e50
movabsq $0x100000000, %rcx      # imm = 0x100000000
testq %rcx, (%rax)
je 0x8aa60
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x20, %edx
callq 0x14e6e
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x20, %ecx
movl %eax, %r8d
callq 0x14b48
cmpb $0x0, 0x10(%rsp)
je 0x8aa7e
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x13(%rsp)
je 0x8aa9c
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0xd, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x12(%rsp)
je 0x8aaba
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x10, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x11(%rsp)
je 0x8aad8
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x11, %ecx
xorl %r8d, %r8d
callq 0x14b48
movl 0x14(%rsp), %eax
cmpl $0x3, %eax
je 0x8abd8
cmpl $0x1, %eax
leaq 0x210(%rsp), %r15
jne 0x8af08
movq %rbx, 0xa8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0xb0(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0xb8(%rsp)
leaq 0xd0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xc0(%rsp), %rdi
callq 0xe456
leaq 0xf0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0xe0(%rsp), %rdi
callq 0xe456
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x58, %edi
callq 0x6250
movq %rax, %rcx
movl 0xb8(%rsp), %edx
movl %edx, 0x10(%rax)
movups 0xa8(%rsp), %xmm0
movups %xmm0, (%rax)
leaq 0x28(%rax), %rdx
movq %rdx, 0x18(%rax)
movq 0xc0(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
cmpq %rdi, %rsi
je 0x8acb8
movq %rsi, 0x18(%rcx)
movq 0xd0(%rsp), %rdx
movq %rdx, 0x28(%rcx)
jmp 0x8acbe
movq %rbx, 0xa8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xb0(%rsp), %rdi
callq 0xe456
leaq 0x210(%rsp), %r15
leaq 0xe0(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0xd0(%rsp), %rdi
callq 0xe456
movq 0x20(%rsp), %rax
movq %rax, 0xf0(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0xf8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movl $0x58, %edi
callq 0x6250
movq %rax, %rcx
movq 0xa8(%rsp), %rdx
movq %rdx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq 0xb0(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
cmpq %rdi, %rsi
je 0x8add6
movq %rsi, 0x8(%rcx)
movq 0xc0(%rsp), %rdx
movq %rdx, 0x18(%rcx)
jmp 0x8addc
movups (%rdi), %xmm0
movups %xmm0, (%rdx)
movq 0xc8(%rsp), %rdx
movq %rdx, 0x20(%rcx)
movq %rdi, 0xc0(%rsp)
movq $0x0, 0xc8(%rsp)
movb $0x0, 0xd0(%rsp)
addq $0x48, %rax
movq %rax, 0x38(%rcx)
movq 0xe0(%rsp), %rdx
leaq 0xf0(%rsp), %rsi
cmpq %rsi, %rdx
je 0x8ad15
movq %rdx, 0x38(%rcx)
movq 0xf0(%rsp), %rax
movq %rax, 0x48(%rcx)
jmp 0x8ad1b
movups (%rsi), %xmm0
movups %xmm0, (%rax)
movq 0xe8(%rsp), %rax
movq %rax, 0x40(%rcx)
movq %rsi, 0xe0(%rsp)
movq $0x0, 0xe8(%rsp)
movb $0x0, 0xf0(%rsp)
movq %rcx, 0x30(%rsp)
leaq 0x164dd(%rip), %rax     # 0xa122c
movq %rax, 0x48(%rsp)
leaq 0x16587(%rip), %rax     # 0xa12e2
movq %rax, 0x40(%rsp)
movq 0x248(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xa8402
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x8ad8b
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xe0(%rsp), %rdi
leaq 0xf0(%rsp), %rax
cmpq %rax, %rdi
je 0x8adb0
movq 0xf0(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x8af08
movq 0xd0(%rsp), %rsi
jmp 0x8af00
movups (%rdi), %xmm0
movups %xmm0, (%rdx)
movq 0xb8(%rsp), %rdx
movq %rdx, 0x10(%rcx)
movq %rdi, 0xb0(%rsp)
movq $0x0, 0xb8(%rsp)
movb $0x0, 0xc0(%rsp)
addq $0x38, %rax
movq %rax, 0x28(%rcx)
movq 0xd0(%rsp), %rdx
leaq 0xe0(%rsp), %rsi
cmpq %rsi, %rdx
je 0x8ae33
movq %rdx, 0x28(%rcx)
movq 0xe0(%rsp), %rax
movq %rax, 0x38(%rcx)
jmp 0x8ae39
movups (%rsi), %xmm0
movups %xmm0, (%rax)
movq 0xd8(%rsp), %rax
movq %rax, 0x30(%rcx)
movq %rsi, 0xd0(%rsp)
movq $0x0, 0xd8(%rsp)
movb $0x0, 0xe0(%rsp)
leaq 0xf0(%rsp), %rdx
movl 0x8(%rdx), %eax
movl %eax, 0x50(%rcx)
movq (%rdx), %rax
movq %rax, 0x48(%rcx)
movq %rcx, 0x30(%rsp)
leaq 0x16578(%rip), %rax     # 0xa13fa
movq %rax, 0x48(%rsp)
leaq 0x16630(%rip), %rax     # 0xa14be
movq %rax, 0x40(%rsp)
movq 0x250(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xa8402
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x8aebe
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
cmpq %rax, %rdi
je 0x8aee3
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x8af08
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x8af24
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x80(%rsp), %eax
incl %eax
movl %eax, 0x80(%rsp)
cmpl 0x18(%rsp), %eax
jb 0x8a89a
jmp 0x8baeb
movq 0x238(%rsp), %rdi
callq 0x797e
movq 0x20(%rsp), %rax
leaq 0x8(%rax), %rdx
movq 0x8e8(%rbx), %rsi
cmpq 0x8f0(%rbx), %rsi
je 0x8af7a
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8e8(%rbx)
jmp 0x8af87
movq 0x230(%rsp), %rdi
callq 0x797e
movq 0x68(%r13), %r12
movq 0x70(%r13), %rax
movq %rax, 0x2b0(%rsp)
cmpq %rax, %r12
je 0x8baeb
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
leaq 0x74(%rsp), %rcx
callq 0x133ea
movb %al, 0x10(%rsp)
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0xe, %ecx
callq 0x1406a
movb $0x1, %r14b
testb %al, %al
jne 0x8afea
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0xe, %edx
callq 0x12974
movl %eax, %r14d
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0xd, %ecx
callq 0x1406a
movb $0x1, 0x13(%rsp)
testb %al, %al
jne 0x8b01f
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0xd, %edx
callq 0x12974
movb %al, 0x13(%rsp)
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x10, %ecx
callq 0x1406a
movb $0x1, 0x12(%rsp)
testb %al, %al
jne 0x8b054
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x12974
movb %al, 0x12(%rsp)
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x11, %ecx
callq 0x1406a
movb $0x1, 0x11(%rsp)
testb %al, %al
jne 0x8b089
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0x11, %edx
callq 0x12974
movb %al, 0x11(%rsp)
cmpb $0x0, 0x10(%rsp)
je 0x8b0a8
movl 0x74(%rsp), %esi
movl 0x14(%rsp), %edx
movq %rbx, %rdi
callq 0x1a1a0
testb %al, %al
je 0x8bad7
movb %r14b, 0x18(%rsp)
movq 0x78(%rsp), %rax
movq 0x70(%rax), %r14
subq 0x68(%rax), %r14
movl (%r12), %esi
movl 0x74(%rsp), %edx
movq %rbx, %rdi
callq 0x8ec06
movl %eax, (%r12)
movl %ebp, %ecx
movq 0x68(%r13), %rdx
movl %eax, (%rdx,%rcx,4)
movq 0x78(%rsp), %rcx
movq 0x70(%rcx), %rsi
cmpq 0x78(%rcx), %rsi
je 0x8b0f6
movl (%r12), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rcx)
jmp 0x8b106
movq 0x208(%rsp), %rdi
movq %r12, %rdx
callq 0x797e
leaq 0x2f8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl %ebp, %ecx
callq 0x8ed4e
leaq 0x220(%rsp), %rax
movq %rax, 0x210(%rsp)
movq %r15, %rdi
leaq 0x2f433(%rip), %rsi     # 0xba568
leaq 0x2f42d(%rip), %rdx     # 0xba569
callq 0x7be0
leaq 0x50(%rsp), %rdi
leaq 0x2f8(%rsp), %rdx
movq %r15, %rcx
callq 0x8eaca
movq 0x210(%rsp), %rdi
leaq 0x220(%rsp), %rax
cmpq %rax, %rdi
je 0x8b17b
movq 0x220(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2f8(%rsp), %rdi
leaq 0x308(%rsp), %rax
cmpq %rax, %rdi
je 0x8b1a0
movq 0x308(%rsp), %rsi
incq %rsi
callq 0x6260
shrq $0x2, %r14
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
leaq 0x50(%rsp), %rcx
callq 0x14b52
leaq 0xb8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0xe456
movq %r15, %rdi
leaq 0x2f654(%rip), %rsi     # 0xba849
callq 0x64e0
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %r15, %rdi
callq 0x60b0
leaq 0x40(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8b234
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x8b23a
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8b277
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x6260
cmpb $0x0, 0x10(%rsp)
je 0x8b296
movl 0x1c(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
leaq 0x30(%rsp), %rcx
callq 0x14b66
jmp 0x8b8f6
movl 0x14(%rsp), %eax
cmpl $0x3, %eax
je 0x8b486
cmpl $0x1, %eax
jne 0x8b8f6
movq %rbx, 0xa8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0xb8(%rsp), %rdi
movq %r13, %rsi
callq 0x1eafa
movl %ebp, 0x190(%rsp)
leaq 0x1a8(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x198(%rsp), %rdi
callq 0xe456
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movl $0x110, %edi            # imm = 0x110
callq 0x6250
movq %rax, %r15
movups 0xa8(%rsp), %xmm0
movups %xmm0, (%rax)
movl 0xc0(%rsp), %eax
movl %eax, 0x18(%r15)
movq 0x1b8(%rsp), %rax
movq %rax, 0x10(%r15)
leaq 0xb0(%rsp), %rcx
movups 0x14(%rcx), %xmm0
movups %xmm0, 0x1c(%r15)
movups 0xd8(%rsp), %xmm0
movups %xmm0, 0x30(%r15)
movq 0xe8(%rsp), %rax
movq %rax, 0x40(%r15)
leaq 0xd8(%rsp), %rax
movl $0x0, %esi
movq %rsi, 0x10(%rax)
xorps %xmm2, %xmm2
movups %xmm2, (%rax)
leaq 0xf0(%rsp), %rdx
movq 0x20(%rdx), %rax
movq %rax, 0x68(%r15)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x58(%r15)
movups %xmm0, 0x48(%r15)
movq %rsi, 0xf0(%rsp)
movl %esi, 0xf8(%rsp)
movq %rsi, 0x100(%rsp)
movl %esi, 0x108(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x70(%r15)
movups 0x120(%rsp), %xmm0
movups %xmm0, 0x78(%r15)
movq 0x130(%rsp), %rax
movq %rax, 0x88(%r15)
movq %rsi, 0x80(%rcx)
movups %xmm2, 0x70(%rcx)
movups 0x88(%rcx), %xmm0
movups 0x98(%rcx), %xmm1
movups %xmm1, 0xa0(%r15)
movups %xmm0, 0x90(%r15)
leaq 0xb0(%r15), %rdi
movq 0x200(%rsp), %rdx
movq %rdx, %rsi
callq 0xa8614
movl 0x190(%rsp), %eax
movl %eax, 0xe8(%r15)
movq %r15, %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0xf0(%r15)
movq 0x198(%rsp), %rcx
leaq 0x1a8(%rsp), %rdx
cmpq %rdx, %rcx
je 0x8b53d
movq %rcx, 0xf0(%r15)
movq 0x1a8(%rsp), %rax
movq %rax, 0x100(%r15)
jmp 0x8b543
movq %rbx, 0xa8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0xb0(%rsp), %rdi
callq 0xe456
movq 0x20(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0x1eafa
movl %ebp, 0x1b0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x90(%rsp)
movl $0x110, %edi            # imm = 0x110
callq 0x6250
movq %rax, %r15
movq 0xa8(%rsp), %rax
movq %rax, (%r15)
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq 0xb0(%rsp), %rcx
leaq 0xc0(%rsp), %rdx
cmpq %rdx, %rcx
je 0x8b68d
movq %rcx, 0x8(%r15)
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%r15)
jmp 0x8b693
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x1a0(%rsp), %rax
movq %rax, 0xf8(%r15)
movq %rdx, 0x198(%rsp)
movq $0x0, 0x1a0(%rsp)
movb $0x0, 0x1a8(%rsp)
movq %r15, 0x80(%rsp)
leaq 0x15805(%rip), %rax     # 0xa0d82
movq %rax, 0x98(%rsp)
leaq 0x158ee(%rip), %rax     # 0xa0e7a
movq %rax, 0x90(%rsp)
movq 0x248(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xa8402
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x8b5c8
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x198(%rsp), %rdi
leaq 0x1a8(%rsp), %rax
cmpq %rax, %rdi
je 0x8b5ed
movq 0x1a8(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x1b8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x200(%rsp), %rdi
callq 0xde80
movq 0x120(%rsp), %rdi
testq %rdi, %rdi
je 0x8b627
movq 0x130(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0xf0(%rsp), %rdi
testq %rdi, %rdi
je 0x8b66c
movq 0x110(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0xf0(%rsp)
movl %eax, 0xf8(%rsp)
movq %rax, 0x100(%rsp)
movl %eax, 0x108(%rsp)
movq %rax, 0x110(%rsp)
movq 0xd8(%rsp), %rdi
testq %rdi, %rdi
je 0x8b8f6
movq 0xe8(%rsp), %rsi
subq %rdi, %rsi
jmp 0x8b8f1
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%r15)
movq %rdx, 0xb0(%rsp)
xorl %edx, %edx
movq %rdx, 0xb8(%rsp)
movb $0x0, 0xc0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%r15)
movl 0xe0(%rsp), %eax
movl %eax, 0x38(%r15)
movq 0x1b8(%rsp), %rax
movq %rax, 0x30(%r15)
leaq 0xb0(%rsp), %rcx
movups 0x34(%rcx), %xmm0
movups %xmm0, 0x3c(%r15)
movups 0xf8(%rsp), %xmm0
movups %xmm0, 0x50(%r15)
movq 0x108(%rsp), %rax
movq %rax, 0x60(%r15)
movq %rdx, 0x58(%rcx)
xorps %xmm2, %xmm2
movups %xmm2, 0x48(%rcx)
movq 0x80(%rcx), %rax
movq %rax, 0x88(%r15)
movups 0x60(%rcx), %xmm0
movups 0x70(%rcx), %xmm1
movups %xmm1, 0x78(%r15)
movups %xmm0, 0x68(%r15)
movq %rdx, 0x110(%rsp)
movl %edx, 0x118(%rsp)
movq %rdx, 0x120(%rsp)
movl %edx, 0x128(%rsp)
movq %rdx, 0x130(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x90(%r15)
movups 0x140(%rsp), %xmm0
movups %xmm0, 0x98(%r15)
movq 0x150(%rsp), %rax
movq %rax, 0xa8(%r15)
movq 0x298(%rsp), %rax
movq %rdx, 0x10(%rax)
movups %xmm2, (%rax)
movq 0x200(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0xc0(%r15)
movups %xmm0, 0xb0(%r15)
movq %r15, %rdi
addq $0xd0, %rdi
leaq 0x178(%rsp), %rdx
movq %rdx, %rsi
callq 0xa8614
movl 0x1b0(%rsp), %eax
movl %eax, 0x108(%r15)
movq %r15, 0x80(%rsp)
leaq 0x157f0(%rip), %rax     # 0xa0fda
movq %rax, 0x98(%rsp)
leaq 0x158d5(%rip), %rax     # 0xa10ce
movq %rax, 0x90(%rsp)
movq 0x250(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xa8402
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x8b835
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x1b8(%rsp), %rax
movq %rax, 0xd8(%rsp)
leaq 0x178(%rsp), %rdi
callq 0xde80
movq 0x140(%rsp), %rdi
testq %rdi, %rdi
je 0x8b86f
movq 0x150(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x110(%rsp), %rdi
testq %rdi, %rdi
je 0x8b8b4
movq 0x130(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0x110(%rsp)
movl %eax, 0x118(%rsp)
movq %rax, 0x120(%rsp)
movl %eax, 0x128(%rsp)
movq %rax, 0x130(%rsp)
movq 0xf8(%rsp), %rdi
testq %rdi, %rdi
je 0x8b8d1
movq 0x108(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x8b8f6
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x1c(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1e, %ecx
callq 0x1406a
testb %al, %al
je 0x8b94b
movl 0x1c(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1e, %ecx
callq 0x14cde
movl %eax, %r15d
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x1e, %ecx
movl %eax, %r8d
callq 0x14b48
movl 0x14(%rsp), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8ebc0
jmp 0x8b9a5
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x12974
testb %al, %al
je 0x8b9a5
movq 0x20(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x14e6e
movl %eax, %r15d
addl %ebp, %r15d
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x1e, %ecx
movl %r15d, %r8d
callq 0x14b48
movl 0x14(%rsp), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8ebc0
movl 0x1c(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1f, %ecx
callq 0x1406a
leaq 0x210(%rsp), %r15
testb %al, %al
je 0x8b9ee
movl 0x1c(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1f, %ecx
callq 0x14cde
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x1f, %ecx
movl %eax, %r8d
callq 0x14b48
cmpb $0x0, 0x10(%rsp)
je 0x8ba27
movl 0xc(%rsp), %esi
movl 0x74(%rsp), %r8d
movq %rbx, %rdi
movl %r14d, %edx
movl $0xb, %ecx
callq 0x14b48
cmpl $0x0, 0x74(%rsp)
jne 0x8ba27
movq 0x240(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6170
cmpb $0x0, 0x18(%rsp)
je 0x8ba45
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x13(%rsp)
je 0x8ba63
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0xd, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x12(%rsp)
je 0x8ba81
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x10, %ecx
xorl %r8d, %r8d
callq 0x14b48
cmpb $0x0, 0x11(%rsp)
je 0x8ba9f
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x11, %ecx
xorl %r8d, %r8d
callq 0x14b48
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x8babb
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x8bad7
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
incl %ebp
addq $0x4, %r12
cmpq 0x2b0(%rsp), %r12
jne 0x8afa2
movq 0x2a8(%rsp), %rsi
addq $0x8, %rsi
cmpq 0x2a0(%rsp), %rsi
jne 0x8a22a
jmp 0x8bb17
movq %rbx, %rdi
callq 0x1c036
movl 0x10(%rax), %eax
jmp 0x8a351
movl 0xc(%rsp), %eax
imulq $0x148, %rax, %rdx      # imm = 0x148
addq 0x38(%rbx), %rdx
leaq 0xa8(%rsp), %rdi
movq 0x78(%rsp), %rsi
xorl %ecx, %ecx
callq 0xa094c
leaq 0xa8(%rsp), %rdi
callq 0x8f04e
movl 0x2c(%rsp), %ebx
movq 0x1c0(%rsp), %rdi
leaq 0x1d0(%rsp), %rax
cmpq %rax, %rdi
je 0x8bb70
movq 0x1d0(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x1e0(%rsp), %rdi
testq %rdi, %rdi
je 0x8bb8d
movq 0x1f0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movl %ebx, %eax
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x34906(%rip), %rsi     # 0xc04ce
leaq 0x34940(%rip), %rdx     # 0xc050f
callq 0x7be0
movb $0x1, %bpl
leaq 0xa8(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0x701da(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x701b2(%rip), %rsi     # 0xfbdb0
movq 0x713d3(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x8bc7b
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
movq %rax, (%rdi)
leaq 0x348da(%rip), %rsi     # 0xc0510
leaq 0x34912(%rip), %rdx     # 0xc054f
callq 0x7be0
movb $0x1, %bpl
leaq 0xa8(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0x7016c(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x70144(%rip), %rsi     # 0xfbdb0
movq 0x71365(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x8c178
jmp 0x8c178
jmp 0x8bc93
jmp 0x8bcc5
jmp 0x8c178
jmp 0x8c07c
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8bcbb
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
jne 0x8bcc8
jmp 0x8c17b
movq %rax, %rbx
movq %r14, %rdi
callq 0x6200
jmp 0x8c17b
jmp 0x8c178
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8bd07
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8bd07
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x8bd28
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8bd28
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c17b
movq 0x40(%rsp), %rsi
jmp 0x8c16e
jmp 0x8c178
jmp 0x8c07c
jmp 0x8c07c
jmp 0x8c178
jmp 0x8c178
jmp 0x8c07c
jmp 0x8c178
jmp 0x8bf8b
jmp 0x8bf8b
jmp 0x8c178
movq %rax, %rbx
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x8bdaa
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8bdaa
jmp 0x8bf8b
movq %rax, %rbx
jmp 0x8be2e
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x8ef62
jmp 0x8c139
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x1be02
jmp 0x8c139
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x8c139
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8c139
jmp 0x8c136
jmp 0x8c136
movq %rax, %rbx
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x8be2e
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xa8(%rsp), %rdi
callq 0x8eee4
jmp 0x8c139
jmp 0x8bf8b
jmp 0x8c178
jmp 0x8c0a2
jmp 0x8c0ee
jmp 0x8be60
movq %rax, %rbx
jmp 0x8beb2
jmp 0x8c0a2
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x8c10d
movq 0x40(%rsp), %rsi
jmp 0x8c105
jmp 0x8c178
jmp 0x8c0ee
movq %rax, %rbx
movq 0x258(%rsp), %rdi
leaq 0x268(%rsp), %rax
cmpq %rax, %rdi
je 0x8beb2
movq 0x268(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2b8(%rsp), %rdi
leaq 0x2c8(%rsp), %rax
cmpq %rax, %rdi
je 0x8c17b
movq 0x2c8(%rsp), %rsi
jmp 0x8c16e
jmp 0x8c178
jmp 0x8bf8b
jmp 0x8bf8b
jmp 0x8c0ee
jmp 0x8c178
jmp 0x8c178
jmp 0x8c178
jmp 0x8c178
jmp 0x8c178
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x8c15a
movq 0xd0(%rsp), %rsi
jmp 0x8c14d
jmp 0x8c157
jmp 0x8c157
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x8bf5b
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8bf5b
jmp 0x8bf8b
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x8efde
jmp 0x8c15a
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x8bf96
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8bf96
movq %rax, %rdi
callq 0xd549
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x8f016
jmp 0x8c15a
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x8c15a
movq 0xc0(%rsp), %rsi
jmp 0x8c14d
jmp 0x8c178
jmp 0x8c178
jmp 0x8c07c
jmp 0x8c136
jmp 0x8c178
jmp 0x8c136
jmp 0x8c178
movq %rax, %rbx
jmp 0x8c023
jmp 0x8c053
movq %rax, %rbx
movq 0x210(%rsp), %rdi
leaq 0x220(%rsp), %rax
cmpq %rax, %rdi
je 0x8c023
movq 0x220(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2f8(%rsp), %rdi
leaq 0x308(%rsp), %rax
cmpq %rax, %rdi
je 0x8c17b
movq 0x308(%rsp), %rsi
jmp 0x8c16e
jmp 0x8c157
jmp 0x8c157
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8c15a
movq 0xb8(%rsp), %rsi
jmp 0x8c14d
movq %rax, %rbx
jmp 0x8c1a0
jmp 0x8c178
jmp 0x8c178
jmp 0x8c136
jmp 0x8c178
movq %rax, %rbx
jmp 0x8c0cf
jmp 0x8c157
movq %rax, %rbx
jmp 0x8c10d
movq %rax, %rbx
movq 0x278(%rsp), %rdi
leaq 0x288(%rsp), %rax
cmpq %rax, %rdi
je 0x8c0cf
movq 0x288(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2d8(%rsp), %rdi
leaq 0x2e8(%rsp), %rax
cmpq %rax, %rdi
je 0x8c10d
movq 0x2e8(%rsp), %rsi
jmp 0x8c105
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x8c10d
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8c17b
movq 0xb8(%rsp), %rsi
jmp 0x8c16e
jmp 0x8c178
jmp 0x8c178
jmp 0x8c178
jmp 0x8c157
jmp 0x8c178
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x8c15a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8c15a
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x8c17b
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8c17b
movq %rax, %rbx
movq 0x1c0(%rsp), %rdi
leaq 0x1d0(%rsp), %rax
cmpq %rax, %rdi
je 0x8c1a0
movq 0x1d0(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x1e0(%rsp), %rdi
testq %rdi, %rdi
je 0x8c1bd
movq 0x1f0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
nop