// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movl 0x28(%rdx), %esi
movq %r15, %rdi
callq 0x90a4
movq %rax, %rbp
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x41b9c
movl 0xc(%r14), %ecx
testb %al, %al
je 0x26626
leal -0x6d(%rcx), %eax
cmpl $0x3f, %eax
ja 0x2660d
movabsq $-0x7ffffbffedffffe7, %rdx # imm = 0x8000040012000019
btq %rax, %rdx
jb 0x26be0
leal -0xae(%rcx), %eax
cmpl $0x14, %eax
ja 0x26626
movl $0x100015, %edx         # imm = 0x100015
btl %eax, %edx
jb 0x26be0
leal -0x7e(%rcx), %eax
cmpl $0x4a, %eax
movq %r13, (%rsp)
ja 0x26689
leaq 0x69fdb(%rip), %rcx     # 0x90614
movslq (%rcx,%rax,4), %rbx
addq %rcx, %rbx
leaq 0x6ca82(%rip), %rax     # 0x930c9
leaq 0x6ca8d(%rip), %rcx     # 0x930db
leaq 0x6ca78(%rip), %rdx     # 0x930cd
leaq 0x6ca82(%rip), %rdi     # 0x930de
leaq 0x68b71(%rip), %r8      # 0x8f1d4
leaq 0x6ca6e(%rip), %r9      # 0x930d8
leaq 0x6ca64(%rip), %r10     # 0x930d5
leaq 0x6ca4f(%rip), %r11     # 0x930c7
leaq 0x6ca46(%rip), %rsi     # 0x930c5
jmpq *%rbx
movq %r11, %rsi
jmp 0x2681a
leal -0x71(%rcx), %eax
cmpl $0x3, %eax
jae 0x266cf
leaq 0x90(%rsp), %rdi
movq %r15, %r12
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2c226
movq %rbp, %r15
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
callq 0x6320
movq %r13, %rdi
callq 0x6548
xorl %r13d, %r13d
jmp 0x267fd
cmpl $0x4f, %ecx
je 0x26a60
cmpl $0x51, %ecx
jne 0x26d30
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)
andl $0x0, (%rsp)
pushq $0x1
popq %r9
movq %r13, %rdi
movq %r15, %rsi
callq 0x2c79e
addq $0x20, %rsp
jmp 0x26a41
movq %rcx, %rsi
jmp 0x2681a
movq %rdx, %rsi
jmp 0x2681a
movq %r8, %rsi
jmp 0x2681a
movq %r10, %rsi
jmp 0x2681a
movq %r9, %rsi
jmp 0x2681a
movq %rax, %rsi
jmp 0x2681a
movq %rdi, %rsi
jmp 0x2681a
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jbe 0x26dda
movl 0x8(%rax), %ecx
movl (%rax), %r9d
movl 0x4(%rax), %r8d
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2c3dc
testb %al, %al
je 0x26bbf
movq %r15, %r12
movq %rbp, %r15
jmp 0x266c7
leaq 0x76f2c(%rip), %rsi     # 0x9d6ce
jmp 0x267ea
leaq 0x6c927(%rip), %rsi     # 0x930d2
jmp 0x2681a
leaq 0x6c91b(%rip), %rsi     # 0x930cf
jmp 0x2681a
leaq 0x6c906(%rip), %rsi     # 0x930c3
jmp 0x2681a
leaq 0x6e692(%rip), %rsi     # 0x94e58
jmp 0x267ea
leaq 0x6e689(%rip), %rsi     # 0x94e58
jmp 0x2681a
leaq 0x68d8b(%rip), %rsi     # 0x8f563
jmp 0x2681a
leaq 0x6c8eb(%rip), %rsi     # 0x930cc
jmp 0x2681a
leaq 0x6c8d7(%rip), %rsi     # 0x930c1
leaq 0x30(%rsp), %rdi
callq 0x64e0
movq %r15, %r12
movq %rbp, %r15
movb $0x1, %r13b
xorl %ebx, %ebx
jmp 0x2682f
leaq 0x6e436(%rip), %rsi     # 0x94c3e
jmp 0x2681a
leaq 0x76eb4(%rip), %rsi     # 0x9d6c5
jmp 0x2681a
leaq 0x6c8b6(%rip), %rsi     # 0x930d0
leaq 0x30(%rsp), %rdi
callq 0x64e0
movq %r15, %r12
movq %rbp, %r15
movb $0x1, %bl
xorl %r13d, %r13d
movl 0xc(%r14), %ebp
movl %ebp, %edi
callq 0x2d1ae
andl $-0x2, %ebp
cmpl $0xaa, %ebp
je 0x2684b
movl 0xc(%r15), %ecx
jmp 0x2684e
pushq $0x4
popq %rcx
movl %ecx, 0xc(%rsp)
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rdx
testb %bl, %bl
je 0x26917
subq %rcx, %rdx
cmpq $0x4, %rdx
movq (%rsp), %r13
jbe 0x26c34
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
xorl %esi, %esi
leaq 0x60(%rsp), %rdi
movq %rdi, -0x10(%rdi)
andq $0x0, -0x8(%rdi)
movb %sil, (%rdx)
movb %sil, (%rdi)
movl (%rcx), %r9d
movl 0x4(%rcx), %r10d
movzbl %al, %eax
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %r14
leaq 0xc(%rsp), %r8
movq %r12, %rsi
movq %r14, %rcx
pushq %rax
pushq %r10
callq 0x2d1d8
popq %rax
popq %rcx
movl 0xc(%r15), %ecx
movl 0xc(%rsp), %eax
cmpl %eax, %ecx
sete %dl
cmpl $0x2, %ecx
sete %cl
orb %dl, %cl
je 0x269b2
leaq 0x6f10b(%rip), %rax     # 0x959f5
leaq 0x77338(%rip), %rsi     # 0x9dc29
leaq 0x68f8e(%rip), %rcx     # 0x8f886
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %r8
movq %r13, %rdi
movq %rcx, %r9
pushq %rax
pushq %r14
callq 0x42eb5
popq %rax
popq %rcx
jmp 0x26a20
testb %r13b, %r13b
je 0x26963
cmpq %rcx, %rdx
movq (%rsp), %r13
je 0x26c88
movl (%rcx), %ecx
leaq 0x90(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2d344
leaq 0x772e4(%rip), %rsi     # 0x9dc29
leaq 0x6f0a9(%rip), %r8      # 0x959f5
leaq 0x30(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq %r13, %rdi
callq 0x42f4d
jmp 0x269a5
cmpq %rcx, %rdx
movq (%rsp), %r13
je 0x26cdc
movl (%rcx), %edx
leaq 0x90(%rsp), %rdi
movq %r12, %rsi
callq 0x2b9f0
leaq 0x772a0(%rip), %rdx     # 0x9dc29
leaq 0x6f065(%rip), %r8      # 0x959f5
leaq 0x30(%rsp), %rsi
leaq 0x90(%rsp), %rcx
movq %r13, %rdi
callq 0x42fc9
leaq 0x90(%rsp), %rdi
jmp 0x26a3c
leaq 0x90(%rsp), %rcx
movl %eax, 0xc(%rcx)
movq (%r12), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x168(%rax)
pushq $0x28
popq %rsi
movq %r13, %rdi
callq 0x6230
leaq 0x68ea4(%rip), %rdx     # 0x8f886
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rcx
leaq 0x50(%rsp), %r9
movq %rdx, %r8
callq 0x42e29
leaq 0x70(%rsp), %rsi
movq %r13, %rdi
callq 0x64f0
leaq 0x70(%rsp), %rdi
callq 0x6548
pushq $0x29
popq %rsi
movq %r13, %rdi
callq 0x6230
leaq 0x90(%rsp), %rdi
callq 0x17a3e
leaq 0x50(%rsp), %rdi
callq 0x6548
leaq 0x10(%rsp), %rdi
callq 0x6548
leaq 0x30(%rsp), %rdi
callq 0x6548
movq %r13, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2c226
leaq 0x771b4(%rip), %rsi     # 0x9dc29
movq %r13, %rdi
callq 0x64d0
movq 0x10(%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x104b0
movl 0x14(%rax), %r13d
movq 0x10(%r14), %rax
movl (%rax), %edx
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x2beca
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2beca
pushq $0x2
popq %r15
leaq 0x70(%rsp), %r12
leaq 0x50(%rsp), %rbp
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movl %ecx, %ecx
cmpq %rcx, %r15
jae 0x26b9d
movl (%rax,%r15,4), %ebx
cmpl %r13d, %ebx
jae 0x26b25
movq %r12, %rdi
leaq 0x90(%rsp), %rsi
leaq 0x6ed2d(%rip), %rdx     # 0x95829
callq 0x174a5
leaq 0x6c603(%rip), %rax     # 0x9310b
movsbl (%rbx,%rax), %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x42e07
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x64f0
jmp 0x26b5e
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x6ecf5(%rip), %rdx     # 0x95829
callq 0x174a5
subl %r13d, %ebx
leaq 0x6c5c8(%rip), %rax     # 0x9310b
movsbl (%rbx,%rax), %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x42e07
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x64f0
movq %rbp, %rdi
callq 0x6548
movq %r12, %rdi
callq 0x6548
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
incq %r15
shrq $0x2, %rax
movl %eax, %eax
cmpq %rax, %r15
jae 0x26ac7
movq (%rsp), %rdi
leaq 0x6e4f8(%rip), %rsi     # 0x9508b
callq 0x64d0
jmp 0x26ac7
leaq 0x6ee51(%rip), %rsi     # 0x959f5
movq (%rsp), %r13
movq %r13, %rdi
callq 0x64d0
leaq 0x10(%rsp), %rdi
callq 0x6548
jmp 0x269a5
movq 0x10(%r14), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2c550
jmp 0x26a41
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x6c498(%rip), %rsi     # 0x9308a
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xc01a0(%rip), %rsi     # 0xe6dc0
movq 0xc13b9(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x26e29
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x6c49b(%rip), %rsi     # 0x930e1
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xc014c(%rip), %rsi     # 0xe6dc0
movq 0xc1365(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x26e29
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x6c447(%rip), %rsi     # 0x930e1
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xc00f8(%rip), %rsi     # 0xe6dc0
movq 0xc1311(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x26e29
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x6c3f3(%rip), %rsi     # 0x930e1
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xc00a4(%rip), %rsi     # 0xe6dc0
movq 0xc12bd(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x26e29
cmpl $0x52, %ecx
jne 0x26d89
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x6c3c9(%rip), %rsi     # 0x93110
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xc004b(%rip), %rsi     # 0xe6dc0
movq 0xc1264(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x26e29
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x6c3aa(%rip), %rsi     # 0x93145
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xbfff7(%rip), %rsi     # 0xe6dc0
movq 0xc1210(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x26e29
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x6c2f5(%rip), %rsi     # 0x930e1
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xbffa6(%rip), %rsi     # 0xe6dc0
movq 0xc11bf(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
je 0x26ffe
jmp 0x26ff6
jmp 0x26f41
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
je 0x26ffe
jmp 0x26ff6
jmp 0x26f41
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
je 0x26ffe
jmp 0x26ff6
jmp 0x26f41
jmp 0x26f61
movq %rax, %r14
jmp 0x26f8c
jmp 0x26ea3
jmp 0x26ea3
movq %rax, %r14
jmp 0x26f99
jmp 0x26fd7
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
je 0x26ffe
jmp 0x26ff6
jmp 0x26f41
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
je 0x26ffe
jmp 0x26ff6
jmp 0x26f41
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x6548
jmp 0x26fa2
jmp 0x26f9f
jmp 0x26f09
movq %rax, %r14
leaq 0x90(%rsp), %rdi
jmp 0x26fd0
jmp 0x26fd7
jmp 0x26fd7
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
je 0x26ffe
jmp 0x26ff6
movq %rax, %r14
jmp 0x26ff6
jmp 0x26f61
movq %rax, %r14
jmp 0x26f78
jmp 0x26f61
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x6548
jmp 0x26f78
movq %rax, %r14
jmp 0x26f82
movq %rax, %r14
jmp 0x26f78
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x6548
leaq 0x70(%rsp), %rdi
callq 0x6548
leaq 0x10(%rsp), %rdi
callq 0x6548
leaq 0x90(%rsp), %rdi
callq 0x6548
movq (%rsp), %rdi
jmp 0x26fd0
movq %rax, %r14
movq %r13, %rdi
callq 0x6548
jmp 0x26faf
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x17a3e
jmp 0x26fc1
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x6548
leaq 0x10(%rsp), %rdi
callq 0x6548
jmp 0x26ffe
movq %rax, %r14
jmp 0x26ffe
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x26ff6
jmp 0x26ffe
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
leaq 0x30(%rsp), %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0