// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::constant_op_expression[abi:cxx11](spirv_cross::SPIRConstantOp const&)
string CompilerGLSL::constant_op_expression(const SPIRConstantOp &cop)
{
	auto &type = get<SPIRType>(cop.basetype);
	bool binary = false;
	bool unary = false;
	string op;

	if (is_legacy() && is_unsigned_opcode(cop.opcode))
		SPIRV_CROSS_THROW("Unsigned integers are not supported on legacy targets.");

	// TODO: Find a clean way to reuse emit_instruction.
	switch (cop.opcode)
	{
	case OpSConvert:
	case OpUConvert:
	case OpFConvert:
		op = type_to_glsl_constructor(type);
		break;

#define GLSL_BOP(opname, x) \
	case Op##opname:        \
		binary = true;      \
		op = x;             \
		break

#define GLSL_UOP(opname, x) \
	case Op##opname:        \
		unary = true;       \
		op = x;             \
		break

		GLSL_UOP(SNegate, "-");
		GLSL_UOP(Not, "~");
		GLSL_BOP(IAdd, "+");
		GLSL_BOP(ISub, "-");
		GLSL_BOP(IMul, "*");
		GLSL_BOP(SDiv, "/");
		GLSL_BOP(UDiv, "/");
		GLSL_BOP(UMod, "%");
		GLSL_BOP(SMod, "%");
		GLSL_BOP(ShiftRightLogical, ">>");
		GLSL_BOP(ShiftRightArithmetic, ">>");
		GLSL_BOP(ShiftLeftLogical, "<<");
		GLSL_BOP(BitwiseOr, "|");
		GLSL_BOP(BitwiseXor, "^");
		GLSL_BOP(BitwiseAnd, "&");
		GLSL_BOP(LogicalOr, "||");
		GLSL_BOP(LogicalAnd, "&&");
		GLSL_UOP(LogicalNot, "!");
		GLSL_BOP(LogicalEqual, "==");
		GLSL_BOP(LogicalNotEqual, "!=");
		GLSL_BOP(IEqual, "==");
		GLSL_BOP(INotEqual, "!=");
		GLSL_BOP(ULessThan, "<");
		GLSL_BOP(SLessThan, "<");
		GLSL_BOP(ULessThanEqual, "<=");
		GLSL_BOP(SLessThanEqual, "<=");
		GLSL_BOP(UGreaterThan, ">");
		GLSL_BOP(SGreaterThan, ">");
		GLSL_BOP(UGreaterThanEqual, ">=");
		GLSL_BOP(SGreaterThanEqual, ">=");

	case OpSelect:
	{
		if (cop.arguments.size() < 3)
			SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");

		// This one is pretty annoying. It's triggered from
		// uint(bool), int(bool) from spec constants.
		// In order to preserve its compile-time constness in Vulkan GLSL,
		// we need to reduce the OpSelect expression back to this simplified model.
		// If we cannot, fail.
		if (to_trivial_mix_op(type, op, cop.arguments[2], cop.arguments[1], cop.arguments[0]))
		{
			// Implement as a simple cast down below.
		}
		else
		{
			// Implement a ternary and pray the compiler understands it :)
			return to_ternary_expression(type, cop.arguments[0], cop.arguments[1], cop.arguments[2]);
		}
		break;
	}

	case OpVectorShuffle:
	{
		string expr = type_to_glsl_constructor(type);
		expr += "(";

		uint32_t left_components = expression_type(cop.arguments[0]).vecsize;
		string left_arg = to_enclosed_expression(cop.arguments[0]);
		string right_arg = to_enclosed_expression(cop.arguments[1]);

		for (uint32_t i = 2; i < uint32_t(cop.arguments.size()); i++)
		{
			uint32_t index = cop.arguments[i];
			if (index >= left_components)
				expr += right_arg + "." + "xyzw"[index - left_components];
			else
				expr += left_arg + "." + "xyzw"[index];

			if (i + 1 < uint32_t(cop.arguments.size()))
				expr += ", ";
		}

		expr += ")";
		return expr;
	}

	case OpCompositeExtract:
	{
		auto expr =
		    access_chain_internal(cop.arguments[0], &cop.arguments[1], uint32_t(cop.arguments.size() - 1), true, false);
		return expr;
	}

	case OpCompositeInsert:
		SPIRV_CROSS_THROW("OpCompositeInsert spec constant op is not supported.");

	default:
		// Some opcodes are unimplemented here, these are currently not possible to test from glslang.
		SPIRV_CROSS_THROW("Unimplemented spec constant op.");
	}

	SPIRType::BaseType input_type;
	bool skip_cast_if_equal_type = glsl_opcode_is_sign_invariant(cop.opcode);

	switch (cop.opcode)
	{
	case OpIEqual:
	case OpINotEqual:
		input_type = SPIRType::Int;
		break;

	default:
		input_type = type.basetype;
		break;
	}

#undef GLSL_BOP
#undef GLSL_UOP
	if (binary)
	{
		if (cop.arguments.size() < 2)
			SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");

		string cast_op0;
		string cast_op1;
		auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, input_type, cop.arguments[0],
		                                              cop.arguments[1], skip_cast_if_equal_type);

		if (type.basetype != input_type && type.basetype != SPIRType::Boolean)
		{
			expected_type.basetype = input_type;
			auto expr = bitcast_glsl_op(type, expected_type);
			expr += '(';
			expr += join(cast_op0, " ", op, " ", cast_op1);
			expr += ')';
			return expr;
		}
		else
			return join("(", cast_op0, " ", op, " ", cast_op1, ")");
	}
	else if (unary)
	{
		if (cop.arguments.size() < 1)
			SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");

		// Auto-bitcast to result type as needed.
		// Works around various casting scenarios in glslang as there is no OpBitcast for specialization constants.
		return join("(", op, bitcast_glsl(type, cop.arguments[0]), ")");
	}
	else
	{
		if (cop.arguments.size() < 1)
			SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");
		return join(op, "(", to_expression(cop.arguments[0]), ")");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
movl 0x28(%rdx), %esi
movq %r15, %rdi
callq 0xa3ea
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
cmpb $0x0, 0x43c(%r15)
movl $0x12b, %ecx            # imm = 0x12B
movl $0x81, %edx
cmovnel %ecx, %edx
movq %rax, %r12
movl 0xc(%r14), %eax
cmpl %edx, 0x438(%r15)
ja 0x2ce1c
leal -0x6d(%rax), %ecx
cmpl $0x3f, %ecx
ja 0x2ce03
movabsq $-0x7ffffbffedffffe7, %rdx # imm = 0x8000040012000019
btq %rcx, %rdx
jb 0x2d665
leal -0xae(%rax), %ecx
cmpl $0x14, %ecx
ja 0x2ce1c
movl $0x100015, %edx         # imm = 0x100015
btl %ecx, %edx
jb 0x2d665
cmpl $0x7d, %eax
jle 0x2ce4f
addl $-0x7e, %eax
cmpl $0x4a, %eax
ja 0x2d917
movl $0x1, %r8d
leaq 0x887fa(%rip), %rcx     # 0xb5634
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8b29b(%rip), %rcx     # 0xb80e5
jmp 0x2d2cd
cmpl $0x70, %eax
jle 0x2ceb2
addl $-0x71, %eax
cmpl $0x3, %eax
jae 0x2d917
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x34a5c
leaq 0x50(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
callq 0x6310
movq (%r13), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x2d639
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2d639
cmpl $0x4f, %eax
je 0x2d01a
cmpl $0x51, %eax
jne 0x2d82d
movq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
movl (%rcx), %edx
subq %rcx, %r8
addq $0x4, %rcx
shrq $0x2, %r8
decl %r8d
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movl $0x0, (%rsp)
movq 0x20(%rsp), %rdi
movq %r15, %rsi
movl $0x1, %r9d
callq 0x35194
addq $0x20, %rsp
jmp 0x2d5d9
movl $0x2, %r8d
leaq 0x8b1d1(%rip), %rcx     # 0xb80e9
jmp 0x2d2cd
leaq 0x872d8(%rip), %rcx     # 0xb41fc
jmp 0x2d2cd
movl $0x2, %r8d
leaq 0x8b1c8(%rip), %rcx     # 0xb80fe
jmp 0x2d2cd
movl $0x2, %r8d
leaq 0x8b1ad(%rip), %rcx     # 0xb80f5
jmp 0x2d2cd
leaq 0x8b193(%rip), %rcx     # 0xb80e7
jmp 0x2d2cd
movl $0x2, %r8d
leaq 0x8b195(%rip), %rcx     # 0xb80fb
jmp 0x2d2cd
movl $0x2, %r8d
leaq 0x8b180(%rip), %rcx     # 0xb80f8
jmp 0x2d2cd
leaq 0x8b169(%rip), %rcx     # 0xb80ed
jmp 0x2d2cd
leaq 0x8b151(%rip), %rcx     # 0xb80e1
jmp 0x2d002
leaq 0x8ccc5(%rip), %rcx     # 0xb9c5e
jmp 0x2d2cd
leaq 0x95768(%rip), %rcx     # 0xc270d
jmp 0x2d2cd
leaq 0x95765(%rip), %rcx     # 0xc2716
jmp 0x2d002
movl $0x2, %r8d
leaq 0x8b12c(%rip), %rcx     # 0xb80ec
jmp 0x2d2cd
leaq 0x8b117(%rip), %rcx     # 0xb80e3
jmp 0x2d2cd
movl $0x2, %r8d
leaq 0x8b114(%rip), %rcx     # 0xb80f2
jmp 0x2d2cd
leaq 0x875a1(%rip), %rcx     # 0xb458b
jmp 0x2d2cd
leaq 0x8b0fa(%rip), %rcx     # 0xb80f0
jmp 0x2d2cd
leaq 0x8ce76(%rip), %rcx     # 0xb9e78
xorl %ebx, %ebx
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x63f0
movb $0x1, %r13b
jmp 0x2d2e0
movq (%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x34a5c
leaq 0x95c41(%rip), %rsi     # 0xc2c71
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x64e0
movq 0x10(%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x12a72
movl 0x14(%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x10(%r14), %rax
movl (%rax), %edx
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x34600
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x70(%rsp), %rdi
movq %r15, %rsi
callq 0x34600
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl $0x3, %ecx
jb 0x2d279
leaq 0x38(%rsp), %r13
movl $0x2, %ebp
leaq 0x8(%rsp), %r15
movl (%rax,%rbp,4), %r12d
cmpl 0x48(%rsp), %r12d
jae 0x2d128
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xe456
movq %r15, %rdi
leaq 0x8d76d(%rip), %rsi     # 0xba849
callq 0x64e0
leaq 0x8b043(%rip), %rax     # 0xb812b
movsbl (%r12,%rax), %r8d
movq 0x10(%rsp), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x64d0
movq %r13, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2d19e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2d1a6
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xe456
movq %r15, %rdi
leaq 0x8d6f8(%rip), %rsi     # 0xba849
callq 0x64e0
subl 0x48(%rsp), %r12d
leaq 0x8afc9(%rip), %rax     # 0xb812b
movsbl (%r12,%rax), %r8d
movq 0x10(%rsp), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x64d0
movq %r13, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2d1d2
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2d1da
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x60b0
jmp 0x2d204
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x60b0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d21b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2d237
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
incq %rbp
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movl %ecx, %ecx
cmpq %rcx, %rbp
jae 0x2d270
movq %rbx, %rdi
leaq 0x8ce51(%rip), %rsi     # 0xba0ab
callq 0x64e0
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movl %ecx, %ecx
cmpq %rcx, %rbp
jb 0x2d0a2
leaq 0x8d795(%rip), %rsi     # 0xbaa15
movq %rbx, %rdi
callq 0x64e0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq 0x60(%rsp), %rbx
je 0x2d45d
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2d45d
leaq 0x8cbba(%rip), %rcx     # 0xb9e78
jmp 0x2d2cd
movl $0x2, %r8d
leaq 0x8ae22(%rip), %rcx     # 0xb80ef
xorl %r13d, %r13d
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x63f0
movb $0x1, %bl
movl 0xc(%r14), %ebp
movl %ebp, %edi
callq 0x35fbb
andl $-0x2, %ebp
movl $0x4, %ecx
cmpl $0xaa, %ebp
je 0x2d300
movl 0xc(%r12), %ecx
movl %ecx, 0x4c(%rsp)
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rdx
testb %bl, %bl
je 0x2d3d0
subq %rcx, %rdx
cmpq $0x4, %rdx
jbe 0x2d6d7
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %edx, %edx
movq %rdx, -0x8(%r13)
movb %dl, (%r13)
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movb %dl, (%rbp)
movl (%rcx), %r9d
movl 0x4(%rcx), %r10d
movzbl %al, %eax
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x28(%rsp), %r14
leaq 0x4c(%rsp), %r8
movq %r15, %rsi
movq %r14, %rcx
pushq %rax
pushq %r10
callq 0x35fe4
addq $0x10, %rsp
movq (%rsp), %rbx
movl 0xc(%r12), %ecx
movl 0x4c(%rsp), %eax
cmpl %eax, %ecx
sete %dl
cmpl $0x2, %ecx
sete %cl
orb %dl, %cl
je 0x2d47f
leaq 0x8d674(%rip), %rax     # 0xbaa15
leaq 0x958c9(%rip), %rsi     # 0xc2c71
leaq 0x874ff(%rip), %rcx     # 0xb48ae
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %r8
movq %rbx, %rdi
movq %rcx, %r9
pushq %rax
pushq %r14
callq 0x53221
addq $0x10, %rsp
jmp 0x2d506
testb %r13b, %r13b
leaq 0x60(%rsp), %rbx
je 0x2d41e
cmpq %rcx, %rdx
je 0x2d749
movl (%rcx), %ecx
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x361ea
leaq 0x95872(%rip), %rsi     # 0xc2c71
leaq 0x8d60f(%rip), %r8      # 0xbaa15
leaq 0x50(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq (%rsp), %rdi
callq 0x532e1
jmp 0x2d45d
cmpq %rcx, %rdx
je 0x2d7bb
movl (%rcx), %edx
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x33f8a
leaq 0x95831(%rip), %rdx     # 0xc2c71
leaq 0x8d5ce(%rip), %r8      # 0xbaa15
leaq 0x50(%rsp), %rsi
leaq 0x90(%rsp), %rcx
movq (%rsp), %rdi
callq 0x5337f
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d5d9
movq 0xa0(%rsp), %rsi
jmp 0x2d5d1
leaq 0x90(%rsp), %rcx
movl %eax, 0xc(%rcx)
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x168(%rax)
movq %rbx, %rdi
movl $0x28, %esi
callq 0x6230
leaq 0x873fe(%rip), %rdx     # 0xb48ae
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rcx
leaq 0x28(%rsp), %r9
movq %rdx, %r8
callq 0x5315e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d4f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
movl $0x29, %esi
callq 0x6230
leaq 0xceed3(%rip), %rax     # 0xfc3e0
addq $0x10, %rax
leaq 0x130(%rsp), %r14
movq %rax, -0xa0(%r14)
movq %r14, %rdi
callq 0xde80
movq -0x38(%r14), %rdi
testq %rdi, %rdi
je 0x2d541
movq 0x108(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d586
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 0x2d5a3
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d5ba
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
leaq 0x60(%rsp), %rbx
je 0x2d5d9
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2d5f0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
movq (%rsp), %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jbe 0x2d8a8
movl 0x8(%rax), %ecx
movl (%rax), %r9d
movl 0x4(%rax), %r8d
leaq 0x50(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x34c8a
testb %al, %al
je 0x2d643
xorl %r13d, %r13d
xorl %ebx, %ebx
jmp 0x2d2e0
movq 0x10(%r14), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
movq (%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x34e2e
jmp 0x2d5d9
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8aa25(%rip), %rsi     # 0xb80aa
leaq 0x8aa54(%rip), %rdx     # 0xb80e0
leaq 0x90(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xce715(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xce6ed(%rip), %rsi     # 0xfbdb0
movq 0xcf90e(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2d984
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8aa0a(%rip), %rsi     # 0xb8101
leaq 0x8aa2c(%rip), %rdx     # 0xb812a
leaq 0x90(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xce6a3(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xce67b(%rip), %rsi     # 0xfbdb0
movq 0xcf89c(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2d984
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8a998(%rip), %rsi     # 0xb8101
leaq 0x8a9ba(%rip), %rdx     # 0xb812a
leaq 0x90(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xce631(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xce609(%rip), %rsi     # 0xfbdb0
movq 0xcf82a(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2d984
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8a926(%rip), %rsi     # 0xb8101
leaq 0x8a948(%rip), %rdx     # 0xb812a
leaq 0x90(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xce5bf(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xce597(%rip), %rsi     # 0xfbdb0
movq 0xcf7b8(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2d984
cmpl $0x52, %eax
jne 0x2d917
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8a8da(%rip), %rsi     # 0xb8130
leaq 0x8a907(%rip), %rdx     # 0xb8164
leaq 0x90(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xce544(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xce51c(%rip), %rsi     # 0xfbdb0
movq 0xcf73d(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2d984
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8a839(%rip), %rsi     # 0xb8101
leaq 0x8a85b(%rip), %rdx     # 0xb812a
leaq 0x90(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xce4d2(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xce4aa(%rip), %rsi     # 0xfbdb0
movq 0xcf6cb(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2d984
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8a82e(%rip), %rsi     # 0xb8165
leaq 0x8a846(%rip), %rdx     # 0xb8184
leaq 0x90(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xce463(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xce43b(%rip), %rsi     # 0xfbdb0
movq 0xcf65c(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9a4
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
je 0x2dc73
jmp 0x2dc6b
jmp 0x2dbcc
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9d7
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
je 0x2dc73
jmp 0x2dc6b
jmp 0x2dbcc
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2da0a
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
je 0x2dc73
jmp 0x2dc6b
jmp 0x2dbcc
jmp 0x2daea
movq %rax, %r14
jmp 0x2db0e
jmp 0x2da2e
jmp 0x2da2e
movq %rax, %r14
jmp 0x2db2f
jmp 0x2dc3c
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2da5b
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
je 0x2dc73
jmp 0x2dc6b
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2da89
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
je 0x2dc73
jmp 0x2dc6b
jmp 0x2dbcc
jmp 0x2dbcc
jmp 0x2dac9
jmp 0x2daa7
jmp 0x2dac9
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2dacc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2dacc
jmp 0x2daea
jmp 0x2dac9
jmp 0x2daea
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2daed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2daed
movq %rax, %r14
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2db0e
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2db2f
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
movq (%rsp), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x2dc73
movq (%rcx), %rsi
jmp 0x2dc32
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dbd7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2dbd7
jmp 0x2dbd4
jmp 0x2db6f
movq %rax, %r14
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dc73
movq 0xa0(%rsp), %rsi
jmp 0x2dc32
jmp 0x2dc3c
jmp 0x2dc3c
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2dbbe
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
je 0x2dc73
jmp 0x2dc6b
movq %rax, %r14
jmp 0x2dc6b
movq %rax, %r14
movq (%rsp), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x2dbf7
movq (%rcx), %rsi
incq %rsi
callq 0x6260
jmp 0x2dbf7
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x1be02
jmp 0x2dc09
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2dc20
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x2dc73
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2dc73
movq %rax, %r14
jmp 0x2dc73
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2dc61
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
jne 0x2dc6b
jmp 0x2dc73
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x2dc8f
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
nop