// File: /workspace/github_cpp_makefile_star2_O3/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 0x14ac0
cmpl $0xc, 0xc(%rax)
jne 0x426c7
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 0x41edd
movb (%rdx), %bpl
jmp 0x41edf
xorl %ebp, %ebp
testq %rcx, %rcx
je 0x41eea
movl (%rcx), %eax
movl %eax, 0xc(%rsp)
movq %r14, 0x80(%rsp)
testl %ebx, %ebx
je 0x424a4
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 0x41f5e
movq %r14, %rdi
movl %ebx, %esi
movl $0x6, %edx
callq 0x14e6e
movl %eax, %ebx
testl %eax, %eax
je 0x42527
movq %r14, %rdi
movl %r12d, %esi
callq 0x54236
testq %rax, %rax
je 0x42006
imull 0x10(%rax), %ebx
addl %ebx, 0x54(%rsp)
jmp 0x42368
cmpl $0xc, 0xc(%r13)
jne 0x420c6
movq %r14, %rdi
movl %r12d, %esi
callq 0x1c036
movl 0x10(%rax), %r14d
movq 0x70(%r13), %rax
subq 0x68(%r13), %rax
sarq $0x2, %rax
cmpq %r14, %rax
jbe 0x425f7
movq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x15402
movl %eax, %ebp
movq 0x68(%r13), %rax
movl (%rax,%r14,4), %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0xa3ea
movq %rax, %r12
addl %ebp, 0x54(%rsp)
cmpl $0x2, 0x18(%rax)
jb 0x4214e
movq 0x58(%rsp), %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x155e0
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %r13, %rdx
movl %r14d, %ecx
callq 0x1af9a
movb 0x10(%rsp), %bpl
shrb $0x4, %bpl
leaq 0x18(%rsp), %rdi
callq 0xd570
jmp 0x42150
movl %ebx, %eax
xorl %edx, %edx
divl 0xd0(%rsp)
testl %edx, %edx
jne 0x4258f
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x34600
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 0x4205b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x774dd(%rip), %rsi     # 0xb9544
callq 0x64e0
movl $0x1, %eax
cmpl $0xa, %ebx
jb 0x422ff
movl $0x4, %eax
movl %ebx, %ecx
cmpl $0x63, %ecx
jbe 0x422f8
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x422fd
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x422ff
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 0x42081
addl $-0x3, %eax
jmp 0x422ff
cmpl $0x2, 0x18(%r13)
jb 0x42106
movq %r14, %rdi
movl %r12d, %esi
callq 0x54236
testq %rax, %rax
je 0x4215a
movq %r14, %rdi
movl %r12d, %esi
callq 0x1c036
movl 0xc(%rsp), %ecx
testb $0x1, %bpl
je 0x420f9
movl 0x10(%r13), %ecx
shrl $0x3, %ecx
imull 0x10(%rax), %ecx
addl %ecx, 0x54(%rsp)
jmp 0x4240d
cmpl $0x2, 0x14(%r13)
jb 0x4265f
movq %r14, %rdi
movl %r12d, %esi
callq 0x54236
testq %rax, %rax
je 0x42229
movq %r14, %rdi
movl %r12d, %esi
callq 0x1c036
movl 0xc(%rsp), %ecx
testb $0x1, %bpl
jne 0x42141
movl 0x10(%r13), %ecx
shrl $0x3, %ecx
imull 0x10(%rax), %ecx
addl %ecx, 0x54(%rsp)
jmp 0x4248e
xorl %ebp, %ebp
movq 0x58(%rsp), %r14
jmp 0x4237c
movl 0xc(%rsp), %eax
testb $0x1, %bpl
je 0x4216b
movl 0x10(%r13), %eax
shrl $0x3, %eax
xorl %edx, %edx
divl 0xd0(%rsp)
testl %edx, %edx
jne 0x4274b
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x34600
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 0x421be
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x7737a(%rip), %rsi     # 0xb9544
callq 0x64e0
movl $0x1, %eax
cmpl $0xa, %ebx
jb 0x423a4
movl $0x4, %eax
movl %ebx, %ecx
cmpl $0x63, %ecx
jbe 0x42395
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x423a2
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x423a4
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 0x421e4
addl $-0x3, %eax
jmp 0x423a4
movl 0xc(%rsp), %eax
testb $0x1, %bpl
jne 0x4223a
movl 0x10(%r13), %eax
shrl $0x3, %eax
xorl %edx, %edx
divl 0xd0(%rsp)
testl %edx, %edx
jne 0x426e6
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x34600
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 0x4228d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x772ab(%rip), %rsi     # 0xb9544
callq 0x64e0
movl $0x1, %eax
cmpl $0xa, %ebx
jb 0x42425
movl $0x4, %eax
movl %ebx, %ecx
cmpl $0x63, %ecx
jbe 0x4239a
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x42423
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x42425
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 0x422b3
addl $-0x3, %eax
jmp 0x42425
addl $-0x2, %eax
jmp 0x422ff
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 0x20b57
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 0x42357
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x80912(%rip), %rsi     # 0xc2c75
callq 0x64e0
movl 0x9c(%r13), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xa3ea
movq %rax, %r12
incq %r15
movq %r12, %r13
cmpq 0x88(%rsp), %r15
jne 0x41f0e
jmp 0x424a4
addl $-0x2, %eax
jmp 0x423a4
addl $-0x2, %eax
jmp 0x42425
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 0x20b57
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 0x423fc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x8086d(%rip), %rsi     # 0xc2c75
callq 0x64e0
movl 0x9c(%r13), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xa3ea
jmp 0x42379
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 0x20b57
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 0x4247d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x60(%rsp), %rdi
leaq 0x807ec(%rip), %rsi     # 0xc2c75
callq 0x64e0
movl 0x9c(%r13), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xa3ea
jmp 0x42379
movq 0xd8(%rsp), %rax
testq %rax, %rax
je 0x424b8
andb $0x1, %bpl
movb %bpl, (%rax)
movq 0xe0(%rsp), %rax
testq %rax, %rax
movq 0x80(%rsp), %rbx
je 0x424d3
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 0xe456
movl 0x54(%rsp), %eax
movl %eax, 0x20(%rbx)
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x42512
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 0x77381(%rip), %rsi     # 0xb98c9
leaq 0x773ae(%rip), %rdx     # 0xb98fd
callq 0x7be0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb985d(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9835(%rip), %rsi     # 0xfbdb0
movq 0xbaa56(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x427ae
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x7734e(%rip), %rsi     # 0xb98fe
leaq 0x77435(%rip), %rdx     # 0xb99ec
callq 0x7be0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb97f5(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb97cd(%rip), %rsi     # 0xfbdb0
movq 0xba9ee(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x427ae
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x76f30(%rip), %rsi     # 0xb9548
leaq 0x76f47(%rip), %rdx     # 0xb9566
callq 0x7be0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb978d(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9765(%rip), %rsi     # 0xfbdb0
movq 0xba986(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x427ae
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x76ee7(%rip), %rsi     # 0xb9567
leaq 0x76f00(%rip), %rdx     # 0xb9587
callq 0x7be0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb9725(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb96fd(%rip), %rsi     # 0xfbdb0
movq 0xba91e(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x427ae
leaq 0x77128(%rip), %rdi     # 0xb97f6
leaq 0x74673(%rip), %rsi     # 0xb6d48
leaq 0x7713d(%rip), %rcx     # 0xb9819
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 0x773c1(%rip), %rsi     # 0xb9ac8
leaq 0x7743f(%rip), %rdx     # 0xb9b4d
callq 0x7be0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb969e(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9676(%rip), %rsi     # 0xfbdb0
movq 0xba897(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x427ae
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
movq %rax, (%rdi)
leaq 0x77281(%rip), %rsi     # 0xb99ed
leaq 0x77354(%rip), %rdx     # 0xb9ac7
callq 0x7be0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0xb9639(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb9611(%rip), %rsi     # 0xfbdb0
movq 0xba832(%rip), %rdx     # 0xfcfd8
movq %r14, %rdi
callq 0x6470
jmp 0x4281a
jmp 0x42840
jmp 0x4281a
jmp 0x42840
jmp 0x427f5
jmp 0x42853
jmp 0x427f5
jmp 0x42853
jmp 0x427f5
jmp 0x42853
jmp 0x427f5
jmp 0x42853
jmp 0x4281a
jmp 0x42840
jmp 0x42853
jmp 0x42853
jmp 0x42853
jmp 0x42853
jmp 0x4281a
jmp 0x42840
jmp 0x42853
jmp 0x42853
jmp 0x4281a
jmp 0x42840
jmp 0x42853
jmp 0x42853
jmp 0x427f5
jmp 0x42853
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42856
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x42856
jmp 0x42853
jmp 0x42853
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42839
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
jne 0x42843
jmp 0x42856
movq %rax, %rbx
movq %r14, %rdi
callq 0x6200
jmp 0x42856
jmp 0x42853
jmp 0x42853
jmp 0x42853
movq %rax, %rbx
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x42872
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0