// File: /workspace/github_cpp_makefile_star2_O1/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 0xa426
movq %rax, %r12
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
cmpb $0x0, 0x43c(%r15)
movl $0x12b, %eax            # imm = 0x12B
movl $0x81, %ecx
cmovnel %eax, %ecx
cmpl %ecx, 0x438(%r15)
ja 0x2d489
movl 0xc(%r14), %eax
leal -0x6d(%rax), %ecx
cmpl $0x3f, %ecx
ja 0x2d471
movabsq $-0x7ffffbffedffffe7, %rdx # imm = 0x8000040012000019
btq %rcx, %rdx
jb 0x2dcd3
addl $0xffffff52, %eax       # imm = 0xFFFFFF52
cmpl $0x14, %eax
ja 0x2d489
movl $0x100015, %ecx         # imm = 0x100015
btl %eax, %ecx
jb 0x2dcd3
movl 0xc(%r14), %eax
cmpl $0x7d, %eax
jle 0x2d4c0
addl $-0x7e, %eax
cmpl $0x4a, %eax
ja 0x2df85
movl $0x1, %r8d
leaq 0x89199(%rip), %rcx     # 0xb6644
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8bc3a(%rip), %rcx     # 0xb90f5
jmp 0x2d93b
cmpl $0x70, %eax
jle 0x2d523
addl $-0x71, %eax
cmpl $0x3, %eax
jae 0x2df85
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x35152
leaq 0x50(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
callq 0x6310
movq (%r13), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x2dca7
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2dca7
cmpl $0x4f, %eax
je 0x2d68b
cmpl $0x51, %eax
jne 0x2de9b
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 0x35880
addq $0x20, %rsp
jmp 0x2dc47
movl $0x2, %r8d
leaq 0x8bb70(%rip), %rcx     # 0xb90f9
jmp 0x2d93b
leaq 0x87c67(%rip), %rcx     # 0xb51fc
jmp 0x2d93b
movl $0x2, %r8d
leaq 0x8bb67(%rip), %rcx     # 0xb910e
jmp 0x2d93b
movl $0x2, %r8d
leaq 0x8bb4c(%rip), %rcx     # 0xb9105
jmp 0x2d93b
leaq 0x8bb32(%rip), %rcx     # 0xb90f7
jmp 0x2d93b
movl $0x2, %r8d
leaq 0x8bb34(%rip), %rcx     # 0xb910b
jmp 0x2d93b
movl $0x2, %r8d
leaq 0x8bb1f(%rip), %rcx     # 0xb9108
jmp 0x2d93b
leaq 0x8bb08(%rip), %rcx     # 0xb90fd
jmp 0x2d93b
leaq 0x8baf0(%rip), %rcx     # 0xb90f1
jmp 0x2d673
leaq 0x8d664(%rip), %rcx     # 0xbac6e
jmp 0x2d93b
leaq 0x96127(%rip), %rcx     # 0xc373d
jmp 0x2d93b
leaq 0x96124(%rip), %rcx     # 0xc3746
jmp 0x2d673
movl $0x2, %r8d
leaq 0x8bacb(%rip), %rcx     # 0xb90fc
jmp 0x2d93b
leaq 0x8bab6(%rip), %rcx     # 0xb90f3
jmp 0x2d93b
movl $0x2, %r8d
leaq 0x8bab3(%rip), %rcx     # 0xb9102
jmp 0x2d93b
leaq 0x87f30(%rip), %rcx     # 0xb558b
jmp 0x2d93b
leaq 0x8ba99(%rip), %rcx     # 0xb9100
jmp 0x2d93b
leaq 0x8d815(%rip), %rcx     # 0xbae88
xorl %ebx, %ebx
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x63f0
movb $0x1, %r13b
jmp 0x2d94e
movq (%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x35152
leaq 0x96600(%rip), %rsi     # 0xc3ca1
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x64e0
movq 0x10(%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x12aba
movl 0x14(%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x10(%r14), %rax
movl (%rax), %edx
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x34d0e
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x70(%rsp), %rdi
movq %r15, %rsi
callq 0x34d0e
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl $0x3, %ecx
jb 0x2d8e7
leaq 0x38(%rsp), %r13
movl $0x2, %ebp
leaq 0x8(%rsp), %r15
movl (%rax,%rbp,4), %r12d
cmpl 0x48(%rsp), %r12d
jae 0x2d799
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xe480
movq %r15, %rdi
leaq 0x8e10c(%rip), %rsi     # 0xbb859
callq 0x64e0
leaq 0x8b9e2(%rip), %rax     # 0xb913b
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 0x2d80f
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2d817
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xe480
movq %r15, %rdi
leaq 0x8e097(%rip), %rsi     # 0xbb859
callq 0x64e0
subl 0x48(%rsp), %r12d
leaq 0x8b968(%rip), %rax     # 0xb913b
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 0x2d843
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2d84b
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 0x2d875
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 0x2d88c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2d8a8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
incq %rbp
shrq $0x2, %rax
movl %eax, %eax
cmpq %rax, %rbp
jae 0x2d8cd
movq %rbx, %rdi
leaq 0x8d7f3(%rip), %rsi     # 0xbb0bb
callq 0x64e0
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movl %ecx, %ecx
cmpq %rcx, %rbp
jb 0x2d713
leaq 0x8e137(%rip), %rsi     # 0xbba25
movq %rbx, %rdi
callq 0x64e0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq 0x60(%rsp), %rbx
je 0x2dacb
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2dacb
leaq 0x8d55c(%rip), %rcx     # 0xbae88
jmp 0x2d93b
movl $0x2, %r8d
leaq 0x8b7c4(%rip), %rcx     # 0xb90ff
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 0x3670f
andl $-0x2, %ebp
movl $0x4, %ecx
cmpl $0xaa, %ebp
je 0x2d96e
movl 0xc(%r12), %ecx
movl %ecx, 0x4c(%rsp)
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rdx
testb %bl, %bl
je 0x2da3e
subq %rcx, %rdx
cmpq $0x4, %rdx
jbe 0x2dd45
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 0x36738
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 0x2daed
leaq 0x8e016(%rip), %rax     # 0xbba25
leaq 0x9628b(%rip), %rsi     # 0xc3ca1
leaq 0x87e91(%rip), %rcx     # 0xb58ae
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %r8
movq %rbx, %rdi
movq %rcx, %r9
pushq %rax
pushq %r14
callq 0x53a1b
addq $0x10, %rsp
jmp 0x2db74
testb %r13b, %r13b
leaq 0x60(%rsp), %rbx
je 0x2da8c
cmpq %rcx, %rdx
je 0x2ddb7
movl (%rcx), %ecx
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3696a
leaq 0x96234(%rip), %rsi     # 0xc3ca1
leaq 0x8dfb1(%rip), %r8      # 0xbba25
leaq 0x50(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq (%rsp), %rdi
callq 0x53adb
jmp 0x2dacb
cmpq %rcx, %rdx
je 0x2de29
movl (%rcx), %edx
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x345e6
leaq 0x961f3(%rip), %rdx     # 0xc3ca1
leaq 0x8df70(%rip), %r8      # 0xbba25
leaq 0x50(%rsp), %rsi
leaq 0x90(%rsp), %rcx
movq (%rsp), %rdi
callq 0x53b79
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dc47
movq 0xa0(%rsp), %rsi
jmp 0x2dc3f
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 0x87d90(%rip), %rdx     # 0xb58ae
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rcx
leaq 0x28(%rsp), %r9
movq %rdx, %r8
callq 0x53958
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 0x2db67
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
movl $0x29, %esi
callq 0x6230
leaq 0xcf835(%rip), %rax     # 0xfd3b0
addq $0x10, %rax
leaq 0x130(%rsp), %r14
movq %rax, -0xa0(%r14)
movq %r14, %rdi
callq 0xdeb6
movq -0x38(%r14), %rdi
testq %rdi, %rdi
je 0x2dbaf
movq 0x108(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x2dbf4
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 0x2dc11
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2dc28
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
leaq 0x60(%rsp), %rbx
je 0x2dc47
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2dc5e
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 0x2df16
movl 0x8(%rax), %ecx
movl (%rax), %r9d
movl 0x4(%rax), %r8d
leaq 0x50(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x35384
testb %al, %al
je 0x2dcb1
xorl %r13d, %r13d
xorl %ebx, %ebx
jmp 0x2d94e
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 0x3551e
jmp 0x2dc47
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8b3c7(%rip), %rsi     # 0xb90ba
leaq 0x8b3f6(%rip), %rdx     # 0xb90f0
leaq 0x90(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xcf077(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcf04f(%rip), %rsi     # 0xfcd80
movq 0xd02a0(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2dff2
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8b3ac(%rip), %rsi     # 0xb9111
leaq 0x8b3ce(%rip), %rdx     # 0xb913a
leaq 0x90(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xcf005(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcefdd(%rip), %rsi     # 0xfcd80
movq 0xd022e(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2dff2
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8b33a(%rip), %rsi     # 0xb9111
leaq 0x8b35c(%rip), %rdx     # 0xb913a
leaq 0x90(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xcef93(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcef6b(%rip), %rsi     # 0xfcd80
movq 0xd01bc(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2dff2
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8b2c8(%rip), %rsi     # 0xb9111
leaq 0x8b2ea(%rip), %rdx     # 0xb913a
leaq 0x90(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xcef21(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xceef9(%rip), %rsi     # 0xfcd80
movq 0xd014a(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2dff2
cmpl $0x52, %eax
jne 0x2df85
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8b27c(%rip), %rsi     # 0xb9140
leaq 0x8b2a9(%rip), %rdx     # 0xb9174
leaq 0x90(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xceea6(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcee7e(%rip), %rsi     # 0xfcd80
movq 0xd00cf(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2dff2
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8b1db(%rip), %rsi     # 0xb9111
leaq 0x8b1fd(%rip), %rdx     # 0xb913a
leaq 0x90(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xcee34(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcee0c(%rip), %rsi     # 0xfcd80
movq 0xd005d(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x2dff2
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8b1d0(%rip), %rsi     # 0xb9175
leaq 0x8b1e8(%rip), %rdx     # 0xb9194
leaq 0x90(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xcedc5(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xced9d(%rip), %rsi     # 0xfcd80
movq 0xcffee(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e01a
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e01a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e2f3
jmp 0x2e2eb
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e050
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e050
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e2f3
jmp 0x2e2eb
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e086
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e086
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e2f3
jmp 0x2e2eb
jmp 0x2e167
movq %rax, %r14
jmp 0x2e18b
jmp 0x2e0a5
jmp 0x2e0a5
movq %rax, %r14
jmp 0x2e1ac
jmp 0x2e2b9
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e0fc
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e0fc
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e110
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e110
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e2f3
jmp 0x2e2eb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e2f3
jmp 0x2e2eb
jmp 0x2e146
jmp 0x2e124
jmp 0x2e146
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e149
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e149
jmp 0x2e167
jmp 0x2e146
jmp 0x2e167
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e16a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e16a
movq %rax, %r14
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e18b
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e1ac
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
movq (%rsp), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x2e2f3
movq (%rcx), %rsi
jmp 0x2e2af
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e254
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e254
jmp 0x2e251
jmp 0x2e1ec
movq %rax, %r14
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e2f3
movq 0xa0(%rsp), %rsi
jmp 0x2e2af
jmp 0x2e2b9
jmp 0x2e2b9
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e243
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e243
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e2f3
jmp 0x2e2eb
movq %rax, %r14
movq (%rsp), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x2e274
movq (%rcx), %rsi
incq %rsi
callq 0x6260
jmp 0x2e274
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x1c438
jmp 0x2e286
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e29d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e2f3
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e2f3
movq %rax, %r14
jmp 0x2e2f3
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e2e6
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x2e2e6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2e2f3
movq %rbx, %rdi
callq 0x6200
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x2e30f
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
nop