// File: /workspace/github_cpp_makefile_star2_O2/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 $0x308, %rsp            # imm = 0x308
movl %esi, %ebp
movl %esi, 0x20(%rsp)
xorps %xmm0, %xmm0
leaq 0x220(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x8(%rdi), %rbx
movq 0x20(%rdi), %r12
movq %rdi, 0x8(%rsp)
movq 0x28(%rdi), %r15
cmpq %r15, %r12
je 0x6fc1b
cmpl $0x2, 0x8(%r12)
jne 0x6fc12
movq %r12, %rdi
callq 0x9b30
movq %rax, %r13
movl 0xc(%rax), %esi
movq 0x8(%rsp), %rdi
callq 0x90a4
movq %rax, %r14
movl 0x10(%r13), %eax
cmpl 0x20(%rsp), %eax
jne 0x6fc12
movl 0x8(%r13), %esi
movq 0x8(%rsp), %rdi
callq 0x115ea
testb %al, %al
je 0x6fc12
xorl %edx, %edx
cmpl $0x3, %ebp
sete %dl
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x10b56
testb %al, %al
jne 0x6fc12
cmpb $0x1, 0x60(%r14)
jne 0x6fc12
movq %r13, 0xc8(%rsp)
leaq 0x220(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x65c84
addq $0x10, %r12
jmp 0x6fb8d
movq 0x220(%rsp), %rax
cmpq 0x228(%rsp), %rax
je 0x6fd38
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x202bc
movl %eax, %r14d
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %eax, %esi
callq 0x17718
movq %rax, %r15
movl $0xc, 0xc(%rax)
movl 0x20(%rsp), %eax
movl %eax, 0x64(%r15)
movl 0x4(%rsp), %esi
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1206e
movq %r15, 0x60(%rsp)
leal 0x1(%r14), %esi
movl %esi, 0x30(%rsp)
leaq 0xc8(%rsp), %r8
andl $0x0, (%r8)
leaq 0x4(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
callq 0x7fc1e
addl $0x2, %r14d
movl %r14d, 0x18(%rax)
leaq 0x210(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x6fd3f
cmpl $0x3, %eax
jne 0x6fd66
leaq 0x980(%rbx), %rsi
leaq 0x200(%rsp), %rdi
callq 0x6170
movq %rbx, %rdi
callq 0x7fc5a
xorl %ebp, %ebp
testb %al, %al
jne 0x6fcf4
movl 0x30(%rsp), %ebp
movl 0x108(%rbx), %esi
movq %rbx, %rdi
callq 0xa048
movq %rax, %r14
movl 0x30(%rsp), %esi
movq %rax, %rdi
callq 0x7fb64
movq 0x68(%r14), %r15
movq 0x70(%r14), %r14
cmpq %r14, %r15
je 0x6fd55
movl (%r15), %esi
movq %rbx, %rdi
callq 0x6bf0
cmpl $0x4, 0xc(%rax)
jne 0x6fd32
movl %ebp, 0x24(%rax)
addq $0x4, %r15
jmp 0x6fd19
xorl %ebx, %ebx
jmp 0x70ffd
leaq 0x960(%rbx), %rsi
leaq 0x200(%rsp), %rdi
callq 0x6170
jmp 0x6fd66
leaq 0x8e0(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6c06
movl 0x4(%rsp), %ebp
movl 0x108(%rbx), %edx
movq (%rbx), %rax
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x291bf(%rip), %rdx     # 0x98f47
leaq 0xa0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xab3f
leaq 0xc8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x200(%rsp), %rdx
callq 0x42dd2
leaq 0xc8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11dda
leaq 0xc8(%rsp), %rdi
callq 0x6548
leaq 0xa0(%rsp), %rdi
callq 0x6548
leaq 0x40(%rsp), %rdi
callq 0x6548
movl 0x30(%rsp), %esi
leaq 0x200(%rsp), %rdx
movq %rbx, %rdi
callq 0x11dda
movl 0x108(%rbx), %esi
movq %rbx, %rdi
callq 0xa048
movq 0x220(%rsp), %rcx
movq 0x228(%rsp), %rdx
movq %rdx, 0x238(%rsp)
leaq 0x8e0(%rbx), %rdx
movq %rdx, 0x1d8(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, %rdx
addq $0x68, %rdx
movq %rdx, 0xc0(%rsp)
leaq 0x98(%rax), %rdx
movq %rdx, 0x1f8(%rsp)
movq %rax, 0x1e0(%rsp)
addq $0xb0, %rax
movq %rax, 0x1f0(%rsp)
leaq 0x940(%rbx), %rax
movq %rax, 0x1e8(%rsp)
cmpq 0x238(%rsp), %rcx
je 0x70fc1
movq %rcx, 0x240(%rsp)
movq (%rcx), %r15
movl 0xc(%r15), %esi
movl %esi, 0x24(%rsp)
movq %rbx, %rdi
callq 0x90a4
movq %rax, 0x28(%rsp)
movl 0xc(%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0x6, %ecx
movq %r15, 0x38(%rsp)
jae 0x70295
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10c60
movl %eax, %r12d
movl 0x8(%r15), %esi
movq %rbx, %rdi
pushq $0xb
popq %rdx
callq 0x12174
movl %eax, %ebp
leaq 0x8(%r15), %r14
movl (%r14), %esi
movq %rbx, %rdi
pushq $0xe
popq %rdx
callq 0x103d2
movb %al, 0x68(%rsp)
movl (%r14), %esi
movq %rbx, %rdi
pushq $0xd
popq %rdx
callq 0x103d2
movb %al, 0x16(%rsp)
movl (%r14), %esi
movq %rbx, %rdi
pushq $0x10
popq %rdx
callq 0x103d2
movb %al, 0x15(%rsp)
movq %r14, 0x18(%rsp)
movl (%r14), %esi
movq %rbx, %rdi
pushq $0x11
popq %rdx
callq 0x103d2
movb %al, 0x17(%rsp)
movl %ebp, %r14d
movl 0x20(%rsp), %edx
testb %r12b, %r12b
je 0x6ff51
movq %rbx, %rdi
movl %r14d, %esi
callq 0x160ec
testb %al, %al
je 0x7027f
jmp 0x6ffb2
andl $-0x3, %edx
cmpl $0x1, %edx
jne 0x6ffb2
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x10d5a
testb %al, %al
jne 0x6ff7b
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x10d6c
testb %al, %al
je 0x6ffb2
movq %rbx, %rdi
movq 0x28(%rsp), %r12
movq %r12, %rsi
callq 0x10d5a
testb %al, %al
je 0x709da
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x10d6c
testb %al, %al
jne 0x7101e
movl 0x18(%r12), %ebp
jmp 0x70a29
movb %r12b, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0x70(%rax), %r12
subq 0x68(%rax), %r12
movl 0x24(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x736e4
movl %eax, 0x24(%rsp)
movl %eax, 0xc(%r15)
movq 0xc0(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x6c06
movq 0x18(%rsp), %rax
movl (%rax), %edx
leaq 0x248(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2b9f0
leaq 0x2a8(%rsp), %r15
movq %r15, %rdi
leaq 0x25530(%rip), %rsi     # 0x95548
leaq 0xa0(%rsp), %rdx
callq 0x6100
leaq 0xc8(%rsp), %rbp
movq %rbp, %rdi
leaq 0x248(%rsp), %r13
movq %r13, %rdx
movq %r15, %rcx
callq 0x735c0
shrq $0x2, %r12
movq %r15, %rdi
callq 0x6548
movq %r13, %rdi
callq 0x6548
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r12d, %edx
movq %rbp, %rcx
callq 0x11ed8
leaq 0x40(%rsp), %r13
movq %r13, %rdi
leaq 0x200(%rsp), %rsi
leaq 0x257a7(%rip), %rdx     # 0x95829
callq 0x174a5
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
leaq 0xc8(%rsp), %rdx
callq 0x42dd2
movq %r13, %rdi
callq 0x6548
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rcx
imulq $0x148, %rax, %rax      # imm = 0x148
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
movq %r15, %rsi
callq 0x6170
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq 0x8(%rsp), %rdi
callq 0x12156
testb $0x40, 0x3(%rax)
movq 0x8(%rsp), %rbx
je 0x70126
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
pushq $0x1e
popq %rdx
callq 0x12174
movl %eax, %r13d
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r12d, %edx
pushq $0x1e
popq %rcx
movl %eax, %r8d
callq 0x11ece
movl 0x20(%rsp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x7369e
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x12156
testb $-0x80, 0x3(%rax)
movq 0x8(%rsp), %rbx
je 0x70167
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
pushq $0x1f
popq %rdx
callq 0x12174
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r12d, %edx
pushq $0x1f
popq %rcx
movl %eax, %r8d
callq 0x11ece
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x12156
movabsq $0x100000000, %rcx      # imm = 0x100000000
testq %rcx, (%rax)
je 0x701b0
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x12174
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r12d, %edx
pushq $0x20
popq %rcx
movl %eax, %r8d
callq 0x11ece
cmpb $0x0, 0x28(%rsp)
je 0x701e8
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r12d, %edx
pushq $0xb
popq %rcx
movl %r14d, %r8d
callq 0x11ece
testl %r14d, %r14d
jne 0x701e8
movq 0x1e8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x6170
cmpb $0x0, 0x68(%rsp)
je 0x70206
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r12d, %edx
pushq $0xe
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x16(%rsp)
je 0x70224
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r12d, %edx
pushq $0xd
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x15(%rsp)
je 0x70242
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r12d, %edx
pushq $0x10
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x17(%rsp)
je 0x70260
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r12d, %edx
pushq $0x11
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
leaq 0xa0(%rsp), %rdi
callq 0x6548
leaq 0xc8(%rsp), %rdi
callq 0x6548
movq 0x8(%rsp), %rbx
movq 0x240(%rsp), %rcx
addq $0x8, %rcx
movq 0x60(%rsp), %rsi
jmp 0x6fe7e
cmpl $0xc, %eax
jne 0x709c9
movq %rbx, %rdi
movq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x10c9e
testb %al, %al
jne 0x702d4
movl 0x8(%r15), %esi
movq 0x1e0(%rsp), %rdi
callq 0x7fb64
leaq 0x8(%r15), %rsi
movq 0x1d8(%rsp), %rdi
callq 0x6c06
movq 0x68(%r14), %rax
movq 0x70(%r14), %rcx
movq %rcx, 0x98(%rsp)
xorl %ebp, %ebp
movq %rax, 0x68(%rsp)
cmpq 0x98(%rsp), %rax
je 0x7027f
movq %rbx, %rdi
movq 0x28(%rsp), %r14
movq %r14, %rsi
movl %ebp, %edx
leaq 0x34(%rsp), %rcx
callq 0x10cdc
movl %eax, %r12d
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl %ebp, 0x18(%rsp)
movl %ebp, %edx
pushq $0xe
popq %rcx
callq 0x117ba
movq 0x60(%rsp), %r14
movb $0x1, %bpl
testb %al, %al
jne 0x70343
movl 0x8(%r15), %esi
movq 0x8(%rsp), %rdi
pushq $0xe
popq %rdx
callq 0x103d2
movl %eax, %ebp
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %edx
pushq $0xd
popq %rcx
callq 0x117ba
movb $0x1, %bl
testb %al, %al
jne 0x70375
movl 0x8(%r15), %esi
movq 0x8(%rsp), %rdi
pushq $0xd
popq %rdx
callq 0x103d2
movl %eax, %ebx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %edx
pushq $0x10
popq %rcx
callq 0x117ba
movb $0x1, 0x16(%rsp)
testb %al, %al
jne 0x703ac
movl 0x8(%r15), %esi
movq 0x8(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x103d2
movb %al, 0x16(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %edx
pushq $0x11
popq %rcx
callq 0x117ba
movb $0x1, 0x15(%rsp)
testb %al, %al
jne 0x703e3
movl 0x8(%r15), %esi
movq 0x8(%rsp), %rdi
pushq $0x11
popq %rdx
callq 0x103d2
movb %al, 0x15(%rsp)
testb %r12b, %r12b
je 0x70402
movl 0x34(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x8(%rsp), %rdi
callq 0x160ec
testb %al, %al
je 0x709b0
movb %bl, 0x17(%rsp)
movl %r12d, %ebx
movl %ebp, %r12d
movq 0x70(%r14), %r15
subq 0x68(%r14), %r15
movq 0x68(%rsp), %r13
movl (%r13), %esi
movl 0x34(%rsp), %edx
movq 0x8(%rsp), %rdi
callq 0x736e4
movq 0x28(%rsp), %r14
movl 0x18(%rsp), %ebp
movl %eax, (%r13)
movl %ebp, %ecx
movq 0x68(%r14), %rdx
movl %eax, (%rdx,%rcx,4)
movq 0xc0(%rsp), %rdi
movq %r13, %rsi
callq 0x6c06
leaq 0x288(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x73790
leaq 0x2e8(%rsp), %r13
movq %r13, %rdi
leaq 0x250ce(%rip), %rsi     # 0x95548
leaq 0xc8(%rsp), %rdx
callq 0x6100
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
leaq 0x288(%rsp), %rbp
movq %rbp, %rdx
movq %r13, %rcx
callq 0x735c0
shrq $0x2, %r15
movq %r13, %rdi
callq 0x6548
movq %rbp, %rdi
callq 0x6548
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r15d, %edx
movq %r14, %rcx
callq 0x11ed8
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
leaq 0x200(%rsp), %rsi
leaq 0x25342(%rip), %rdx     # 0x95829
callq 0x174a5
movb 0x17(%rsp), %r13b
movl %r12d, %ebp
movl %ebx, %r12d
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
leaq 0xa0(%rsp), %rdx
callq 0x42dd2
movq %r14, %rdi
callq 0x6548
testb %r12b, %r12b
je 0x70535
movl 0x24(%rsp), %esi
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %edx
leaq 0x40(%rsp), %rcx
callq 0x11eec
jmp 0x707ef
movl 0x20(%rsp), %eax
cmpl $0x3, %eax
je 0x7061f
cmpl $0x1, %eax
jne 0x707ef
movq 0x8(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0xd8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1a29c
movl 0x18(%rsp), %eax
movl %eax, 0x1b0(%rsp)
leaq 0x1b8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x63c0
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movl $0x110, %edi            # imm = 0x110
callq 0x6270
movq %rax, %r14
movups 0xc8(%rsp), %xmm0
movups %xmm0, (%rax)
leaq 0x10(%rax), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x83f6e
movl 0x1b0(%rsp), %eax
movl %eax, 0xe8(%r14)
movq %r14, %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0xf0(%r14)
movq 0x1b8(%rsp), %rcx
leaq 0x1c8(%rsp), %rdx
cmpq %rdx, %rcx
je 0x706c6
movq %rcx, 0xf0(%r14)
movq 0x1c8(%rsp), %rax
movq %rax, 0x100(%r14)
jmp 0x706cc
movq 0x8(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x63c0
movq 0x38(%rsp), %rax
movq %rax, 0xf0(%rsp)
leaq 0xf8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1a29c
movl 0x18(%rsp), %eax
movl %eax, 0x1d0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movl $0x110, %edi            # imm = 0x110
callq 0x6270
movq %rax, %r14
movq 0xc8(%rsp), %rax
movq %rax, (%r14)
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq 0xd0(%rsp), %rcx
leaq 0xe0(%rsp), %rdx
cmpq %rdx, %rcx
je 0x70749
movq %rcx, 0x8(%r14)
movq 0xe0(%rsp), %rax
movq %rax, 0x18(%r14)
jmp 0x7074f
movups (%rdx), %xmm0
movups %xmm0, (%rax)
leaq 0x70(%rsp), %rcx
movq 0x1c0(%rsp), %rax
movq %rax, 0xf8(%r14)
movq %rdx, 0x1b8(%rsp)
andq $0x0, 0x1c0(%rsp)
movb $0x0, 0x1c8(%rsp)
movq %r14, 0x70(%rsp)
leaq 0xd74f(%rip), %rax      # 0x7de54
movq %rax, 0x88(%rsp)
leaq 0xd7f2(%rip), %rax      # 0x7df06
movq %rax, 0x80(%rsp)
movq 0x1f0(%rsp), %rdi
movq %rcx, %r14
movq %rcx, %rsi
callq 0x83d70
movq %r14, %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x738d2
jmp 0x707ef
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%r14)
movq %rdx, 0xd0(%rsp)
andq $0x0, 0xd8(%rsp)
movb $0x0, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r14, %rdi
addq $0x30, %rdi
leaq 0xf8(%rsp), %rsi
callq 0x83f6e
movl 0x1d0(%rsp), %eax
movl %eax, 0x108(%r14)
movq %r14, 0x70(%rsp)
leaq 0xd832(%rip), %rax      # 0x7dfe0
movq %rax, 0x88(%rsp)
leaq 0xd8d1(%rip), %rax      # 0x7e08e
movq %rax, 0x80(%rsp)
movq 0x1f8(%rsp), %rdi
leaq 0x70(%rsp), %r14
movq %r14, %rsi
callq 0x83d70
movq %r14, %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x738f0
movl 0x24(%rsp), %esi
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %edx
pushq $0x1e
popq %rcx
callq 0x117ba
testb %al, %al
je 0x70849
movl 0x24(%rsp), %esi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl 0x18(%rsp), %edx
pushq $0x1e
popq %rcx
callq 0x12036
movl %eax, %r14d
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0x1e
popq %rcx
movl %eax, %r8d
callq 0x11ece
movl 0x20(%rsp), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7369e
jmp 0x708a6
movq 0x38(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rdi
pushq $0x1e
popq %rdx
callq 0x103d2
testb %al, %al
movq 0x8(%rsp), %rbx
je 0x708a6
movq 0x38(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
pushq $0x1e
popq %rdx
callq 0x12174
movl %eax, %r14d
addl 0x18(%rsp), %r14d
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0x1e
popq %rcx
movl %r14d, %r8d
callq 0x11ece
movl 0x20(%rsp), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7369e
movl 0x24(%rsp), %esi
movq %rbx, %rdi
movl 0x18(%rsp), %edx
pushq $0x1f
popq %rcx
callq 0x117ba
testb %al, %al
je 0x708e9
movl 0x24(%rsp), %esi
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %edx
pushq $0x1f
popq %rcx
callq 0x12036
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r15d, %edx
pushq $0x1f
popq %rcx
movl %eax, %r8d
callq 0x11ece
testb %r12b, %r12b
je 0x70920
movl 0x4(%rsp), %esi
movl 0x34(%rsp), %r8d
movq 0x8(%rsp), %rdi
movl %r15d, %edx
pushq $0xb
popq %rcx
callq 0x11ece
cmpl $0x0, 0x34(%rsp)
jne 0x70920
movq 0x1e8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6170
testb %bpl, %bpl
je 0x7093c
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r15d, %edx
pushq $0xe
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
testb %r13b, %r13b
je 0x70958
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r15d, %edx
pushq $0xd
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x16(%rsp)
je 0x70976
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r15d, %edx
pushq $0x10
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x15(%rsp)
je 0x70994
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movl %r15d, %edx
pushq $0x11
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0xa0(%rsp), %rdi
callq 0x6548
movq 0x38(%rsp), %r15
movl 0x18(%rsp), %ebp
incl %ebp
movq 0x68(%rsp), %rax
addq $0x4, %rax
movq 0x8(%rsp), %rbx
jmp 0x702e6
addl $-0x9, %eax
cmpl $0x2, %eax
jbe 0x6fec0
jmp 0x7027f
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x10d6c
xorl %ebp, %ebp
testb %al, %al
je 0x70a29
movq 0x28(%r12), %rax
subq 0x20(%r12), %rax
cmpq $0x4, %rax
jne 0x71072
movq %r12, %rdi
addq $0x38, %rdi
callq 0x17d30
movq 0x28(%r12), %rcx
movl -0x4(%rcx), %ebp
testq %rdx, (%rax)
jne 0x70a29
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x17bce
movl 0x10(%rax), %ebp
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10d6c
testb %al, %al
jne 0x70a4e
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x10d5a
testb %al, %al
je 0x70a68
movl 0x9c(%r12), %esi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x90a4
movq %rax, %r12
jmp 0x70a2e
movq 0x18(%rsp), %r14
movl (%r14), %esi
movq 0x1e0(%rsp), %rdi
callq 0x7fb64
movq 0x1d8(%rsp), %rdi
movq %r14, %rsi
callq 0x6c06
addq $0x8, %r12
xorl %eax, %eax
movl %ebp, 0x98(%rsp)
movl %eax, 0x70(%rsp)
cmpl %ebp, %eax
jae 0x7027a
movq 0x60(%rsp), %rax
movq 0x70(%rax), %r15
subq 0x68(%rax), %r15
movq 0xc0(%rsp), %rdi
movq %r12, %r13
movq %r12, %rsi
callq 0x6c06
movq 0x18(%rsp), %rax
movl (%rax), %edx
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x2b9f0
leaq 0x268(%rsp), %rdi
movq %r12, %rsi
leaq 0x28453(%rip), %rdx     # 0x98f47
leaq 0x70(%rsp), %rcx
callq 0x7fc7b
leaq 0x2c8(%rsp), %r14
movq %r14, %rdi
leaq 0x24a38(%rip), %rsi     # 0x95548
leaq 0x40(%rsp), %rdx
callq 0x6100
leaq 0xa0(%rsp), %r12
movq %r12, %rdi
leaq 0x268(%rsp), %rbp
movq %rbp, %rdx
movq %r14, %rcx
callq 0x735c0
shrq $0x2, %r15
movq %r14, %rdi
callq 0x6548
movq %rbp, %rdi
callq 0x6548
leaq 0xc8(%rsp), %rdi
callq 0x6548
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
movq %r12, %rcx
callq 0x11ed8
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x12156
testb $0x40, 0x3(%rax)
je 0x70bc3
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
pushq $0x1e
popq %rdx
callq 0x12174
movl %eax, %r12d
addl 0x70(%rsp), %r12d
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0x1e
popq %rcx
movl %r12d, %r8d
callq 0x11ece
movl 0x20(%rsp), %edx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7369e
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x12156
movabsq $0x100000000, %rcx      # imm = 0x100000000
testq %rcx, (%rax)
je 0x70c08
movq 0x18(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x12174
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0x20
popq %rcx
movl %eax, %r8d
callq 0x11ece
cmpb $0x0, 0x68(%rsp)
je 0x70c24
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0xe
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x16(%rsp)
je 0x70c40
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0xd
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x15(%rsp)
je 0x70c5c
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0x10
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
cmpb $0x0, 0x17(%rsp)
je 0x70c78
movl 0x4(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
pushq $0x11
popq %rcx
xorl %r8d, %r8d
callq 0x11ece
movl 0x20(%rsp), %eax
cmpl $0x3, %eax
je 0x70d4a
cmpl $0x1, %eax
movq 0x38(%rsp), %rax
movq %r13, %r12
movl 0x98(%rsp), %ebp
jne 0x70fa9
movq 0x8(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movq %rax, 0xd0(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0xd8(%rsp)
leaq 0xe0(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0x63c0
leaq 0x100(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x63c0
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
pushq $0x58
popq %rdi
callq 0x6270
movq %rax, %rcx
movl 0xd8(%rsp), %edx
movl %edx, 0x10(%rax)
movups 0xc8(%rsp), %xmm0
movups %xmm0, (%rax)
leaq 0x28(%rax), %rdx
movq %rdx, 0x18(%rax)
movq 0xe0(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
cmpq %rdi, %rsi
je 0x70df7
movq %rsi, 0x18(%rcx)
movq 0xf0(%rsp), %rdx
movq %rdx, 0x28(%rcx)
jmp 0x70dfd
movq %rbx, 0xc8(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0x63c0
movq 0x38(%rsp), %r14
movq %r13, %r12
leaq 0xf0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x63c0
movl 0x98(%rsp), %ebp
movq %r14, 0x110(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x118(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
pushq $0x58
popq %rdi
callq 0x6270
movq %rax, %rcx
movq 0xc8(%rsp), %rdx
movq %rdx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq 0xd0(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
cmpq %rdi, %rsi
je 0x70ec8
movq %rsi, 0x8(%rcx)
movq 0xe0(%rsp), %rdx
movq %rdx, 0x18(%rcx)
jmp 0x70ece
movups (%rdi), %xmm0
movups %xmm0, (%rdx)
movq 0xe8(%rsp), %rdx
movq %rdx, 0x20(%rcx)
movq %rdi, 0xe0(%rsp)
andq $0x0, 0xe8(%rsp)
movb $0x0, 0xf0(%rsp)
addq $0x48, %rax
movq %rax, 0x38(%rcx)
movq 0x100(%rsp), %rdx
leaq 0x110(%rsp), %rsi
cmpq %rsi, %rdx
je 0x70e51
movq %rdx, 0x38(%rcx)
movq 0x110(%rsp), %rax
movq %rax, 0x48(%rcx)
jmp 0x70e57
movups (%rsi), %xmm0
movups %xmm0, (%rax)
movq 0x108(%rsp), %rax
movq %rax, 0x40(%rcx)
movq %rsi, 0x100(%rsp)
andq $0x0, 0x108(%rsp)
movb $0x0, 0x110(%rsp)
movq %rcx, 0x40(%rsp)
leaq 0xd2e4(%rip), %rax      # 0x7e16c
movq %rax, 0x58(%rsp)
leaq 0xd366(%rip), %rax      # 0x7e1fa
movq %rax, 0x50(%rsp)
movq 0x1f0(%rsp), %rdi
leaq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0x83d70
movq %r15, %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x7390a
jmp 0x70fa9
movups (%rdi), %xmm0
movups %xmm0, (%rdx)
leaq 0x110(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq %rdx, 0x10(%rcx)
movq %rdi, 0xd0(%rsp)
andq $0x0, 0xd8(%rsp)
movb $0x0, 0xe0(%rsp)
addq $0x38, %rax
movq %rax, 0x28(%rcx)
movq 0xf0(%rsp), %rdx
leaq 0x100(%rsp), %rdi
cmpq %rdi, %rdx
je 0x70f2a
movq %rdx, 0x28(%rcx)
movq 0x100(%rsp), %rax
movq %rax, 0x38(%rcx)
jmp 0x70f30
movups (%rdi), %xmm0
movups %xmm0, (%rax)
movq 0xf8(%rsp), %rax
movq %rax, 0x30(%rcx)
movq %rdi, 0xf0(%rsp)
andq $0x0, 0xf8(%rsp)
movb $0x0, 0x100(%rsp)
movl 0x8(%rsi), %eax
movl %eax, 0x50(%rcx)
movq (%rsi), %rax
movq %rax, 0x48(%rcx)
movq %rcx, 0x40(%rsp)
leaq 0xd354(%rip), %rax      # 0x7e2c2
movq %rax, 0x58(%rsp)
leaq 0xd3e4(%rip), %rax      # 0x7e35e
movq %rax, 0x50(%rsp)
movq 0x1f8(%rsp), %rdi
leaq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0x83d70
movq %r15, %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x73924
leaq 0xa0(%rsp), %rdi
callq 0x6548
movl 0x70(%rsp), %eax
incl %eax
jmp 0x70a9a
movl 0x4(%rsp), %eax
imulq $0x148, %rax, %rdx      # imm = 0x148
addq 0x38(%rbx), %rdx
leaq 0xc8(%rsp), %rdi
xorl %ecx, %ecx
callq 0x7db24
leaq 0xc8(%rsp), %rdi
callq 0x7393e
movl 0x30(%rsp), %ebx
leaq 0x200(%rsp), %rdi
callq 0x6548
leaq 0x220(%rsp), %rdi
callq 0x65c50
movl %ebx, %eax
addq $0x308, %rsp            # imm = 0x308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %r14
leaq 0x2a456(%rip), %rsi     # 0x9b486
leaq 0xc8(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0xc8(%rsp), %rsi
movq %r14, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0x75d5f(%rip), %rsi     # 0xe6dc0
movq 0x76f78(%rip), %rdx     # 0xe7fe0
movq %r14, %rdi
callq 0x6490
jmp 0x710c4
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %r14
leaq 0x2a444(%rip), %rsi     # 0x9b4c8
leaq 0xc8(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0xc8(%rsp), %rsi
movq %r14, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0x75d0b(%rip), %rsi     # 0xe6dc0
movq 0x76f24(%rip), %rdx     # 0xe7fe0
movq %r14, %rdi
callq 0x6490
jmp 0x71381
jmp 0x71117
jmp 0x71131
jmp 0x71381
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x6548
jmp 0x710e7
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x6548
jmp 0x710f9
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x7137a
jmp 0x71381
jmp 0x71381
jmp 0x71251
jmp 0x71251
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x71134
jmp 0x71384
movq %rax, %rbx
movq %r14, %rdi
callq 0x6200
jmp 0x71384
jmp 0x71251
jmp 0x71381
jmp 0x71381
jmp 0x71381
jmp 0x71251
jmp 0x71381
jmp 0x71381
jmp 0x71381
movq %rax, %rbx
leaq 0x2a8(%rsp), %rdi
callq 0x6548
jmp 0x71183
jmp 0x7131f
movq %rax, %rbx
leaq 0x248(%rsp), %rdi
jmp 0x7137a
jmp 0x7130c
jmp 0x7131f
jmp 0x71381
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x71341
jmp 0x7130c
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x17a3e
jmp 0x71363
jmp 0x711e4
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x6548
jmp 0x71363
jmp 0x71208
jmp 0x71360
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x738d2
jmp 0x71363
jmp 0x71360
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x738f0
jmp 0x71363
jmp 0x7130c
jmp 0x71251
jmp 0x71381
jmp 0x71381
jmp 0x71381
jmp 0x71381
jmp 0x71381
jmp 0x71381
jmp 0x71381
movq %rax, %rbx
jmp 0x71391
jmp 0x71381
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
jmp 0x71368
jmp 0x7136f
jmp 0x7136f
jmp 0x7127c
jmp 0x7129b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x7390a
jmp 0x71372
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xbe36
leaq 0xc8(%rsp), %rdi
callq 0x73924
jmp 0x71372
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
jmp 0x71368
jmp 0x71360
jmp 0x71360
movq %rax, %rbx
leaq 0x2e8(%rsp), %rdi
callq 0x6548
jmp 0x712f5
jmp 0x7136f
jmp 0x71381
jmp 0x7136f
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
jmp 0x7137a
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
jmp 0x71368
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
jmp 0x71341
jmp 0x71381
jmp 0x71360
jmp 0x71381
movq %rax, %rbx
jmp 0x71346
movq %rax, %rbx
jmp 0x71339
movq %rax, %rbx
leaq 0x2c8(%rsp), %rdi
callq 0x6548
leaq 0x268(%rsp), %rdi
callq 0x6548
leaq 0xc8(%rsp), %rdi
jmp 0x7137a
jmp 0x71381
jmp 0x7136f
jmp 0x71381
jmp 0x71381
jmp 0x71381
jmp 0x71381
jmp 0x7136f
jmp 0x71381
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6548
jmp 0x71372
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x6548
jmp 0x71384
movq %rax, %rbx
leaq 0x200(%rsp), %rdi
callq 0x6548
leaq 0x220(%rsp), %rdi
callq 0x65c50
movq %rbx, %rdi
callq 0x64b0