// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::access_chain_internal[abi:cxx11](unsigned int, unsigned int const*, unsigned int, bool, bool, bool*, bool*)
string CompilerGLSL::access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count,
                                           bool index_is_literal, bool chain_only, bool *need_transpose,
                                           bool *result_is_packed)
{
	string expr;
	if (!chain_only)
		expr = to_enclosed_expression(base);

	// Start traversing type hierarchy at the proper non-pointer types,
	// but keep type_id referencing the original pointer for use below.
	uint32_t type_id = expression_type_id(base);
	const auto *type = &get_non_pointer_type(type_id);

	bool access_chain_is_arrayed = expr.find_first_of('[') != string::npos;
	bool row_major_matrix_needs_conversion = is_non_native_row_major_matrix(base);
	bool is_packed = has_decoration(base, DecorationCPacked);
	bool pending_array_enclose = false;
	bool dimension_flatten = false;

	for (uint32_t i = 0; i < count; i++)
	{
		uint32_t index = indices[i];

		// Arrays
		if (!type->array.empty())
		{
			// If we are flattening multidimensional arrays, only create opening bracket on first
			// array index.
			if (options.flatten_multidimensional_arrays && !pending_array_enclose)
			{
				dimension_flatten = type->array.size() > 1;
				pending_array_enclose = dimension_flatten;
				if (pending_array_enclose)
					expr += "[";
			}

			assert(type->parent_type);

			const auto append_index = [&]() {
				expr += "[";
				if (index_is_literal)
					expr += convert_to_string(index);
				else
					expr += to_expression(index);
				expr += "]";
			};

			auto *var = maybe_get<SPIRVariable>(base);
			if (backend.force_gl_in_out_block && i == 0 && var && is_builtin_variable(*var) &&
			    !has_decoration(type->self, DecorationBlock))
			{
				// This deals with scenarios for tesc/geom where arrays of gl_Position[] are declared.
				// Normally, these variables live in blocks when compiled from GLSL,
				// but HLSL seems to just emit straight arrays here.
				// We must pretend this access goes through gl_in/gl_out arrays
				// to be able to access certain builtins as arrays.
				auto builtin = ir.meta[base].decoration.builtin_type;
				switch (builtin)
				{
				// case BuiltInCullDistance: // These are already arrays, need to figure out rules for these in tess/geom.
				// case BuiltInClipDistance:
				case BuiltInPosition:
				case BuiltInPointSize:
					if (var->storage == StorageClassInput)
						expr = join("gl_in[", to_expression(index), "].", expr);
					else if (var->storage == StorageClassOutput)
						expr = join("gl_out[", to_expression(index), "].", expr);
					else
						append_index();
					break;

				default:
					append_index();
					break;
				}
			}
			else if (options.flatten_multidimensional_arrays && dimension_flatten)
			{
				// If we are flattening multidimensional arrays, do manual stride computation.
				auto &parent_type = get<SPIRType>(type->parent_type);

				if (index_is_literal)
					expr += convert_to_string(index);
				else
					expr += to_enclosed_expression(index);

				for (auto j = uint32_t(parent_type.array.size()); j; j--)
				{
					expr += " * ";
					expr += enclose_expression(to_array_size(parent_type, j - 1));
				}

				if (parent_type.array.empty())
					pending_array_enclose = false;
				else
					expr += " + ";

				if (!pending_array_enclose)
					expr += "]";
			}
			else
			{
				append_index();
			}

			type_id = type->parent_type;
			type = &get<SPIRType>(type_id);

			access_chain_is_arrayed = true;
		}
		// For structs, the index refers to a constant, which indexes into the members.
		// We also check if this member is a builtin, since we then replace the entire expression with the builtin one.
		else if (type->basetype == SPIRType::Struct)
		{
			if (!index_is_literal)
				index = get<SPIRConstant>(index).scalar();

			if (index >= type->member_types.size())
				SPIRV_CROSS_THROW("Member index is out of bounds!");

			BuiltIn builtin;
			if (is_member_builtin(*type, index, &builtin))
			{
				// FIXME: We rely here on OpName on gl_in/gl_out to make this work properly.
				// To make this properly work by omitting all OpName opcodes,
				// we need to infer gl_in or gl_out based on the builtin, and stage.
				if (access_chain_is_arrayed)
				{
					expr += ".";
					expr += builtin_to_glsl(builtin, type->storage);
				}
				else
					expr = builtin_to_glsl(builtin, type->storage);
			}
			else
			{
				// If the member has a qualified name, use it as the entire chain
				string qual_mbr_name = get_member_qualified_name(type_id, index);
				if (!qual_mbr_name.empty())
					expr = qual_mbr_name;
				else
					expr += to_member_reference(maybe_get_backing_variable(base), *type, index);
			}

			is_packed = member_is_packed_type(*type, index);
			row_major_matrix_needs_conversion = member_is_non_native_row_major_matrix(*type, index);
			type = &get<SPIRType>(type->member_types[index]);
		}
		// Matrix -> Vector
		else if (type->columns > 1)
		{
			if (row_major_matrix_needs_conversion)
			{
				expr = convert_row_major_matrix(expr, *type, is_packed);
				row_major_matrix_needs_conversion = false;
				is_packed = false;
			}

			expr += "[";
			if (index_is_literal)
				expr += convert_to_string(index);
			else
				expr += to_expression(index);
			expr += "]";

			type_id = type->parent_type;
			type = &get<SPIRType>(type_id);
		}
		// Vector -> Scalar
		else if (type->vecsize > 1)
		{
			if (index_is_literal && !is_packed)
			{
				expr += ".";
				expr += index_to_swizzle(index);
			}
			else if (ir.ids[index].get_type() == TypeConstant && !is_packed)
			{
				auto &c = get<SPIRConstant>(index);
				expr += ".";
				expr += index_to_swizzle(c.scalar());
			}
			else if (index_is_literal)
			{
				// For packed vectors, we can only access them as an array, not by swizzle.
				expr += join("[", index, "]");
			}
			else
			{
				expr += "[";
				expr += to_expression(index);
				expr += "]";
			}

			is_packed = false;
			type_id = type->parent_type;
			type = &get<SPIRType>(type_id);
		}
		else if (!backend.allow_truncated_access_chain)
			SPIRV_CROSS_THROW("Cannot subdivide a scalar value!");
	}

	if (pending_array_enclose)
	{
		SPIRV_CROSS_THROW("Flattening of multidimensional arrays were enabled, "
		                  "but the access chain was terminated in the middle of a multidimensional array. "
		                  "This is not supported.");
	}

	if (need_transpose)
		*need_transpose = row_major_matrix_needs_conversion;

	if (result_is_packed)
		*result_is_packed = is_packed;

	return expr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebp
movq %rcx, 0x68(%rsp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb 0x110(%rsp), %al
movb %r9b, 0xf(%rsp)
movb $0x0, 0x10(%rdi)
testb %al, %al
jne 0x2c808
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x2beca
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6320
movq %r14, %rdi
callq 0x6548
movq %r15, %rdi
movl %r13d, %esi
callq 0x10a5e
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x11e8c
movq %rax, 0x18(%rsp)
pushq $0x5b
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6370
cmpq $-0x1, %rax
setne 0x17(%rsp)
movq (%r15), %rax
movq %r15, %rdi
movl %r13d, %esi
callq *0x108(%rax)
movl %eax, 0x2c(%rsp)
pushq $0xa
popq %rdx
movq %r15, %rdi
movl %r13d, %esi
callq 0x103d2
movl %eax, 0x24(%rsp)
movl %r13d, 0x54(%rsp)
movl %r13d, %eax
movl %ebp, %ecx
movq %rcx, 0x70(%rsp)
xorl %ecx, %ecx
leaq 0x98(%rsp), %r13
leaq 0x78(%rsp), %rbp
imulq $0x148, %rax, %rax      # imm = 0x148
movq %rax, 0x60(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x50(%rsp)
cmpq 0x70(%rsp), %rcx
je 0x2cf7d
movq 0x68(%rsp), %rax
movq %rcx, 0x58(%rsp)
movl (%rax,%rcx,4), %edx
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsi), %rcx
movq 0x28(%rsi), %rax
cmpq %rax, %rcx
je 0x2c9e1
cmpb $0x1, 0x440(%r15)
jne 0x2c911
testb $0x1, 0x28(%rsp)
jne 0x2c911
subq %rcx, %rax
movl $0x0, 0x28(%rsp)
movl $0x0, 0x50(%rsp)
cmpq $0x5, %rax
jb 0x2c911
movb $0x1, %al
movl %eax, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x7139e(%rip), %rsi     # 0x9dca4
callq 0x64d0
movb $0x1, %al
movl %eax, 0x50(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x2cfc9
movq %rbx, 0x30(%rsp)
leaq 0xf(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %r15, 0x48(%rsp)
movq %r15, %rdi
movl 0x54(%rsp), %esi
callq 0xa9e4
movq %rax, %r14
testq %rax, %rax
je 0x2c991
cmpq $0x0, 0x58(%rsp)
jne 0x2c991
cmpb $0x0, 0x62d(%r15)
je 0x2c991
movq %r15, %rdi
movq %r14, %rsi
callq 0x10c60
testb %al, %al
je 0x2c991
movq 0x18(%rsp), %rax
movl 0x8(%rax), %esi
movq %r15, %rdi
pushq $0x2
popq %rdx
callq 0x103d2
testb %al, %al
je 0x2ccb5
movb 0x440(%r15), %al
andb 0x50(%rsp), %al
cmpb $0x1, %al
jne 0x2ca7f
movq 0x18(%rsp), %rax
movl 0x9c(%rax), %esi
movq %r15, %rdi
callq 0x90a4
movq %rax, %r14
cmpb $0x1, 0xf(%rsp)
jne 0x2cb3e
movl 0x10(%rsp), %esi
movq %rbp, %rdi
callq 0x1c182
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64f0
jmp 0x2cb58
cmpl $0xc, 0xc(%rsi)
jne 0x2ca8e
cmpb $0x0, 0xf(%rsp)
jne 0x2ca03
movq %r15, %rdi
movl %edx, %esi
callq 0x17bce
movl 0x10(%rax), %edx
movl %edx, 0x10(%rsp)
movl %edx, %eax
movq 0x18(%rsp), %rsi
movq 0x70(%rsi), %rcx
subq 0x68(%rsi), %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
jbe 0x2cfe8
movq %r15, %rdi
movq %r13, %rcx
callq 0x10cdc
testb %al, %al
je 0x2cc78
testb $0x1, 0x17(%rsp)
je 0x2cd83
movq %rbx, %rdi
leaq 0x68de2(%rip), %rsi     # 0x95829
callq 0x64d0
movq 0x18(%rsp), %rax
movl 0x98(%rsp), %edx
movl 0x64(%rax), %ecx
movq (%r15), %rax
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64f0
jmp 0x2cdf4
leaq 0x30(%rsp), %rdi
callq 0x3559a
jmp 0x2ced1
cmpl $0x2, 0x18(%rsi)
jb 0x2cbfe
testb $0x1, 0x2c(%rsp)
je 0x2cb03
leaq 0xb8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x63c0
movq 0x18(%rsp), %rcx
movq (%r15), %rax
movzbl 0x24(%rsp), %r8d
andl $0x1, %r8d
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x118(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6320
movq %r14, %rdi
callq 0x6548
movq %r12, %rdi
callq 0x6548
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x24(%rsp)
movq %rbx, %rdi
leaq 0x71197(%rip), %rsi     # 0x9dca4
callq 0x64d0
cmpb $0x1, 0xf(%rsp)
jne 0x2cd2c
movl 0x10(%rsp), %esi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x1c182
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f0
jmp 0x2cd4b
movl 0x10(%rsp), %edx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x2beca
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64f0
movq %rbp, %rdi
callq 0x6548
movq 0x28(%r14), %r12
subq 0x20(%r14), %r12
shrq $0x2, %r12
decl %r12d
cmpl $-0x1, %r12d
je 0x2cbbd
movq %rbx, %rdi
leaq 0x679a5(%rip), %rsi     # 0x94524
callq 0x64d0
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r12d, %ecx
callq 0x35634
movq %rbp, %rdi
movq %r13, %rdx
callq 0x2aa76
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64f0
movq %rbp, %rdi
callq 0x6548
movq %r13, %rdi
callq 0x6548
jmp 0x2cb6c
movq 0x20(%r14), %rax
cmpq 0x28(%r14), %rax
je 0x2cbe2
movq %rbx, %rdi
leaq 0x7105c(%rip), %rsi     # 0x9dc2d
callq 0x64d0
testb $0x1, 0x28(%rsp)
je 0x2cbea
jmp 0x2ced1
movl $0x0, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x6beda(%rip), %rsi     # 0x98ace
callq 0x64d0
jmp 0x2ced1
cmpl $0x2, 0x14(%rsi)
jb 0x2cd19
movb 0xf(%rsp), %al
cmpb $0x1, %al
jne 0x2cc1b
testb $0x1, 0x24(%rsp)
je 0x2ceff
movq 0x20(%r15), %rcx
movq %rdx, %rsi
shlq $0x4, %rsi
cmpl $0x3, 0x8(%rcx,%rsi)
jne 0x2cc38
testb $0x1, 0x24(%rsp)
je 0x2cf24
testb %al, %al
je 0x2ce49
leaq 0x30(%rsp), %r14
movq %r14, %rdi
leaq 0x71055(%rip), %rsi     # 0x9dca4
leaq 0x10(%rsp), %rdx
leaq 0x6be73(%rip), %rcx     # 0x98ace
callq 0x44a4d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f0
movq %r14, %rdi
callq 0x6548
jmp 0x2cf54
movl 0x10(%rsp), %edx
movq %r15, %rdi
movl %r14d, %esi
callq 0x11f7e
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x63c0
cmpq $0x0, 0x38(%rsp)
je 0x2cdb3
movq %rbx, %rdi
leaq 0x30(%rsp), %r12
movq %r12, %rsi
callq 0x6170
jmp 0x2cdf4
movq 0x38(%r15), %rax
movq 0x60(%rsp), %rcx
cmpl $0x2, 0xa0(%rax,%rcx)
jae 0x2cd0a
movl 0x10(%r14), %eax
cmpl $0x3, %eax
je 0x2ce8b
cmpl $0x1, %eax
jne 0x2cd0a
movl 0x10(%rsp), %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2b9f0
movq %rbp, %rdi
leaq 0x6781f(%rip), %rsi     # 0x94512
movq %r13, %rdx
leaq 0x6781c(%rip), %rcx     # 0x94519
movq %rbx, %r8
callq 0x44945
jmp 0x2ceb6
leaq 0x30(%rsp), %rdi
callq 0x3559a
jmp 0x2ced1
cmpb $0x0, 0x62f(%r15)
jne 0x2cef2
jmp 0x2d036
movl 0x10(%rsp), %edx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b9f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f0
movq %r14, %rdi
callq 0x6548
movq %rbx, %rdi
leaq 0x6bd71(%rip), %rsi     # 0x98ace
callq 0x64d0
movq 0x18(%rsp), %rax
movl 0x9c(%rax), %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x90a4
movq %rax, 0x18(%rsp)
jmp 0x2cef2
movl 0x98(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x64(%rax), %ecx
movq (%r15), %rax
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6320
jmp 0x2cdf4
movq %r15, %rdi
movl 0x54(%rsp), %esi
callq 0x1067e
movl 0x10(%rsp), %r8d
movq (%r15), %r9
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
callq *0x120(%r9)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64f0
movq %rbp, %rdi
callq 0x6548
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x6548
movl 0x10(%rsp), %edx
movq %r15, %rdi
movq 0x18(%rsp), %r12
movq %r12, %rsi
callq 0x3573a
movl %eax, 0x24(%rsp)
movl 0x10(%rsp), %edx
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x110(%rax)
movl %eax, 0x2c(%rsp)
movl 0x10(%rsp), %eax
movq 0x68(%r12), %rcx
movl (%rcx,%rax,4), %esi
movq %r15, %rdi
callq 0x90a4
movq %rax, 0x18(%rsp)
jmp 0x2cef2
movq %rbx, %rdi
leaq 0x70e51(%rip), %rsi     # 0x9dca4
callq 0x64d0
movl 0x10(%rsp), %edx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b9f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f0
movq %r14, %rdi
callq 0x6548
leaq 0x6bc48(%rip), %rax     # 0x98ace
jmp 0x2cf17
movl 0x10(%rsp), %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2b9f0
movq %rbp, %rdi
leaq 0x67678(%rip), %rsi     # 0x9451c
movq %r13, %rdx
leaq 0x6766b(%rip), %rcx     # 0x94519
movq %rbx, %r8
callq 0x449c1
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6320
movq %rbp, %rdi
callq 0x6548
movq %r13, %rdi
callq 0x6548
movq 0x18(%rsp), %rax
movl 0x9c(%rax), %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x90a4
movq %rax, 0x18(%rsp)
movb $0x1, 0x17(%rsp)
movq 0x58(%rsp), %rcx
incq %rcx
jmp 0x2c89a
movq %rbx, %rdi
leaq 0x68920(%rip), %rsi     # 0x95829
callq 0x64d0
movl 0x10(%rsp), %esi
callq 0x2ab62
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64d0
jmp 0x2cf54
movq %r15, %rdi
movl %edx, %esi
callq 0x17bce
movq %rax, %r14
movq %rbx, %rdi
leaq 0x688ee(%rip), %rsi     # 0x95829
callq 0x64d0
movl 0x10(%r14), %esi
callq 0x2ab62
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64d0
movq 0x18(%rsp), %rax
movl 0x9c(%rax), %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x90a4
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
jmp 0x2cef2
testb $0x1, 0x28(%rsp)
jne 0x2d081
movq 0x118(%rsp), %rcx
testq %rcx, %rcx
movq 0x120(%rsp), %rax
je 0x2cfa6
movl 0x2c(%rsp), %edx
andb $0x1, %dl
movb %dl, (%rcx)
testq %rax, %rax
je 0x2cfb4
movl 0x24(%rsp), %ecx
andb $0x1, %cl
movb %cl, (%rax)
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x62cf7(%rip), %rdi     # 0x8fcc7
leaq 0x64d51(%rip), %rsi     # 0x91d28
leaq 0x674ba(%rip), %rcx     # 0x94498
movl $0x14a6, %edx           # imm = 0x14A6
callq 0x61c0
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %r15
leaq 0x6752e(%rip), %rsi     # 0x94528
leaq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xb9d9e(%rip), %rsi     # 0xe6dc0
movq 0xbafb7(%rip), %rdx     # 0xe7fe0
movq %r15, %rdi
callq 0x6490
jmp 0x2d0ca
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %r15
leaq 0x674ff(%rip), %rsi     # 0x94547
leaq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xb9d50(%rip), %rsi     # 0xe6dc0
movq 0xbaf69(%rip), %rdx     # 0xe7fe0
movq %r15, %rdi
callq 0x6490
jmp 0x2d0ca
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %r15
leaq 0x674d5(%rip), %rsi     # 0x94568
leaq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xb9d05(%rip), %rsi     # 0xe6dc0
movq 0xbaf1e(%rip), %rdx     # 0xe7fe0
movq %r15, %rdi
callq 0x6490
jmp 0x2d17f
jmp 0x2d17a
jmp 0x2d17f
jmp 0x2d17a
jmp 0x2d133
jmp 0x2d133
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d13d
jmp 0x2d151
jmp 0x2d17a
jmp 0x2d13d
jmp 0x2d151
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d17a
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x6548
jmp 0x2d136
jmp 0x2d17a
jmp 0x2d133
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d133
jmp 0x2d17a
jmp 0x2d133
jmp 0x2d17a
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
jmp 0x2d199
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d133
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x2d199
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x2d154
jmp 0x2d19e
movq %rax, %r14
movq %r15, %rdi
callq 0x6200
jmp 0x2d19e
jmp 0x2d162
jmp 0x2d17a
movq %rax, %r14
leaq 0x78(%rsp), %rdi
jmp 0x2d199
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d17a
jmp 0x2d17a
movq %rax, %r14
jmp 0x2d19e
movq %rax, %r14
jmp 0x2d191
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x6548
leaq 0x98(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0