// File: /workspace/github_cpp_makefile_star2_O1/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 $0x328, %rsp            # imm = 0x328
movq %rdi, %rbx
movl %esi, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x1e0(%rsp)
movq $0x0, 0x1f0(%rsp)
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r12
cmpq %r12, %r14
je 0x8aa92
movl %esi, %ebp
cmpl $0x2, 0x8(%r14)
jne 0x8aa85
movq %r14, %rdi
callq 0xb2e2
movq %rax, %r13
movl 0xc(%rax), %esi
movq %rbx, %rdi
callq 0xa426
movq %rax, %r15
movl 0x10(%r13), %eax
cmpl 0x10(%rsp), %eax
jne 0x8aa85
movl 0x8(%r13), %esi
movq %rbx, %rdi
callq 0x13f62
testb %al, %al
je 0x8aa85
xorl %edx, %edx
cmpl $0x3, %ebp
sete %dl
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1324c
testb %al, %al
jne 0x8aa85
cmpb $0x1, 0x60(%r15)
jne 0x8aa85
movq %r13, 0x80(%rsp)
movq 0x1e8(%rsp), %rsi
cmpq 0x1f0(%rsp), %rsi
je 0x8aa70
movq %r13, (%rsi)
addq $0x8, 0x1e8(%rsp)
jmp 0x8aa85
leaq 0x1e0(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x7eef6
addq $0x10, %r14
cmpq %r12, %r14
jne 0x8a9ec
movq 0x1e0(%rsp), %rax
cmpq 0x1e8(%rsp), %rax
je 0x8abbf
leaq 0x8(%rbx), %rdi
movl $0x3, %esi
callq 0x2561c
movl %eax, %r14d
movl %eax, 0x8(%rsp)
movq %rbx, %rdi
movl %eax, %esi
callq 0x1c15a
movq %rax, %r15
movl $0xc, 0xc(%rax)
movl 0x10(%rsp), %eax
movl %eax, 0x64(%r15)
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x14ea4
movq %r15, 0x78(%rsp)
leal 0x1(%r14), %esi
movl %esi, 0x1c(%rsp)
leaq 0x80(%rsp), %r8
movl $0x0, (%r8)
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0xa4506
addl $0x2, %r14d
movl %r14d, 0x18(%rax)
leaq 0x1d0(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x10(%rsp), %eax
cmpl $0x1, %eax
je 0x8abc6
cmpl $0x3, %eax
jne 0x8ac4b
leaq 0x980(%rbx), %rsi
leaq 0x1c0(%rsp), %rdi
callq 0x6170
xorl %ebp, %ebp
cmpb $0x1, 0x937(%rbx)
movl $0x0, %eax
jne 0x8ab85
movq %rbx, %rdi
callq 0x16112
cmpl $0x0, 0xb8(%rax)
sete %al
testb %al, %al
jne 0x8ab8d
movl 0x1c(%rsp), %ebp
movl 0x108(%rbx), %esi
movq %rbx, %rdi
callq 0xb9ca
movq %rax, %r14
movl 0x1c(%rsp), %eax
movl %eax, 0x80(%rsp)
movq 0x50(%r14), %rsi
cmpq 0x58(%r14), %rsi
je 0x8abdc
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%r14)
jmp 0x8abf0
xorl %ebx, %ebx
jmp 0x8c7d2
leaq 0x960(%rbx), %rsi
leaq 0x1c0(%rsp), %rdi
callq 0x6170
jmp 0x8ac4b
movq %r14, %rdi
addq $0x48, %rdi
leaq 0x80(%rsp), %rdx
callq 0x7a00
movq 0x68(%r14), %r15
movq 0x70(%r14), %r14
cmpq %r14, %r15
je 0x8ac17
movl (%r15), %esi
movq %rbx, %rdi
callq 0x78fe
cmpl $0x4, 0xc(%rax)
jne 0x8ac11
movl %ebp, 0x24(%rax)
addq $0x4, %r15
jmp 0x8abf8
movq 0x8e8(%rbx), %rsi
cmpq 0x8f0(%rbx), %rsi
je 0x8ac3a
movl 0x1c(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8e8(%rbx)
jmp 0x8ac4b
leaq 0x8e0(%rbx), %rdi
leaq 0x1c(%rsp), %rdx
callq 0x7a00
movl 0x8(%rsp), %ebp
movl 0x108(%rbx), %edx
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq *0x38(%rax)
leaq 0x34340(%rip), %rsi     # 0xbefaf
leaq 0x20(%rsp), %rdi
callq 0x64e0
leaq 0x58(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8aca0
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x8aca6
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x48(%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 0x90(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8ad07
movq %rdx, 0x80(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x90(%rsp)
jmp 0x8ad0e
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rsi
leaq 0x80(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14bd2
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x8ad54
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8ad70
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ad8b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x1c(%rsp), %esi
leaq 0x1c0(%rsp), %rdx
movq %rbx, %rdi
callq 0x14bd2
movl 0x108(%rbx), %esi
movq %rbx, %rdi
callq 0xb9ca
movq %rax, 0x200(%rsp)
movq 0x1e0(%rsp), %rcx
movq 0x1e8(%rsp), %rax
movq %rax, 0x2b0(%rsp)
cmpq %rax, %rcx
je 0x8c779
movq 0x200(%rsp), %rax
leaq 0x48(%rax), %rdx
movq %rdx, 0x220(%rsp)
leaq 0x8e0(%rbx), %rdx
movq %rdx, 0x218(%rsp)
movq 0x78(%rsp), %rdx
addq $0x68, %rdx
movq %rdx, 0x210(%rsp)
movl $0x98, %edx
leaq (%rax,%rdx), %rsi
movq %rsi, 0x240(%rsp)
movl $0xb0, %esi
addq %rsi, %rax
movq %rax, 0x238(%rsp)
leaq 0x80(%rsp), %rax
addq %rax, %rdx
movq %rdx, 0x2a8(%rsp)
addq %rax, %rsi
movq %rsi, 0x208(%rsp)
leaq 0x725b0(%rip), %rax     # 0xfd400
addq $0x10, %rax
movq %rax, 0x230(%rsp)
leaq 0x7254d(%rip), %rax     # 0xfd3b0
addq $0x10, %rax
movq %rax, 0x1b8(%rsp)
leaq 0x940(%rbx), %rax
movq %rax, 0x228(%rsp)
movq %rcx, 0x2c0(%rsp)
movq (%rcx), %r14
movl 0xc(%r14), %esi
movl %esi, 0x14(%rsp)
movq %rbx, %rdi
callq 0xa426
movq %rax, %r13
movl 0xc(%rax), %eax
cmpl $0xc, %eax
ja 0x8c75f
movl $0xefc, %ecx            # imm = 0xEFC
btl %eax, %ecx
jae 0x8b352
movq %rbx, %rdi
movq %r14, %rsi
callq 0x133a2
movl %eax, %r15d
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl $0xb, %edx
callq 0x14ff6
movl %eax, 0x18(%rsp)
leaq 0x80(%rsp), %r12
leaq 0x8(%r14), %rbp
movl (%rbp), %esi
movq %rbx, %rdi
movl $0xe, %edx
callq 0x1299a
movb %al, 0xf(%rsp)
movl (%rbp), %esi
movq %rbx, %rdi
movl $0xd, %edx
callq 0x1299a
movb %al, 0xe(%rsp)
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x1299a
movb %al, 0xd(%rsp)
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x11, %edx
callq 0x1299a
movb %al, 0xc(%rsp)
testb %r15b, %r15b
je 0x8af5f
movl 0x10(%rsp), %edx
movq %rbx, %rdi
movl 0x18(%rsp), %esi
callq 0x1a80e
testb %al, %al
je 0x8c75f
testb %r15b, %r15b
leaq 0x80(%rsp), %r12
jne 0x8afbd
movl 0x10(%rsp), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x8afbd
movq %rbx, %rdi
movq %r13, %rsi
callq 0x134f8
testb %al, %al
jne 0x8af89
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1350a
testb %al, %al
je 0x8afbd
movq %rbx, %rdi
movq %r13, %rsi
callq 0x134f8
testb %al, %al
movq %r14, 0x70(%rsp)
je 0x8b3a6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1350a
testb %al, %al
jne 0x8c803
movl 0x18(%r13), %r14d
jmp 0x8b424
movq 0x78(%rsp), %rax
movq 0x70(%rax), %r13
subq 0x68(%rax), %r13
movl 0x14(%rsp), %esi
movq %rbx, %rdi
movl 0x18(%rsp), %edx
callq 0x8f92e
movl %eax, 0x14(%rsp)
movl %eax, 0xc(%r14)
movq 0x78(%rsp), %rcx
movq 0x70(%rcx), %rsi
cmpq 0x78(%rcx), %rsi
je 0x8affd
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rcx)
jmp 0x8b00f
movq 0x210(%rsp), %rdi
leaq 0x14(%rsp), %rdx
callq 0x7a00
movl (%rbp), %edx
leaq 0x2c8(%rsp), %rdi
movq %rbx, %rsi
callq 0x345e6
leaq 0x258(%rsp), %rax
movq %rax, 0x248(%rsp)
leaq 0x248(%rsp), %r14
movq %r14, %rdi
leaq 0x30534(%rip), %rsi     # 0xbb578
leaq 0x3052e(%rip), %rdx     # 0xbb579
callq 0x7c64
movq %r12, %rdi
leaq 0x2c8(%rsp), %rdx
movq %r14, %rcx
callq 0x8f7f6
movq 0x248(%rsp), %rdi
leaq 0x258(%rsp), %rax
cmpq %rax, %rdi
je 0x8b088
movq 0x258(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2c8(%rsp), %rdi
leaq 0x2d8(%rsp), %rax
cmpq %rax, %rdi
je 0x8b0ad
movq 0x2d8(%rsp), %rsi
incq %rsi
callq 0x6260
shrq $0x2, %r13
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movq %r12, %rcx
callq 0x14ce0
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xe480
movq %r14, %rdi
leaq 0x30762(%rip), %rsi     # 0xbb859
callq 0x64e0
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq %r14, %rdi
callq 0x60b0
leaq 0x58(%rsp), %rsi
movq %rsi, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8b13c
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x8b142
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8b176
movq 0x30(%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 0x48(%rsp), %rsi
callq 0x6170
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14fd8
testb $0x40, 0x3(%rax)
je 0x8b1e0
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x14ff6
movl %eax, %r12d
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x1e, %ecx
movl %eax, %r8d
callq 0x14cd6
movl 0x10(%rsp), %edx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x8f8e8
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14fd8
testb $-0x80, 0x3(%rax)
je 0x8b218
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x1f, %edx
callq 0x14ff6
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x1f, %ecx
movl %eax, %r8d
callq 0x14cd6
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14fd8
movabsq $0x100000000, %rcx      # imm = 0x100000000
testq %rcx, (%rax)
je 0x8b259
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x20, %edx
callq 0x14ff6
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x20, %ecx
movl %eax, %r8d
callq 0x14cd6
testb %r15b, %r15b
je 0x8b290
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0xb, %ecx
movl 0x18(%rsp), %r8d
callq 0x14cd6
cmpl $0x0, 0x18(%rsp)
jne 0x8b290
movq 0x228(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6170
cmpb $0x0, 0xf(%rsp)
je 0x8b2ae
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xe(%rsp)
je 0x8b2cc
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0xd, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xd(%rsp)
je 0x8b2ea
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x10, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xc(%rsp)
je 0x8b308
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r13d, %edx
movl $0x11, %ecx
xorl %r8d, %r8d
callq 0x14cd6
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8b324
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x8c75f
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8c75f
cmpl $0xc, %eax
jne 0x8c75f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13422
testb %al, %al
jne 0x8bbb1
movl 0x8(%r14), %eax
movl %eax, 0x80(%rsp)
movq 0x200(%rsp), %rcx
movq 0x50(%rcx), %rsi
cmpq 0x58(%rcx), %rsi
leaq 0x80(%rsp), %rdx
je 0x8bb72
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rcx)
jmp 0x8bb7f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1350a
xorl %r14d, %r14d
testb %al, %al
je 0x8b424
movq 0x28(%r13), %rax
movq %rax, %rcx
subq 0x20(%r13), %rcx
cmpq $0x4, %rcx
jne 0x8c871
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), %r14d
jb 0x8b424
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1c66e
movl 0x10(%rax), %r14d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1350a
testb %al, %al
jne 0x8b442
movq %rbx, %rdi
movq %r13, %rsi
callq 0x134f8
testb %al, %al
je 0x8b456
movl 0x9c(%r13), %esi
movq %rbx, %rdi
callq 0xa426
movq %rax, %r13
jmp 0x8b424
movl (%rbp), %eax
movl %eax, 0x80(%rsp)
movq 0x200(%rsp), %rcx
movq 0x50(%rcx), %rsi
cmpq 0x58(%rcx), %rsi
je 0x8b47e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rcx)
jmp 0x8b48e
movq 0x220(%rsp), %rdi
movq %r12, %rdx
callq 0x7a00
movq 0x8e8(%rbx), %rsi
cmpq 0x8f0(%rbx), %rsi
je 0x8b4b0
movl (%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8e8(%rbx)
jmp 0x8b4c0
movq 0x218(%rsp), %rdi
movq %rbp, %rdx
callq 0x7a00
movl $0x0, 0x190(%rsp)
testl %r14d, %r14d
je 0x8c75f
addq $0x8, %r13
movq 0x78(%rsp), %rcx
movq 0x70(%rcx), %rsi
movq %rsi, %r15
subq 0x68(%rcx), %r15
cmpq 0x78(%rcx), %rsi
je 0x8b4fe
movl (%r13), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rcx)
jmp 0x8b50e
movq 0x210(%rsp), %rdi
movq %r13, %rdx
callq 0x7a00
movl (%rbp), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x345e6
leaq 0x2e8(%rsp), %rdi
movq %r12, %rsi
leaq 0x33a81(%rip), %rdx     # 0xbefaf
leaq 0x190(%rsp), %rcx
callq 0xa454d
leaq 0x278(%rsp), %rax
movq %rax, 0x268(%rsp)
leaq 0x268(%rsp), %r12
movq %r12, %rdi
leaq 0x3001b(%rip), %rsi     # 0xbb578
leaq 0x30015(%rip), %rdx     # 0xbb579
callq 0x7c64
leaq 0x48(%rsp), %rdi
leaq 0x2e8(%rsp), %rdx
movq %r12, %rcx
callq 0x8f7f6
movq 0x268(%rsp), %rdi
leaq 0x278(%rsp), %rax
cmpq %rax, %rdi
je 0x8b5a3
movq 0x278(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x2e8(%rsp), %rdi
leaq 0x2f8(%rsp), %rax
cmpq %rax, %rdi
je 0x8b5c8
movq 0x2f8(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x8b5ed
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x6260
shrq $0x2, %r15
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
leaq 0x48(%rsp), %rcx
callq 0x14ce0
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14fd8
testb $0x40, 0x3(%rax)
je 0x8b657
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x14ff6
movl %eax, %r12d
addl 0x190(%rsp), %r12d
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x1e, %ecx
movl %r12d, %r8d
callq 0x14cd6
movl 0x10(%rsp), %edx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x8f8e8
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x14fd8
leaq 0x80(%rsp), %r12
movabsq $0x100000000, %rcx      # imm = 0x100000000
testq %rcx, (%rax)
je 0x8b6a0
movl (%rbp), %esi
movq %rbx, %rdi
movl $0x20, %edx
callq 0x14ff6
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x20, %ecx
movl %eax, %r8d
callq 0x14cd6
cmpb $0x0, 0xf(%rsp)
je 0x8b6be
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xe(%rsp)
je 0x8b6dc
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0xd, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xd(%rsp)
je 0x8b6fa
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x10, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xc(%rsp)
je 0x8b718
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r15d, %edx
movl $0x11, %ecx
xorl %r8d, %r8d
callq 0x14cd6
movl 0x10(%rsp), %eax
cmpl $0x3, %eax
je 0x8b810
cmpl $0x1, %eax
jne 0x8bb38
movq %rbx, 0x80(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x88(%rsp)
movl 0x190(%rsp), %eax
movl %eax, 0x90(%rsp)
leaq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x98(%rsp), %rdi
callq 0xe480
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
addq %rsi, %rdx
leaq 0xb8(%rsp), %rdi
callq 0xe480
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x58, %edi
callq 0x6250
movq %rax, %rcx
movl 0x90(%rsp), %edx
movl %edx, 0x10(%rax)
movups 0x80(%rsp), %xmm0
movups %xmm0, (%rax)
leaq 0x28(%rax), %rdx
movq %rdx, 0x18(%rax)
movq 0x98(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
cmpq %rdi, %rsi
je 0x8b8e8
movq %rsi, 0x18(%rcx)
movq 0xa8(%rsp), %rdx
movq %rdx, 0x28(%rcx)
jmp 0x8b8ee
movq %rbx, 0x80(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x88(%rsp), %rdi
callq 0xe480
leaq 0xb8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
addq %rsi, %rdx
leaq 0xa8(%rsp), %rdi
callq 0xe480
movq 0x70(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl 0x190(%rsp), %eax
movl %eax, 0xd0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x58, %edi
callq 0x6250
movq %rax, %rcx
movq 0x80(%rsp), %rdx
movq %rdx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq 0x88(%rsp), %rsi
leaq 0x98(%rsp), %rdi
cmpq %rdi, %rsi
je 0x8ba06
movq %rsi, 0x8(%rcx)
movq 0x98(%rsp), %rdx
movq %rdx, 0x18(%rcx)
jmp 0x8ba0c
movups (%rdi), %xmm0
movups %xmm0, (%rdx)
movq 0xa0(%rsp), %rdx
movq %rdx, 0x20(%rcx)
movq %rdi, 0x98(%rsp)
movq $0x0, 0xa0(%rsp)
movb $0x0, 0xa8(%rsp)
addq $0x48, %rax
movq %rax, 0x38(%rcx)
movq 0xb8(%rsp), %rdx
leaq 0xc8(%rsp), %rsi
cmpq %rsi, %rdx
je 0x8b945
movq %rdx, 0x38(%rcx)
movq 0xc8(%rsp), %rax
movq %rax, 0x48(%rcx)
jmp 0x8b94b
movups (%rsi), %xmm0
movups %xmm0, (%rax)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%rcx)
movq %rsi, 0xb8(%rsp)
movq $0x0, 0xc0(%rsp)
movb $0x0, 0xc8(%rsp)
movq %rcx, 0x20(%rsp)
leaq 0x16789(%rip), %rax     # 0xa2108
movq %rax, 0x38(%rsp)
leaq 0x16833(%rip), %rax     # 0xa21be
movq %rax, 0x30(%rsp)
movq 0x238(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xa939c
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x8b9bb
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x8b9e0
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x8bb38
movq 0xa8(%rsp), %rsi
jmp 0x8bb30
movups (%rdi), %xmm0
movups %xmm0, (%rdx)
movq 0x90(%rsp), %rdx
movq %rdx, 0x10(%rcx)
movq %rdi, 0x88(%rsp)
movq $0x0, 0x90(%rsp)
movb $0x0, 0x98(%rsp)
addq $0x38, %rax
movq %rax, 0x28(%rcx)
movq 0xa8(%rsp), %rdx
leaq 0xb8(%rsp), %rsi
cmpq %rsi, %rdx
je 0x8ba63
movq %rdx, 0x28(%rcx)
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rcx)
jmp 0x8ba69
movups (%rsi), %xmm0
movups %xmm0, (%rax)
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%rcx)
movq %rsi, 0xa8(%rsp)
movq $0x0, 0xb0(%rsp)
movb $0x0, 0xb8(%rsp)
leaq 0xc8(%rsp), %rdx
movl 0x8(%rdx), %eax
movl %eax, 0x50(%rcx)
movq (%rdx), %rax
movq %rax, 0x48(%rcx)
movq %rcx, 0x20(%rsp)
leaq 0x1682c(%rip), %rax     # 0xa22de
movq %rax, 0x38(%rsp)
leaq 0x168e4(%rip), %rax     # 0xa23a2
movq %rax, 0x30(%rsp)
movq 0x240(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xa939c
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x8baee
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x8bb13
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x8bb38
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8bb54
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x190(%rsp), %eax
incl %eax
movl %eax, 0x190(%rsp)
cmpl %r14d, %eax
jb 0x8b4d8
jmp 0x8c75f
movq 0x220(%rsp), %rdi
callq 0x7a00
leaq 0x8(%r14), %rdx
movq 0x8e8(%rbx), %rsi
cmpq 0x8f0(%rbx), %rsi
je 0x8bba4
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8e8(%rbx)
jmp 0x8bbb1
movq 0x218(%rsp), %rdi
callq 0x7a00
movq 0x68(%r13), %r12
movq 0x70(%r13), %rax
movq %rax, 0x2b8(%rsp)
cmpq %rax, %r12
je 0x8c75f
xorl %ebp, %ebp
movq %r14, 0x70(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
leaq 0x6c(%rsp), %rcx
callq 0x13472
movl %eax, %r15d
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0xe, %ecx
callq 0x14222
movb $0x1, 0xf(%rsp)
testb %al, %al
jne 0x8bc17
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl $0xe, %edx
callq 0x1299a
movb %al, 0xf(%rsp)
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0xd, %ecx
callq 0x14222
movb $0x1, 0xe(%rsp)
testb %al, %al
jne 0x8bc48
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl $0xd, %edx
callq 0x1299a
movb %al, 0xe(%rsp)
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x10, %ecx
callq 0x14222
movb $0x1, 0xd(%rsp)
testb %al, %al
jne 0x8bc79
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x1299a
movb %al, 0xd(%rsp)
movl 0x8(%r13), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x11, %ecx
callq 0x14222
movb $0x1, 0xc(%rsp)
testb %al, %al
jne 0x8bcaa
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl $0x11, %edx
callq 0x1299a
movb %al, 0xc(%rsp)
testb %r15b, %r15b
je 0x8bcc7
movl 0x6c(%rsp), %esi
movl 0x10(%rsp), %edx
movq %rbx, %rdi
callq 0x1a80e
testb %al, %al
je 0x8c74b
movq 0x78(%rsp), %rax
movq 0x70(%rax), %r14
subq 0x68(%rax), %r14
movl (%r12), %esi
movl 0x6c(%rsp), %edx
movq %rbx, %rdi
callq 0x8f92e
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 0x8bd10
movl (%r12), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rcx)
jmp 0x8bd20
movq 0x210(%rsp), %rdi
movq %r12, %rdx
callq 0x7a00
movb %r15b, 0x18(%rsp)
leaq 0x308(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl %ebp, %ecx
callq 0x8fa72
leaq 0x298(%rsp), %rax
movq %rax, 0x288(%rsp)
leaq 0x288(%rsp), %r15
movq %r15, %rdi
leaq 0x2f81c(%rip), %rsi     # 0xbb578
leaq 0x2f816(%rip), %rdx     # 0xbb579
callq 0x7c64
leaq 0x48(%rsp), %rdi
leaq 0x308(%rsp), %rdx
movq %r15, %rcx
callq 0x8f7f6
movq 0x288(%rsp), %rdi
leaq 0x298(%rsp), %rax
cmpq %rax, %rdi
je 0x8bda2
movq 0x298(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x308(%rsp), %rdi
leaq 0x318(%rsp), %rax
cmpq %rax, %rdi
je 0x8bdc7
movq 0x318(%rsp), %rsi
incq %rsi
callq 0x6260
shrq $0x2, %r14
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
leaq 0x48(%rsp), %rcx
callq 0x14ce0
leaq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x1c0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq 0xe480
movq %r15, %rdi
leaq 0x2fa3d(%rip), %rsi     # 0xbb859
callq 0x64e0
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x60b0
leaq 0x30(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movb 0x18(%rsp), %r15b
je 0x8be60
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x8be66
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x8bea3
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x6260
testb %r15b, %r15b
je 0x8bec0
movl 0x14(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
leaq 0x20(%rsp), %rcx
callq 0x14cf4
jmp 0x8c56a
movl 0x10(%rsp), %eax
cmpl $0x3, %eax
je 0x8c0d5
cmpl $0x1, %eax
jne 0x8c56a
movq %rbx, 0x80(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
movq %r13, %rsi
callq 0x1f216
movl %ebp, 0x168(%rsp)
leaq 0x180(%rsp), %rax
movq %rax, 0x170(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x170(%rsp), %rdi
callq 0xe480
xorps %xmm0, %xmm0
movaps %xmm0, 0x1a0(%rsp)
movaps %xmm0, 0x190(%rsp)
movl $0x110, %edi            # imm = 0x110
callq 0x6250
movq %rax, %r15
movups 0x80(%rsp), %xmm0
movups %xmm0, (%rax)
movq 0x230(%rsp), %rax
movq %rax, 0x10(%r15)
movl 0x98(%rsp), %eax
movl %eax, 0x18(%r15)
movq 0x1b8(%rsp), %rax
movq %rax, 0x10(%r15)
leaq 0x88(%rsp), %rcx
movups 0x14(%rcx), %xmm0
movups %xmm0, 0x1c(%r15)
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%r15)
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%r15)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%r15)
leaq 0xb0(%rsp), %rax
movl $0x0, %esi
movq %rsi, 0x10(%rax)
xorps %xmm2, %xmm2
movups %xmm2, (%rax)
leaq 0xc8(%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, 0xc8(%rsp)
movl %esi, 0xd0(%rsp)
movq %rsi, 0xd8(%rsp)
movl %esi, 0xe0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x70(%r15)
movq 0xf8(%rsp), %rax
movq %rax, 0x78(%r15)
movq 0x100(%rsp), %rax
movq %rax, 0x80(%r15)
movq 0x108(%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 0x208(%rsp), %rdx
movq %rdx, %rsi
callq 0xa95c0
movl 0x168(%rsp), %eax
movl %eax, 0xe8(%r15)
movq %r15, %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0xf0(%r15)
movq 0x170(%rsp), %rcx
leaq 0x180(%rsp), %rdx
cmpq %rdx, %rcx
je 0x8c18c
movq %rcx, 0xf0(%r15)
movq 0x180(%rsp), %rax
movq %rax, 0x100(%r15)
jmp 0x8c192
movq %rbx, 0x80(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x88(%rsp), %rdi
callq 0xe480
movq 0x70(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
movq %r13, %rsi
callq 0x1f216
movl %ebp, 0x188(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x190(%rsp)
movaps %xmm0, 0x1a0(%rsp)
movl $0x110, %edi            # imm = 0x110
callq 0x6250
movq %rax, %r15
movq 0x80(%rsp), %rax
movq %rax, (%r15)
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq 0x88(%rsp), %rcx
leaq 0x98(%rsp), %rdx
cmpq %rdx, %rcx
je 0x8c2dc
movq %rcx, 0x8(%r15)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%r15)
jmp 0x8c2e2
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x178(%rsp), %rax
movq %rax, 0xf8(%r15)
movq %rdx, 0x170(%rsp)
movq $0x0, 0x178(%rsp)
movb $0x0, 0x180(%rsp)
movq %r15, 0x190(%rsp)
leaq 0x15a76(%rip), %rax     # 0xa1c42
movq %rax, 0x1a8(%rsp)
leaq 0x15b5f(%rip), %rax     # 0xa1d3a
movq %rax, 0x1a0(%rsp)
movq 0x238(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0xa939c
movq 0x1a0(%rsp), %rax
testq %rax, %rax
je 0x8c217
leaq 0x190(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x170(%rsp), %rdi
leaq 0x180(%rsp), %rax
cmpq %rax, %rdi
je 0x8c23c
movq 0x180(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x1b8(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x208(%rsp), %rdi
callq 0xdeb6
movq 0xf8(%rsp), %rdi
testq %rdi, %rdi
je 0x8c276
movq 0x108(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x8c2bb
movq 0xe8(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0xc8(%rsp)
movl %eax, 0xd0(%rsp)
movq %rax, 0xd8(%rsp)
movl %eax, 0xe0(%rsp)
movq %rax, 0xe8(%rsp)
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x8c56a
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
jmp 0x8c565
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%r15)
movq %rdx, 0x88(%rsp)
xorl %edx, %edx
movq %rdx, 0x90(%rsp)
movb $0x0, 0x98(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%r15)
movq 0x230(%rsp), %rax
movq %rax, 0x30(%r15)
movl 0xb8(%rsp), %eax
movl %eax, 0x38(%r15)
movq 0x1b8(%rsp), %rax
movq %rax, 0x30(%r15)
leaq 0x88(%rsp), %rcx
movups 0x34(%rcx), %xmm0
movups %xmm0, 0x3c(%r15)
movq 0xd0(%rsp), %rax
movq %rax, 0x50(%r15)
movq 0xd8(%rsp), %rax
movq %rax, 0x58(%r15)
movq 0xe0(%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, 0xe8(%rsp)
movl %edx, 0xf0(%rsp)
movq %rdx, 0xf8(%rsp)
movl %edx, 0x100(%rsp)
movq %rdx, 0x108(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x90(%r15)
movq 0x118(%rsp), %rax
movq %rax, 0x98(%r15)
movq 0x120(%rsp), %rax
movq %rax, 0xa0(%r15)
movq 0x128(%rsp), %rax
movq %rax, 0xa8(%r15)
movq 0x2a8(%rsp), %rax
movq %rdx, 0x10(%rax)
movups %xmm2, (%rax)
movq 0x208(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0xc0(%r15)
movups %xmm0, 0xb0(%r15)
movq %r15, %rdi
addq $0xd0, %rdi
leaq 0x150(%rsp), %rdx
movq %rdx, %rsi
callq 0xa95c0
movl 0x188(%rsp), %eax
movl %eax, 0x108(%r15)
movq %r15, 0x190(%rsp)
leaq 0x15a48(%rip), %rax     # 0xa1ea6
movq %rax, 0x1a8(%rsp)
leaq 0x15b2d(%rip), %rax     # 0xa1f9a
movq %rax, 0x1a0(%rsp)
movq 0x240(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0xa939c
movq 0x1a0(%rsp), %rax
testq %rax, %rax
je 0x8c4a9
leaq 0x190(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x1b8(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0x150(%rsp), %rdi
callq 0xdeb6
movq 0x118(%rsp), %rdi
testq %rdi, %rdi
je 0x8c4e3
movq 0x128(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0x8c528
movq 0x108(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0xe8(%rsp)
movl %eax, 0xf0(%rsp)
movq %rax, 0xf8(%rsp)
movl %eax, 0x100(%rsp)
movq %rax, 0x108(%rsp)
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x8c545
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x8c56a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x14(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1e, %ecx
callq 0x14222
testb %al, %al
je 0x8c5bf
movl 0x14(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1e, %ecx
callq 0x14e6c
movl %eax, %r15d
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x1e, %ecx
movl %eax, %r8d
callq 0x14cd6
movl 0x10(%rsp), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8f8e8
jmp 0x8c619
movq 0x70(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x1299a
testb %al, %al
je 0x8c619
movq 0x70(%rsp), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
movl $0x1e, %edx
callq 0x14ff6
movl %eax, %r15d
addl %ebp, %r15d
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x1e, %ecx
movl %r15d, %r8d
callq 0x14cd6
movl 0x10(%rsp), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8f8e8
movl 0x14(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1f, %ecx
callq 0x14222
movb 0x18(%rsp), %r15b
testb %al, %al
je 0x8c65f
movl 0x14(%rsp), %esi
movq %rbx, %rdi
movl %ebp, %edx
movl $0x1f, %ecx
callq 0x14e6c
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x1f, %ecx
movl %eax, %r8d
callq 0x14cd6
testb %r15b, %r15b
je 0x8c696
movl 0x8(%rsp), %esi
movl 0x6c(%rsp), %r8d
movq %rbx, %rdi
movl %r14d, %edx
movl $0xb, %ecx
callq 0x14cd6
cmpl $0x0, 0x6c(%rsp)
jne 0x8c696
movq 0x228(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6170
cmpb $0x0, 0xf(%rsp)
je 0x8c6b4
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xe(%rsp)
je 0x8c6d2
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0xd, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xd(%rsp)
je 0x8c6f0
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x10, %ecx
xorl %r8d, %r8d
callq 0x14cd6
cmpb $0x0, 0xc(%rsp)
je 0x8c70e
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x11, %ecx
xorl %r8d, %r8d
callq 0x14cd6
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8c72a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
movq 0x70(%rsp), %r14
je 0x8c74b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
incl %ebp
addq $0x4, %r12
cmpq 0x2b8(%rsp), %r12
jne 0x8bbd1
movq 0x2c0(%rsp), %rcx
addq $0x8, %rcx
cmpq 0x2b0(%rsp), %rcx
jne 0x8ae7e
movl 0x8(%rsp), %eax
imulq $0x148, %rax, %rdx      # imm = 0x148
addq 0x38(%rbx), %rdx
leaq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
xorl %ecx, %ecx
callq 0xa1806
leaq 0x80(%rsp), %rdi
callq 0x8fd72
movl 0x1c(%rsp), %ebx
movq 0x1c0(%rsp), %rdi
leaq 0x1d0(%rsp), %rax
cmpq %rax, %rdi
je 0x8c7d2
movq 0x1d0(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x1e0(%rsp), %rdi
testq %rdi, %rdi
je 0x8c7ef
movq 0x1f0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movl %ebx, %eax
addq $0x328, %rsp            # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
movq %rax, (%rdi)
leaq 0x34cd4(%rip), %rsi     # 0xc14fe
leaq 0x34d0e(%rip), %rdx     # 0xc153f
callq 0x7c64
movb $0x1, %bpl
leaq 0x80(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0x70548(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x70520(%rip), %rsi     # 0xfcd80
movq 0x71771(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x8c8dd
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
movq %rax, (%rdi)
leaq 0x34ca8(%rip), %rsi     # 0xc1540
leaq 0x34ce0(%rip), %rdx     # 0xc157f
callq 0x7c64
movb $0x1, %bpl
leaq 0x80(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0x704da(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x704b2(%rip), %rsi     # 0xfcd80
movq 0x71703(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cccd
jmp 0x8c8f5
jmp 0x8c91f
jmp 0x8cddf
movq %rax, %rbx
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x8c925
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8c925
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8cde2
movq %r14, %rdi
callq 0x6200
jmp 0x8cde2
jmp 0x8cddf
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x8c965
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8c965
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8c986
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8c986
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8cde2
movq 0x30(%rsp), %rsi
jmp 0x8cdd5
jmp 0x8cddf
jmp 0x8cccd
jmp 0x8cccd
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cccd
jmp 0x8cbe0
jmp 0x8cbe0
jmp 0x8cddf
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x1c438
jmp 0x8cda0
jmp 0x8cd9d
movq %rax, %rbx
movq 0x1a0(%rsp), %rax
testq %rax, %rax
je 0x8ca15
leaq 0x190(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8ca15
jmp 0x8cbe0
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x8fc86
jmp 0x8cda0
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x8cda0
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8cda0
jmp 0x8cd9d
movq %rax, %rbx
movq 0x1a0(%rsp), %rax
testq %rax, %rax
je 0x8ca89
leaq 0x190(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8ca89
jmp 0x8cbe0
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x8fc08
jmp 0x8cda0
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cb04
movq %rax, %rbx
movq 0x248(%rsp), %rdi
leaq 0x258(%rsp), %rax
cmpq %rax, %rdi
je 0x8cade
movq 0x258(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8cade
jmp 0x8cd1b
jmp 0x8ccfd
movq %rax, %rbx
movq 0x2c8(%rsp), %rdi
leaq 0x2d8(%rsp), %rax
cmpq %rax, %rdi
je 0x8cde2
movq 0x2d8(%rsp), %rsi
jmp 0x8cdd5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8cd7c
movq 0x30(%rsp), %rsi
jmp 0x8cd74
jmp 0x8cd1b
jmp 0x8ccfd
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8ccfd
jmp 0x8cbe0
jmp 0x8cbe0
jmp 0x8cccd
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cd9d
jmp 0x8cddf
movq %rax, %rbx
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x8cdc1
movq 0xa8(%rsp), %rsi
jmp 0x8cdb4
jmp 0x8cdbe
jmp 0x8cdbe
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x8cbeb
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8cbeb
jmp 0x8cbe0
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x8cc00
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x8cc00
movq %rax, %rdi
callq 0xd589
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x8fd3a
jmp 0x8cdc1
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x8fd02
jmp 0x8cdc1
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x8cdc1
movq 0x98(%rsp), %rsi
jmp 0x8cdb4
jmp 0x8cd9d
jmp 0x8cc56
jmp 0x8cdbe
jmp 0x8cddf
jmp 0x8cdbe
movq %rax, %rbx
jmp 0x8cca7
movq %rax, %rbx
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x8cdc1
movq 0x90(%rsp), %rsi
jmp 0x8cdb4
movq %rax, %rbx
movq 0x288(%rsp), %rdi
leaq 0x298(%rsp), %rax
cmpq %rax, %rdi
je 0x8cca7
movq 0x298(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x308(%rsp), %rdi
leaq 0x318(%rsp), %rax
cmpq %rax, %rdi
je 0x8cde2
movq 0x318(%rsp), %rsi
jmp 0x8cdd5
movq %rax, %rbx
jmp 0x8ce07
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cd9d
jmp 0x8cddf
jmp 0x8cddf
jmp 0x8cddf
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8cd7c
movq 0x58(%rsp), %rsi
jmp 0x8cd74
jmp 0x8cddf
movq %rax, %rbx
jmp 0x8cd7c
jmp 0x8cddf
jmp 0x8cdbe
movq %rax, %rbx
movq 0x268(%rsp), %rdi
leaq 0x278(%rsp), %rax
cmpq %rax, %rdi
je 0x8cd57
movq 0x278(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8cd57
movq %rax, %rbx
movq 0x2e8(%rsp), %rdi
leaq 0x2f8(%rsp), %rax
cmpq %rax, %rdi
je 0x8cd7c
movq 0x2f8(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x8cde2
movq 0x90(%rsp), %rsi
jmp 0x8cdd5
jmp 0x8cdbe
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8cdc1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8cdc1
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8cde2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8cde2
movq %rax, %rbx
movq 0x1c0(%rsp), %rdi
leaq 0x1d0(%rsp), %rax
cmpq %rax, %rdi
je 0x8ce07
movq 0x1d0(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x1e0(%rsp), %rdi
testq %rdi, %rdi
je 0x8ce24
movq 0x1f0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0