// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::flattened_access_chain_offset[abi:cxx11](spirv_cross::SPIRType const&, unsigned int const*, unsigned int, unsigned int, unsigned int, bool*, unsigned int*)
std::pair<std::string, uint32_t> CompilerGLSL::flattened_access_chain_offset(const SPIRType &basetype,
                                                                             const uint32_t *indices, uint32_t count,
                                                                             uint32_t offset, uint32_t word_stride,
                                                                             bool *need_transpose,
                                                                             uint32_t *out_matrix_stride)
{
	// Start traversing type hierarchy at the proper non-pointer types.
	const auto *type = &get_non_pointer_type(basetype);

	// This holds the type of the current pointer which we are traversing through.
	// We always start out from a struct type which is the block.
	// This is primarily used to reflect the array strides and matrix strides later.
	// For the first access chain index, type_id won't be needed, so just keep it as 0, it will be set
	// accordingly as members of structs are accessed.
	assert(type->basetype == SPIRType::Struct);
	uint32_t type_id = 0;

	std::string expr;

	// Inherit matrix information in case we are access chaining a vector which might have come from a row major layout.
	bool row_major_matrix_needs_conversion = need_transpose ? *need_transpose : false;
	uint32_t matrix_stride = out_matrix_stride ? *out_matrix_stride : 0;

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

		// Arrays
		if (!type->array.empty())
		{
			// Here, the type_id will be a type ID for the array type itself.
			uint32_t array_stride = get_decoration(type_id, DecorationArrayStride);
			if (!array_stride)
				SPIRV_CROSS_THROW("SPIR-V does not define ArrayStride for buffer block.");

			auto *constant = maybe_get<SPIRConstant>(index);
			if (constant)
			{
				// Constant array access.
				offset += constant->scalar() * array_stride;
			}
			else
			{
				// Dynamic array access.
				if (array_stride % word_stride)
				{
					SPIRV_CROSS_THROW(
					    "Array stride for dynamic indexing must be divisible by the size of a 4-component vector. "
					    "Likely culprit here is a float or vec2 array inside a push constant block which is std430. "
					    "This cannot be flattened. Try using std140 layout instead.");
				}

				expr += to_enclosed_expression(index);
				expr += " * ";
				expr += convert_to_string(array_stride / word_stride);
				expr += " + ";
			}

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

			// Type ID now refers to the array type with one less dimension.
		}
		// 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)
		{
			index = get<SPIRConstant>(index).scalar();

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

			offset += type_struct_member_offset(*type, index);
			type_id = type->member_types[index];

			auto &struct_type = *type;
			type = &get<SPIRType>(type->member_types[index]);

			if (type->columns > 1)
			{
				matrix_stride = type_struct_member_matrix_stride(struct_type, index);
				row_major_matrix_needs_conversion =
				    combined_decoration_for_member(struct_type, index).get(DecorationRowMajor);
			}
			else
				row_major_matrix_needs_conversion = false;
		}
		// Matrix -> Vector
		else if (type->columns > 1)
		{
			auto *constant = maybe_get<SPIRConstant>(index);
			if (constant)
			{
				index = get<SPIRConstant>(index).scalar();
				offset += index * (row_major_matrix_needs_conversion ? (type->width / 8) : matrix_stride);
			}
			else
			{
				uint32_t indexing_stride = row_major_matrix_needs_conversion ? (type->width / 8) : matrix_stride;
				// Dynamic array access.
				if (indexing_stride % word_stride)
				{
					SPIRV_CROSS_THROW(
					    "Matrix stride for dynamic indexing must be divisible by the size of a 4-component vector. "
					    "Likely culprit here is a row-major matrix being accessed dynamically. "
					    "This cannot be flattened. Try using std140 layout instead.");
				}

				expr += to_enclosed_expression(index);
				expr += " * ";
				expr += convert_to_string(indexing_stride / word_stride);
				expr += " + ";
			}

			uint32_t parent_type = type->parent_type;
			type = &get<SPIRType>(type->parent_type);
			type_id = parent_type;
		}
		// Vector -> Scalar
		else if (type->vecsize > 1)
		{
			auto *constant = maybe_get<SPIRConstant>(index);
			if (constant)
			{
				index = get<SPIRConstant>(index).scalar();
				offset += index * (row_major_matrix_needs_conversion ? matrix_stride : (type->width / 8));
			}
			else
			{
				uint32_t indexing_stride = row_major_matrix_needs_conversion ? matrix_stride : (type->width / 8);

				// Dynamic array access.
				if (indexing_stride % word_stride)
				{
					SPIRV_CROSS_THROW(
					    "Stride for dynamic vector indexing must be divisible by the size of a 4-component vector. "
					    "This cannot be flattened in legacy targets.");
				}

				expr += to_enclosed_expression(index);
				expr += " * ";
				expr += convert_to_string(indexing_stride / word_stride);
				expr += " + ";
			}

			uint32_t parent_type = type->parent_type;
			type = &get<SPIRType>(type->parent_type);
			type_id = parent_type;
		}
		else
			SPIRV_CROSS_THROW("Cannot subdivide a scalar value!");
	}

	if (need_transpose)
		*need_transpose = row_major_matrix_needs_conversion;
	if (out_matrix_stride)
		*out_matrix_stride = matrix_stride;

	return std::make_pair(expr, offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movq %rcx, 0x90(%rsp)
movq %rdi, %r14
movq %rsi, 0x58(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x14c4e
cmpl $0xc, 0xc(%rax)
jne 0x42eed
movq %rax, %r13
movl %ebp, 0x54(%rsp)
movq 0xe0(%rsp), %rcx
movq 0xd8(%rsp), %rdx
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl $0x0, 0xc(%rsp)
testq %rdx, %rdx
je 0x42703
movb (%rdx), %bpl
jmp 0x42705
xorl %ebp, %ebp
testq %rcx, %rcx
je 0x42710
movl (%rcx), %eax
movl %eax, 0xc(%rsp)
movq %r14, 0x80(%rsp)
testl %ebx, %ebx
je 0x42cca
movl %ebx, %eax
movq %rax, 0x88(%rsp)
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x58(%rsp), %r14
movq 0x90(%rsp), %rax
movl (%rax,%r15,4), %r12d
movq 0x20(%r13), %rax
cmpq 0x28(%r13), %rax
je 0x42784
movq %r14, %rdi
movl %ebx, %esi
movl $0x6, %edx
callq 0x14ff6
movl %eax, %ebx
testl %eax, %eax
je 0x42d4d
movq %r14, %rdi
movl %r12d, %esi
callq 0x54a30
testq %rax, %rax
je 0x4282c
imull 0x10(%rax), %ebx
addl %ebx, 0x54(%rsp)
jmp 0x42b8e
cmpl $0xc, 0xc(%r13)
jne 0x428ec
movq %r14, %rdi
movl %r12d, %esi
callq 0x1c66e
movl 0x10(%rax), %r14d
movq 0x70(%r13), %rax
subq 0x68(%r13), %rax
sarq $0x2, %rax
cmpq %r14, %rax
jbe 0x42e1d
movq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x155fe
movl %eax, %ebp
movq 0x68(%r13), %rax
movl (%rax,%r14,4), %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0xa426
movq %rax, %r12
addl %ebp, 0x54(%rsp)
cmpl $0x2, 0x18(%rax)
jb 0x42974
movq 0x58(%rsp), %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x157e2
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %r13, %rdx
movl %r14d, %ecx
callq 0x1b67c
movb 0x10(%rsp), %bpl
shrb $0x4, %bpl
leaq 0x18(%rsp), %rdi
callq 0xd5b0
jmp 0x42976
movl %ebx, %eax
xorl %edx, %edx
divl 0xd0(%rsp)
testl %edx, %edx
jne 0x42db5
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x34d0e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42881
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x77cc7(%rip), %rsi     # 0xba554
callq 0x64e0
movl $0x1, %eax
cmpl $0xa, %ebx
jb 0x42b25
movl $0x4, %eax
movl %ebx, %ecx
cmpl $0x63, %ecx
jbe 0x42b1e
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x42b23
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x42b25
movl %ecx, %edx
movl $0xd1b71759, %esi       # imm = 0xD1B71759
imulq %rsi, %rdx
shrq $0x2d, %rdx
addl $0x4, %eax
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x428a7
addl $-0x3, %eax
jmp 0x42b25
cmpl $0x2, 0x18(%r13)
jb 0x4292c
movq %r14, %rdi
movl %r12d, %esi
callq 0x54a30
testq %rax, %rax
je 0x42980
movq %r14, %rdi
movl %r12d, %esi
callq 0x1c66e
movl 0xc(%rsp), %ecx
testb $0x1, %bpl
je 0x4291f
movl 0x10(%r13), %ecx
shrl $0x3, %ecx
imull 0x10(%rax), %ecx
addl %ecx, 0x54(%rsp)
jmp 0x42c33
cmpl $0x2, 0x14(%r13)
jb 0x42e85
movq %r14, %rdi
movl %r12d, %esi
callq 0x54a30
testq %rax, %rax
je 0x42a4f
movq %r14, %rdi
movl %r12d, %esi
callq 0x1c66e
movl 0xc(%rsp), %ecx
testb $0x1, %bpl
jne 0x42967
movl 0x10(%r13), %ecx
shrl $0x3, %ecx
imull 0x10(%rax), %ecx
addl %ecx, 0x54(%rsp)
jmp 0x42cb4
xorl %ebp, %ebp
movq 0x58(%rsp), %r14
jmp 0x42ba2
movl 0xc(%rsp), %eax
testb $0x1, %bpl
je 0x42991
movl 0x10(%r13), %eax
shrl $0x3, %eax
xorl %edx, %edx
divl 0xd0(%rsp)
testl %edx, %edx
jne 0x42f71
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x34d0e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x429e4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x77b64(%rip), %rsi     # 0xba554
callq 0x64e0
movl $0x1, %eax
cmpl $0xa, %ebx
jb 0x42bca
movl $0x4, %eax
movl %ebx, %ecx
cmpl $0x63, %ecx
jbe 0x42bbb
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x42bc8
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x42bca
movl %ecx, %edx
movl $0xd1b71759, %esi       # imm = 0xD1B71759
imulq %rsi, %rdx
shrq $0x2d, %rdx
addl $0x4, %eax
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x42a0a
addl $-0x3, %eax
jmp 0x42bca
movl 0xc(%rsp), %eax
testb $0x1, %bpl
jne 0x42a60
movl 0x10(%r13), %eax
shrl $0x3, %eax
xorl %edx, %edx
divl 0xd0(%rsp)
testl %edx, %edx
jne 0x42f0c
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x34d0e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42ab3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x77a95(%rip), %rsi     # 0xba554
callq 0x64e0
movl $0x1, %eax
cmpl $0xa, %ebx
jb 0x42c4b
movl $0x4, %eax
movl %ebx, %ecx
cmpl $0x63, %ecx
jbe 0x42bc0
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x42c49
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x42c4b
movl %ecx, %edx
movl $0xd1b71759, %esi       # imm = 0xD1B71759
imulq %rsi, %rdx
shrq $0x2d, %rdx
addl $0x4, %eax
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x42ad9
addl $-0x3, %eax
jmp 0x42c4b
addl $-0x2, %eax
jmp 0x42b25
decl %eax
movl %eax, %esi
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
callq 0x62f0
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
movl %ebx, %edx
callq 0x21251
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42b7d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x8111c(%rip), %rsi     # 0xc3ca5
callq 0x64e0
movl 0x9c(%r13), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xa426
movq %rax, %r12
incq %r15
movq %r12, %r13
cmpq 0x88(%rsp), %r15
jne 0x42734
jmp 0x42cca
addl $-0x2, %eax
jmp 0x42bca
addl $-0x2, %eax
jmp 0x42c4b
decl %eax
movl %eax, %esi
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
callq 0x62f0
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
movl %ebx, %edx
callq 0x21251
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42c22
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x81077(%rip), %rsi     # 0xc3ca5
callq 0x64e0
movl 0x9c(%r13), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xa426
jmp 0x42b9f
decl %eax
movl %eax, %esi
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
callq 0x62f0
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
movl %ebx, %edx
callq 0x21251
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42ca3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x80ff6(%rip), %rsi     # 0xc3ca5
callq 0x64e0
movl 0x9c(%r13), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xa426
jmp 0x42b9f
movq 0xd8(%rsp), %rax
testq %rax, %rax
je 0x42cde
andb $0x1, %bpl
movb %bpl, (%rax)
movq 0xe0(%rsp), %rax
testq %rax, %rax
movq 0x80(%rsp), %rbx
je 0x42cf9
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe480
movl 0x54(%rsp), %eax
movl %eax, 0x20(%rbx)
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x42d38
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x77b6b(%rip), %rsi     # 0xba8d9
leaq 0x77b98(%rip), %rdx     # 0xba90d
callq 0x7c64
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xba007(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9fdf(%rip), %rsi     # 0xfcd80
movq 0xbb230(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x42fd4
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x77b38(%rip), %rsi     # 0xba90e
leaq 0x77c1f(%rip), %rdx     # 0xba9fc
callq 0x7c64
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb9f9f(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9f77(%rip), %rsi     # 0xfcd80
movq 0xbb1c8(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x42fd4
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x7771a(%rip), %rsi     # 0xba558
leaq 0x77731(%rip), %rdx     # 0xba576
callq 0x7c64
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb9f37(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9f0f(%rip), %rsi     # 0xfcd80
movq 0xbb160(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x42fd4
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x776d1(%rip), %rsi     # 0xba577
leaq 0x776ea(%rip), %rdx     # 0xba597
callq 0x7c64
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb9ecf(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9ea7(%rip), %rsi     # 0xfcd80
movq 0xbb0f8(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x42fd4
leaq 0x77912(%rip), %rdi     # 0xba806
leaq 0x74e5d(%rip), %rsi     # 0xb7d58
leaq 0x77927(%rip), %rcx     # 0xba829
movl $0x164d, %edx           # imm = 0x164D
callq 0x61b0
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x77bab(%rip), %rsi     # 0xbaad8
leaq 0x77c29(%rip), %rdx     # 0xbab5d
callq 0x7c64
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb9e48(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9e20(%rip), %rsi     # 0xfcd80
movq 0xbb071(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x42fd4
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x77a6b(%rip), %rsi     # 0xba9fd
leaq 0x77b3e(%rip), %rdx     # 0xbaad7
callq 0x7c64
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb9de3(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9dbb(%rip), %rsi     # 0xfcd80
movq 0xbb00c(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
jmp 0x43043
jmp 0x43064
jmp 0x43043
jmp 0x43064
jmp 0x4301e
jmp 0x4307f
jmp 0x4301e
jmp 0x4307f
jmp 0x4301e
jmp 0x4307f
jmp 0x4301e
jmp 0x4307f
jmp 0x43043
jmp 0x43064
jmp 0x4307f
jmp 0x4307f
jmp 0x4307f
jmp 0x4307f
jmp 0x43043
jmp 0x43064
jmp 0x4307f
jmp 0x4307f
jmp 0x43043
jmp 0x43064
jmp 0x4307f
jmp 0x4307f
jmp 0x4301e
jmp 0x4307f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x43082
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x43082
jmp 0x4307f
jmp 0x4307f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4306a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x4306a
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x43082
movq %r14, %rdi
callq 0x6200
jmp 0x43082
jmp 0x4307f
jmp 0x4307f
jmp 0x4307f
movq %rax, %rbx
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x4309e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0