LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_constant(spirv_cross::SPIRConstant const&)
void CompilerGLSL::emit_constant(const SPIRConstant &constant)
{
	auto &type = get<SPIRType>(constant.constant_type);
	auto name = to_name(constant.self);

	SpecializationConstant wg_x, wg_y, wg_z;
	uint32_t workgroup_size_id = get_work_group_size_specialization_constants(wg_x, wg_y, wg_z);

	if (constant.self == workgroup_size_id || constant.self == wg_x.id || constant.self == wg_y.id ||
	    constant.self == wg_z.id)
	{
		// These specialization constants are implicitly declared by emitting layout() in;
		return;
	}

	// Only scalars have constant IDs.
	if (has_decoration(constant.self, DecorationSpecId))
	{
		statement("layout(constant_id = ", get_decoration(constant.self, DecorationSpecId), ") const ",
		          variable_decl(type, name), " = ", constant_expression(constant), ";");
	}
	else
	{
		statement("const ", variable_decl(type, name), " = ", constant_expression(constant), ";");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rsi), %esi
callq 0x90a4
movq %rax, %r15
movl 0x8(%r14), %edx
movq (%rbx), %rax
leaq 0x60(%rsp), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x12fd6
movl 0x8(%r14), %esi
cmpl %eax, %esi
je 0x27170
cmpl 0x38(%rsp), %esi
je 0x27170
cmpl 0x30(%rsp), %esi
je 0x27170
cmpl 0x28(%rsp), %esi
je 0x27170
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x103d2
testb %al, %al
je 0x27109
movl 0x8(%r14), %esi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x12174
movl %eax, 0x4(%rsp)
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rcx
movq %rbx, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq *0xc8(%rax)
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x271d4
leaq 0x729a6(%rip), %rax     # 0x99a81
leaq 0x6b07d(%rip), %rsi     # 0x9215f
leaq 0x6b08c(%rip), %rcx     # 0x92175
leaq 0x728fa(%rip), %r9      # 0x999ea
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
pushq %rax
pushq %r15
callq 0x424c6
popq %rax
popq %rcx
jmp 0x2715c
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rcx
movq %rbx, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq *0xc8(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x271d4
leaq 0x6b03b(%rip), %rsi     # 0x92177
leaq 0x728a7(%rip), %rcx     # 0x999ea
leaq 0x72937(%rip), %r9      # 0x99a81
leaq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %r8
movq %rbx, %rdi
callq 0x423d0
leaq 0x40(%rsp), %rdi
callq 0x6548
leaq 0x8(%rsp), %rdi
callq 0x6548
leaq 0x60(%rsp), %rdi
callq 0x6548
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6548
jmp 0x271a8
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6548
jmp 0x271ad
movq %rax, %rbx
jmp 0x271ad
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6548
jmp 0x271c2
jmp 0x271bf
jmp 0x271bf
jmp 0x271bf
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::replace_fragment_outputs()
void CompilerGLSL::replace_fragment_outputs()
{
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeVariable)
		{
			auto &var = id.get<SPIRVariable>();
			auto &type = get<SPIRType>(var.basetype);

			if (!is_builtin_variable(var) && !var.remapped_variable && type.pointer &&
			    var.storage == StorageClassOutput)
				replace_fragment_output(var);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r13
cmpq %r13, %r14
je 0x2a931
cmpl $0x2, 0x8(%r14)
jne 0x2a92b
movq %r14, %rdi
callq 0x9b30
movq %rax, %r15
movl 0xc(%rax), %esi
movq %rbx, %rdi
callq 0x90a4
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10c60
testb %al, %al
jne 0x2a92b
cmpb $0x0, 0x5b(%r15)
jne 0x2a92b
cmpb $0x1, 0x60(%r12)
jne 0x2a92b
cmpl $0x3, 0x10(%r15)
jne 0x2a92b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a696
addq $0x10, %r14
jmp 0x2a8d6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::remap_swizzle(spirv_cross::SPIRType const&, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CompilerGLSL::remap_swizzle(const SPIRType &out_type, uint32_t input_components, const string &expr)
{
	if (out_type.vecsize == input_components)
		return expr;
	else if (input_components == 1 && !backend.can_swizzle_scalar)
		return join(type_to_glsl(out_type), "(", expr, ")");
	else
	{
		// FIXME: This will not work with packed expressions.
		auto e = enclose_expression(expr) + ".";
		// Just clamp the swizzle index if we have more outputs than inputs.
		for (uint32_t c = 0; c < out_type.vecsize; c++)
			e += index_to_swizzle(min(c, input_components - 1));
		if (backend.swizzle_is_function && out_type.vecsize > 1)
			e += "()";

		remove_duplicate_swizzle(e);
		return e;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rdi, %rbx
cmpl %ecx, 0x14(%rdx)
jne 0x2a965
movq %rbx, %rdi
movq %r12, %rsi
callq 0x63c0
jmp 0x2aa42
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
cmpl $0x1, %ecx
jne 0x2a980
cmpb $0x0, 0x62c(%r14)
je 0x2aa03
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x2aa76
leaq 0x6ae92(%rip), %rdx     # 0x95829
movq %rbx, %rdi
movq %r13, %rsi
callq 0xab3f
leaq 0x8(%rsp), %rdi
callq 0x6548
decl %ebp
xorl %r12d, %r12d
movl 0x14(%r15), %eax
cmpl %eax, %r12d
jae 0x2a9d8
cmpl %r12d, %ebp
movl %r12d, %esi
cmovbl %ebp, %esi
callq 0x2ab62
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64d0
incl %r12d
jmp 0x2a9b1
cmpl $0x2, %eax
jb 0x2a9f6
cmpb $0x0, 0x620(%r14)
je 0x2a9f6
leaq 0x68f42(%rip), %rsi     # 0x93930
movq %rbx, %rdi
callq 0x64d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2abf8
jmp 0x2aa42
movq (%r14), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq *0x98(%rax)
leaq 0x73206(%rip), %rdx     # 0x9dc29
leaq 0x6afcb(%rip), %r8      # 0x959f5
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rcx
callq 0x426cb
leaq 0x8(%rsp), %rdi
callq 0x6548
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2aa56
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x2aa68
jmp 0x2aa62
movq %rax, %r14
movq %rbx, %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::enclose_expression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CompilerGLSL::enclose_expression(const string &expr)
{
	bool need_parens = false;

	// If the expression starts with a unary we need to enclose to deal with cases where we have back-to-back
	// unary expressions.
	if (!expr.empty())
	{
		auto c = expr.front();
		if (c == '-' || c == '+' || c == '!' || c == '~')
			need_parens = true;
	}

	if (!need_parens)
	{
		uint32_t paren_count = 0;
		for (auto c : expr)
		{
			if (c == '(' || c == '[')
				paren_count++;
			else if (c == ')' || c == ']')
			{
				assert(paren_count);
				paren_count--;
			}
			else if (c == ' ' && paren_count == 0)
			{
				need_parens = true;
				break;
			}
		}
		assert(paren_count == 0);
	}

	// If this expression contains any spaces which are not enclosed by parentheses,
	// we need to enclose it so we can treat the whole string as an expression.
	// This happens when two expressions have been part of a binary op earlier.
	if (need_parens)
		return join('(', expr, ')');
	else
		return expr;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x2aac2
movzbl (%rax), %esi
cmpq $0x2d, %rsi
ja 0x2aaa3
movabsq $0x280200000000, %rdi   # imm = 0x280200000000
btq %rsi, %rdi
jb 0x2aaa8
cmpl $0x7e, %esi
jne 0x2aac2
leaq 0xf(%rsp), %rsi
movb $0x28, (%rsi)
leaq 0xe(%rsp), %rcx
movb $0x29, (%rcx)
movq %rbx, %rdi
callq 0x42c62
jmp 0x2ab1b
xorl %esi, %esi
xorl %edi, %edi
cmpq %rsi, %rcx
je 0x2ab0c
movzbl (%rax,%rsi), %r8d
cmpl $0x28, %r8d
je 0x2aae8
cmpl $0x29, %r8d
je 0x2aaec
cmpl $0x5d, %r8d
je 0x2aaec
cmpl $0x5b, %r8d
jne 0x2aaf4
incl %edi
jmp 0x2ab07
testl %edi, %edi
je 0x2ab24
decl %edi
jmp 0x2ab07
cmpb $0x20, %r8b
sete %r8b
testl %edi, %edi
sete %r9b
testb %r9b, %r8b
jne 0x2aaa8
incq %rsi
jmp 0x2aac6
testl %edi, %edi
jne 0x2ab43
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x63c0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x68481(%rip), %rdi     # 0x92fac
leaq 0x671f6(%rip), %rsi     # 0x91d28
leaq 0x6847f(%rip), %rcx     # 0x92fb8
movl $0x949, %edx            # imm = 0x949
callq 0x61c0
leaq 0x684b3(%rip), %rdi     # 0x92ffd
leaq 0x671d7(%rip), %rsi     # 0x91d28
leaq 0x68460(%rip), %rcx     # 0x92fb8
movl $0x952, %edx            # imm = 0x952
callq 0x61c0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::index_to_swizzle(unsigned int)
const char *CompilerGLSL::index_to_swizzle(uint32_t index)
{
	switch (index)
	{
	case 0:
		return "x";
	case 1:
		return "y";
	case 2:
		return "z";
	case 3:
		return "w";
	default:
		SPIRV_CROSS_THROW("Swizzle index out of range");
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x4, %esi
jae 0x2ab88
movl %esi, %eax
leaq 0x66874(%rip), %rcx     # 0x913ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x698e3(%rip), %rsi     # 0x9447d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xbc1fe(%rip), %rsi     # 0xe6dc0
movq 0xbd417(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x2abe8
jmp 0x2abf0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::pls_decl[abi:cxx11](spirv_cross::PlsRemap const&)
string CompilerGLSL::pls_decl(const PlsRemap &var)
{
	auto &variable = get<SPIRVariable>(var.id);

	SPIRType type;
	type.vecsize = pls_format_to_components(var.format);
	type.basetype = pls_format_to_basetype(var.format);

	return join(to_pls_layout(var.format), to_pls_qualifiers_glsl(variable), type_to_glsl(type), " ",
	            to_name(variable.self));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %esi
movq %r14, %rdi
callq 0x9c0e
leaq 0x120(%rsp), %rcx
andl $0x0, -0xc8(%rcx)
leaq 0xbc397(%rip), %rdx     # 0xe73f0
addq $0x10, %rdx
movq %rdx, -0xd0(%rcx)
andl $0x0, -0xc0(%rcx)
movl $0x1, -0xb8(%rcx)
andq $0x0, -0x88(%rcx)
andl $0x0, -0x80(%rcx)
andq $0x0, -0x78(%rcx)
movq %rax, %r15
movb $0x0, -0x70(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0xb0(%rcx)
movups %xmm0, -0xa0(%rcx)
andl $0x0, -0x90(%rcx)
movl $0x8, -0x6c(%rcx)
andq $0x0, -0x58(%rcx)
movups %xmm0, -0x68(%rcx)
andq $0x0, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, -0x10(%rcx) # imm = 0x3F800000
movups %xmm0, -0x8(%rcx)
movl 0x4(%r12), %eax
pushq $0x1
popq %rcx
cmpl $0xb, %eax
ja 0x2b101
movl $0x6b0, %edx            # imm = 0x6B0
btl %eax, %edx
jb 0x2b0fe
movl $0x948, %edx            # imm = 0x948
btl %eax, %edx
jae 0x2b1d4
pushq $0x2
jmp 0x2b100
pushq $0x4
popq %rcx
movl %ecx, 0x64(%rsp)
leal -0x7(%rax), %ecx
cmpl $0x5, %ecx
ja 0x2b11b
movl %ecx, %ecx
leaq 0x662e6(%rip), %rdx     # 0x913fc
movl (%rdx,%rcx,4), %ecx
jmp 0x2b11e
pushq $0xa
popq %rcx
movl %ecx, 0x5c(%rsp)
decl %eax
cmpl $0xb, %eax
ja 0x2b13b
movl %eax, %eax
leaq 0x662e2(%rip), %rcx     # 0x91414
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmp 0x2b142
leaq 0x64745(%rip), %rax     # 0x8f887
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dc0e
movq %rax, (%rsp)
movq (%r14), %rax
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq *0x98(%rax)
movl 0x8(%r15), %edx
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq *0x38(%rax)
leaq 0x646fc(%rip), %r8      # 0x8f886
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r9
movq %rbx, %rdi
callq 0x46880
leaq 0x10(%rsp), %rdi
callq 0x6548
leaq 0x30(%rsp), %rdi
callq 0x6548
leaq 0x50(%rsp), %rdi
callq 0x17a3e
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x1, %eax
jne 0x2b101
movl $0x3, 0x64(%rsp)
movl $0xa, 0x5c(%rsp)
leaq 0x6ab95(%rip), %rax     # 0x95d89
jmp 0x2b142
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6548
jmp 0x2b20b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6548
jmp 0x2b21c
jmp 0x2b219
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x17a3e
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::declare_undefined_values()
void CompilerGLSL::declare_undefined_values()
{
	bool emitted = false;
	for (auto &id : ir.ids)
	{
		if (id.get_type() != TypeUndef)
			continue;

		auto &undef = id.get<SPIRUndef>();
		statement(variable_decl(get<SPIRType>(undef.basetype), to_name(undef.self), undef.self), ";");
		emitted = true;
	}

	if (emitted)
		statement("");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
xorl %eax, %eax
cmpq %r15, %r14
je 0x2b972
cmpl $0xd, 0x8(%r14)
jne 0x2b969
movq %r14, %rdi
callq 0x429e0
movq %rax, %rbp
movl 0xc(%rax), %esi
movq %rbx, %rdi
callq 0x90a4
movq %rax, %r13
movl 0x8(%rbp), %edx
movq (%rbx), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rcx
callq *0x38(%rax)
movl 0x8(%rbp), %r8d
leaq 0x28(%rsp), %rbp
movq (%rbx), %rax
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *0xc8(%rax)
movq %rbx, %rdi
movq %rbp, %rsi
leaq 0x6e131(%rip), %rdx     # 0x99a81
callq 0x953a
movq %rbp, %rdi
callq 0x6548
leaq 0x8(%rsp), %rdi
callq 0x6548
movb $0x1, %al
addq $0x10, %r14
jmp 0x2b8e5
testb $0x1, %al
je 0x2b985
leaq 0x63f0a(%rip), %rsi     # 0x8f887
movq %rbx, %rdi
callq 0x928e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2b9a6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6548
leaq 0x8(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_unpacked_expression[abi:cxx11](unsigned int)
string CompilerGLSL::to_unpacked_expression(uint32_t id)
{
	// If we need to transpose, it will also take care of unpacking rules.
	auto *e = maybe_get<SPIRExpression>(id);
	bool need_transpose = e && e->need_transpose;
	if (!need_transpose && has_decoration(id, DecorationCPacked))
		return unpack_expression_type(to_expression(id), expression_type(id));
	else
		return to_expression(id);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x16fde
testq %rax, %rax
je 0x2bf3b
cmpb $0x0, 0x39(%rax)
jne 0x2bf83
pushq $0xa
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x103d2
testb %al, %al
je 0x2bf83
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2b9f0
movq %r14, %rdi
movl %ebp, %esi
callq 0x104b0
movq (%r14), %r8
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq *0x100(%r8)
movq %rsp, %rdi
callq 0x6548
jmp 0x2bf90
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2b9f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_enclosed_unpacked_expression[abi:cxx11](unsigned int)
string CompilerGLSL::to_enclosed_unpacked_expression(uint32_t id)
{
	// If we need to transpose, it will also take care of unpacking rules.
	auto *e = maybe_get<SPIRExpression>(id);
	bool need_transpose = e && e->need_transpose;
	if (!need_transpose && has_decoration(id, DecorationCPacked))
		return unpack_expression_type(to_expression(id), expression_type(id));
	else
		return to_enclosed_expression(id);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x16fde
testq %rax, %rax
je 0x2bfd5
cmpb $0x0, 0x39(%rax)
jne 0x2c01d
pushq $0xa
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x103d2
testb %al, %al
je 0x2c01d
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2b9f0
movq %r14, %rdi
movl %ebp, %esi
callq 0x104b0
movq (%r14), %r8
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq *0x100(%r8)
movq %rsp, %rdi
callq 0x6548
jmp 0x2c02a
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2beca
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_extract_component_expression[abi:cxx11](unsigned int, unsigned int)
string CompilerGLSL::to_extract_component_expression(uint32_t id, uint32_t index)
{
	auto expr = to_enclosed_expression(id);
	if (has_decoration(id, DecorationCPacked))
		return join(expr, "[", index, "]");
	else
		return join(expr, ".", index_to_swizzle(index));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2beca
pushq $0xa
popq %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x103d2
testb %al, %al
je 0x2c0a1
leaq 0x71c1e(%rip), %rdx     # 0x9dca4
leaq 0x6ca41(%rip), %r8      # 0x98ace
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
callq 0x42cdc
jmp 0x2c0c4
movl %ebp, %esi
callq 0x2ab62
leaq 0x30(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x69772(%rip), %rdx     # 0x95829
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x42d58
leaq 0x10(%rsp), %rdi
callq 0x6548
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c0de
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::track_expression_read(unsigned int)
void CompilerGLSL::track_expression_read(uint32_t id)
{
	// If we try to read a forwarded temporary more than once we will stamp out possibly complex code twice.
	// In this case, it's better to just bind the complex expression to the temporary and read that temporary twice.
	if (expression_is_forwarded(id))
	{
		auto &v = expression_usage_counts[id];
		v++;

		if (v >= 2)
		{
			//if (v == 2)
			//    fprintf(stderr, "ID %u was forced to temporary due to more than 1 expression use!\n", id);

			forced_temporaries.insert(id);
			// Force a recompile after this pass to avoid forwarding this variable.
			force_recompile = true;
		}
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
callq 0x2f176
testb %al, %al
je 0x2c13d
leaq 0x6e8(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1d40e
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
cmpl $0x2, %ecx
jb 0x2c13d
leaq 0x228(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1af30
movb $0x1, 0x1d0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::load_flattened_struct[abi:cxx11](spirv_cross::SPIRVariable&)
string CompilerGLSL::load_flattened_struct(SPIRVariable &var)
{
	auto expr = type_to_glsl_constructor(get<SPIRType>(var.basetype));
	expr += '(';

	auto &type = get<SPIRType>(var.basetype);
	for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++)
	{
		if (i)
			expr += ", ";

		// Flatten the varyings.
		// Apply name transformation for flattened I/O blocks.
		expr += to_flattened_struct_member(var, i);
	}
	expr += ')';
	return expr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0xc(%rdx), %esi
movq %r15, %rdi
callq 0x90a4
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2c226
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x6230
movl 0xc(%r14), %esi
movq %r15, %rdi
callq 0x90a4
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq 0x70(%r12), %rax
subq 0x68(%r12), %rax
shrq $0x2, %rax
cmpl %eax, %ebp
jae 0x2c1e1
testl %ebp, %ebp
je 0x2c1ba
movq %rbx, %rdi
leaq 0x68ed6(%rip), %rsi     # 0x9508b
callq 0x64d0
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35746
movq %rbx, %rdi
movq %r13, %rsi
callq 0x64f0
movq %r13, %rdi
callq 0x6548
incl %ebp
jmp 0x2c195
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x6230
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c213
jmp 0x2c213
jmp 0x2c213
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6548
jmp 0x2c216
movq %rax, %r14
movq %rbx, %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::type_to_glsl_constructor[abi:cxx11](spirv_cross::SPIRType const&)
string CompilerGLSL::type_to_glsl_constructor(const SPIRType &type)
{
	if (type.array.size() > 1)
	{
		if (options.flatten_multidimensional_arrays)
			SPIRV_CROSS_THROW("Cannot flatten constructors of multidimensional array constructors, e.g. float[][]().");
		else if (!options.es && options.version < 430)
			require_extension_internal("GL_ARB_arrays_of_arrays");
		else if (options.es && options.version < 310)
			SPIRV_CROSS_THROW("Arrays of arrays not supported before ESSL version 310.");
	}

	auto e = type_to_glsl(type);
	for (uint32_t i = 0; i < type.array.size(); i++)
		e += "[]";
	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rdx), %rax
subq 0x20(%rdx), %rax
cmpq $0x5, %rax
jb 0x2c2fe
cmpb $0x1, 0x440(%r15)
je 0x2c34b
movb 0x43c(%r15), %al
movl 0x438(%r15), %ecx
cmpl $0x1ae, %ecx            # imm = 0x1AE
setae %dl
orb %al, %dl
je 0x2c2d1
cmpl $0x136, %ecx            # imm = 0x136
setb %cl
andb %cl, %al
cmpb $0x1, %al
jne 0x2c2fe
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x69596(%rip), %rsi     # 0x9582b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xbab03(%rip), %rsi     # 0xe6dc0
movq 0xbbd1c(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x2c394
leaq 0x693ac(%rip), %rsi     # 0x95684
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6100
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x21390
leaq 0x8(%rsp), %rdi
callq 0x6548
movq (%r15), %rax
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x98(%rax)
leaq 0x66c21(%rip), %r15     # 0x92f3c
movl %ebp, %eax
movq 0x28(%r14), %rcx
subq 0x20(%r14), %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
jbe 0x2c33d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
incl %ebp
jmp 0x2c31b
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x69478(%rip), %rsi     # 0x957d5
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xbaa3b(%rip), %rsi     # 0xe6dc0
movq 0xbbc54(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x2c3a7
jmp 0x2c3bb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x2c3ce
movq %rax, %r14
jmp 0x2c3d3
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x2c3be
jmp 0x2c3d3
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
jmp 0x2c3d3
movq %rax, %r14
movq %rbx, %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::bitcast_glsl[abi:cxx11](spirv_cross::SPIRType const&, unsigned int)
string CompilerGLSL::bitcast_glsl(const SPIRType &result_type, uint32_t argument)
{
	auto op = bitcast_glsl_op(result_type, expression_type(argument));
	if (op.empty())
		return to_enclosed_expression(argument);
	else
		return join(op, "(", to_expression(argument), ")");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %ecx, %esi
callq 0x104b0
movq (%r14), %r8
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq *0x168(%r8)
cmpq $0x0, 0x8(%r12)
je 0x2d3bd
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2b9f0
leaq 0x7088d(%rip), %rdx     # 0x9dc29
leaq 0x68652(%rip), %r8      # 0x959f5
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x42fc9
movq %rsp, %rdi
callq 0x6548
jmp 0x2d3ca
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2beca
leaq 0x20(%rsp), %rdi
callq 0x6548
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d3f3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6548
jmp 0x2d3f6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_op(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool)
SPIRExpression &CompilerGLSL::emit_op(uint32_t result_type, uint32_t result_id, const string &rhs, bool forwarding,
                                      bool suppress_usage_tracking)
{
	if (forwarding && (forced_temporaries.find(result_id) == end(forced_temporaries)))
	{
		// Just forward it without temporary.
		// If the forward is trivial, we do not force flushing to temporary for this expression.
		if (!suppress_usage_tracking)
			forwarded_temporaries.insert(result_id);

		return set<SPIRExpression>(result_id, rhs, result_type, true);
	}
	else
	{
		// If expression isn't immutable, bind it to a temporary and make the new temporary immutable (they always are).
		statement(declare_temporary(result_type, result_id), rhs, ";");
		return set<SPIRExpression>(result_id, to_name(result_id), result_type, true);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
movl %esi, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
testl %r8d, %r8d
je 0x2f1dc
movl %r9d, %ebp
leaq 0x228(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1c722
testq %rax, %rax
je 0x2f25b
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2ee90
leaq 0x6a88e(%rip), %rcx     # 0x99a81
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x435da
leaq 0x18(%rsp), %rdi
callq 0x6548
movl 0xc(%rsp), %ebp
movq (%rbx), %rax
leaq 0x18(%rsp), %r14
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x38(%rax)
leaq 0x17(%rsp), %r8
movb $0x1, (%r8)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x436b4
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6548
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb %bpl, %bpl
jne 0x2f271
leaq 0x260(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1af30
movl 0xc(%rsp), %esi
leaq 0x18(%rsp), %r8
movb $0x1, (%r8)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4359e
movq %rax, %rbx
jmp 0x2f24d
jmp 0x2f295
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_binary_op(unsigned int, unsigned int, unsigned int, unsigned int, char const*)
void CompilerGLSL::emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op)
{
	bool forward = should_forward(op0) && should_forward(op1);
	emit_op(result_type, result_id,
	        join(to_enclosed_unpacked_expression(op0), " ", op, " ", to_enclosed_unpacked_expression(op1)), forward);

	inherit_expression_dependencies(result_id, op0);
	inherit_expression_dependencies(result_id, op1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movq %r9, (%rsp)
movl %ecx, %esi
callq 0x2f360
testb %al, %al
je 0x2f3d4
movq %r14, %rdi
movl %ebx, %esi
callq 0x2f360
movl %eax, %r13d
jmp 0x2f3d7
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2bfb0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2bfb0
leaq 0x60489(%rip), %rdx     # 0x8f886
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rsp, %rcx
leaq 0x8(%rsp), %r9
movq %rdx, %r8
callq 0x4375a
movzbl %r13b, %r8d
leaq 0x48(%rsp), %rcx
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x2f196
leaq 0x48(%rsp), %rdi
callq 0x6548
leaq 0x8(%rsp), %rdi
callq 0x6548
leaq 0x28(%rsp), %rdi
callq 0x6548
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x13128
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x13128
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6548
jmp 0x2f488
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6548
jmp 0x2f497
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_unrolled_unary_op(unsigned int, unsigned int, unsigned int, char const*)
void CompilerGLSL::emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *op)
{
	auto &type = get<SPIRType>(result_type);
	auto expr = type_to_glsl_constructor(type);
	expr += '(';
	for (uint32_t i = 0; i < type.vecsize; i++)
	{
		// Make sure to call to_expression multiple times to ensure
		// that these expressions are properly flushed to temporaries if needed.
		expr += op;
		expr += to_extract_component_expression(operand, i);

		if (i + 1 < type.vecsize)
			expr += ", ";
	}
	expr += ')';
	emit_op(result_type, result_id, expr, should_forward(operand));

	inherit_expression_dependencies(result_id, operand);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r12
movl %ecx, 0xc(%rsp)
movl %edx, 0x10(%rsp)
movq %rdi, %r14
movl %esi, 0x14(%rsp)
callq 0x90a4
movq %rax, %r13
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2c226
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x6230
xorl %ebp, %ebp
leaq 0x18(%rsp), %r15
leaq 0x38(%rsp), %rbx
cmpl 0x14(%r13), %ebp
jae 0x2f54a
movq %r15, %rdi
movq %r12, %rsi
callq 0x64d0
movq %rbx, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
movl %ebp, %ecx
callq 0x2c04a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x64f0
movq %rbx, %rdi
callq 0x6548
incl %ebp
cmpl 0x14(%r13), %ebp
jae 0x2f4fc
movq %r15, %rdi
leaq 0x65b48(%rip), %rsi     # 0x9508b
callq 0x64d0
jmp 0x2f4fc
leaq 0x18(%rsp), %rdi
pushq $0x29
popq %rsi
callq 0x6230
movq %r14, %rdi
movl 0xc(%rsp), %esi
callq 0x2f360
movzbl %al, %r8d
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
xorl %r9d, %r9d
callq 0x2f196
movq %r14, %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x13128
leaq 0x18(%rsp), %rdi
callq 0x6548
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f5bb
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6548
jmp 0x2f5be
jmp 0x2f5bb
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_unrolled_binary_op(unsigned int, unsigned int, unsigned int, unsigned int, char const*)
void CompilerGLSL::emit_unrolled_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
                                           const char *op)
{
	auto &type = get<SPIRType>(result_type);
	auto expr = type_to_glsl_constructor(type);
	expr += '(';
	for (uint32_t i = 0; i < type.vecsize; i++)
	{
		// Make sure to call to_expression multiple times to ensure
		// that these expressions are properly flushed to temporaries if needed.
		expr += to_extract_component_expression(op0, i);
		expr += ' ';
		expr += op;
		expr += ' ';
		expr += to_extract_component_expression(op1, i);

		if (i + 1 < type.vecsize)
			expr += ", ";
	}
	expr += ')';
	emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1));

	inherit_expression_dependencies(result_id, op0);
	inherit_expression_dependencies(result_id, op1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
movl %ecx, 0x8(%rsp)
movl %edx, (%rsp)
movq %rdi, %r14
movl %esi, 0xc(%rsp)
callq 0x90a4
movq %rax, %r12
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2c226
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x6230
xorl %ebp, %ebp
leaq 0x38(%rsp), %rbx
leaq 0x18(%rsp), %r15
pushq $0x20
popq %r13
cmpl 0x14(%r12), %ebp
jae 0x2f6bf
movq %rbx, %rdi
movq %r14, %rsi
movl 0x8(%rsp), %edx
movl %ebp, %ecx
callq 0x2c04a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x64f0
movq %rbx, %rdi
callq 0x6548
movq %r15, %rdi
movl %r13d, %esi
callq 0x6230
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x64d0
movq %r15, %rdi
movl %r13d, %esi
callq 0x6230
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movl %ebp, %ecx
callq 0x2c04a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x64f0
movq %rbx, %rdi
callq 0x6548
incl %ebp
cmpl 0x14(%r12), %ebp
jae 0x2f62c
movq %r15, %rdi
leaq 0x659d6(%rip), %rsi     # 0x9508b
callq 0x64d0
jmp 0x2f62c
leaq 0x18(%rsp), %rdi
pushq $0x29
popq %rsi
callq 0x6230
movq %r14, %rdi
movl 0x8(%rsp), %esi
callq 0x2f360
testb %al, %al
je 0x2f6ea
movq %r14, %rdi
movl 0x4(%rsp), %esi
callq 0x2f360
jmp 0x2f6ec
xorl %eax, %eax
movzbl %al, %r8d
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
movl 0xc(%rsp), %esi
movl (%rsp), %edx
xorl %r9d, %r9d
callq 0x2f196
movq %r14, %rdi
movl (%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x13128
movq %r14, %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x13128
leaq 0x18(%rsp), %rdi
callq 0x6548
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f755
jmp 0x2f755
jmp 0x2f746
jmp 0x2f755
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6548
jmp 0x2f758
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_binary_func_op(unsigned int, unsigned int, unsigned int, unsigned int, char const*)
void CompilerGLSL::emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
                                       const char *op)
{
	bool forward = should_forward(op0) && should_forward(op1);
	emit_op(result_type, result_id, join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ")"),
	        forward);
	inherit_expression_dependencies(result_id, op0);
	inherit_expression_dependencies(result_id, op1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %ebx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movq %r9, 0x10(%rsp)
movl %ecx, %esi
callq 0x2f360
testb %al, %al
je 0x2faf3
movq %r14, %rdi
movl %ebx, %esi
callq 0x2f360
movl %eax, %r13d
jmp 0x2faf6
xorl %r13d, %r13d
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2bf16
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2bf16
leaq 0x65ed9(%rip), %rax     # 0x959f5
movq %rax, (%rsp)
leaq 0x6e102(%rip), %rdx     # 0x9dc29
leaq 0x6555d(%rip), %r8      # 0x9508b
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rcx
leaq 0x18(%rsp), %r9
callq 0x438ee
movzbl %r13b, %r8d
leaq 0x58(%rsp), %rcx
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x2f196
leaq 0x58(%rsp), %rdi
callq 0x6548
leaq 0x18(%rsp), %rdi
callq 0x6548
leaq 0x38(%rsp), %rdi
callq 0x6548
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x13128
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x13128
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x6548
jmp 0x2fbb8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6548
jmp 0x2fbc7
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_trinary_func_op(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, char const*)
void CompilerGLSL::emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
                                        uint32_t op2, const char *op)
{
	bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2);
	emit_op(result_type, result_id,
	        join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ", ",
	             to_unpacked_expression(op2), ")"),
	        forward);

	inherit_expression_dependencies(result_id, op0);
	inherit_expression_dependencies(result_id, op1);
	inherit_expression_dependencies(result_id, op2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, (%rsp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movl %ecx, %esi
callq 0x2f360
testb %al, %al
je 0x2fedc
movq %r14, %rdi
movl %r15d, %esi
callq 0x2f360
testb %al, %al
je 0x2fedc
movq %r14, %rdi
movl (%rsp), %esi
callq 0x2f360
movl %eax, %r13d
jmp 0x2fedf
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x2bf16
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2bf16
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl (%rsp), %edx
callq 0x2bf16
subq $0x8, %rsp
leaq 0x65ad8(%rip), %rax     # 0x959f5
leaq 0x65167(%rip), %r8      # 0x9508b
leaq 0x6dcfe(%rip), %rdx     # 0x9dc29
leaq 0x50(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r9
pushq %rax
pushq %rbx
pushq %r8
callq 0x43a1e
addq $0x20, %rsp
movzbl %r13b, %r8d
leaq 0x48(%rsp), %rcx
movq %r14, %rdi
movl 0x4(%rsp), %esi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x2f196
leaq 0x48(%rsp), %rdi
callq 0x6548
leaq 0x68(%rsp), %rdi
callq 0x6548
leaq 0x8(%rsp), %rdi
callq 0x6548
leaq 0x28(%rsp), %rdi
callq 0x6548
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x13128
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x13128
movq %r14, %rdi
movl %ebp, %esi
movl (%rsp), %edx
callq 0x13128
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6548
jmp 0x2ffdc
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6548
jmp 0x2ffeb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6548
jmp 0x2fffa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_quaternary_func_op(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, char const*)
void CompilerGLSL::emit_quaternary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
                                           uint32_t op2, uint32_t op3, const char *op)
{
	bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2) && should_forward(op3);
	emit_op(result_type, result_id,
	        join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ", ",
	             to_unpacked_expression(op2), ", ", to_unpacked_expression(op3), ")"),
	        forward);

	inherit_expression_dependencies(result_id, op0);
	inherit_expression_dependencies(result_id, op1);
	inherit_expression_dependencies(result_id, op2);
	inherit_expression_dependencies(result_id, op3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %ebp
movl %ecx, %r13d
movl %edx, %ebx
movl %esi, 0x14(%rsp)
movq %rdi, %r15
movl %ecx, %esi
callq 0x2f360
testb %al, %al
movl %ebp, 0x10(%rsp)
je 0x30072
movq %r15, %rdi
movl %ebp, %esi
callq 0x2f360
testb %al, %al
je 0x30072
movq %r15, %rdi
movl 0xc(%rsp), %esi
callq 0x2f360
testb %al, %al
je 0x30072
movq %r15, %rdi
movl 0xf0(%rsp), %esi
callq 0x2f360
movl %eax, %r14d
jmp 0x30075
xorl %r14d, %r14d
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x2bf16
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movl 0x10(%rsp), %edx
callq 0x2bf16
leaq 0x98(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
callq 0x2bf16
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl 0xf0(%rsp), %edx
callq 0x2bf16
subq $0x8, %rsp
leaq 0x65926(%rip), %rax     # 0x959f5
leaq 0x64fb5(%rip), %r8      # 0x9508b
leaq 0x6db4c(%rip), %rdx     # 0x9dc29
leaq 0x60(%rsp), %rdi
leaq 0x100(%rsp), %rsi
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r9
pushq %rax
pushq %r12
pushq %r8
pushq %rbp
pushq %r8
callq 0x43ac3
addq $0x30, %rsp
movzbl %r14b, %r8d
leaq 0x58(%rsp), %rcx
movq %r15, %rdi
movl 0x14(%rsp), %esi
movl %ebx, %edx
xorl %r9d, %r9d
callq 0x2f196
leaq 0x58(%rsp), %rdi
callq 0x6548
leaq 0x78(%rsp), %rdi
callq 0x6548
leaq 0x98(%rsp), %rdi
callq 0x6548
leaq 0x18(%rsp), %rdi
callq 0x6548
leaq 0x38(%rsp), %rdi
callq 0x6548
movq %r15, %rdi
movl %ebx, %esi
movl %r13d, %edx
callq 0x13128
movq %r15, %rdi
movl %ebx, %esi
movl 0x10(%rsp), %edx
callq 0x13128
movq %r15, %rdi
movl %ebx, %esi
movl 0xc(%rsp), %edx
callq 0x13128
movq %r15, %rdi
movl %ebx, %esi
movl 0xf0(%rsp), %edx
callq 0x13128
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x6548
jmp 0x301b2
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x6548
jmp 0x301c1
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x6548
jmp 0x301d3
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6548
jmp 0x301e2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::check_explicit_lod_allowed(unsigned int)
bool CompilerGLSL::check_explicit_lod_allowed(uint32_t lod)
{
	auto &execution = get_entry_point();
	bool allowed = !is_legacy_es() || execution.model == ExecutionModelFragment;
	if (!allowed && lod != 0)
	{
		auto *lod_constant = maybe_get<SPIRConstant>(lod);
		if (!lod_constant || lod_constant->scalar_f32() != 0.0f)
		{
			SPIRV_CROSS_THROW("Explicit lod not allowed in legacy ES non-fragment shaders.");
		}
	}
	return allowed;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %r14
callq 0x12fa4
movb 0x43c(%r14), %cl
cmpl $0x12c, 0x438(%r14) # imm = 0x12C
setae %dl
xorb $0x1, %cl
orb %dl, %cl
cmpl $0x4, 0xb8(%rax)
sete %bl
orb %cl, %bl
testl %ebp, %ebp
je 0x30252
testb %bl, %bl
jne 0x30252
movq %r14, %rdi
movl %ebp, %esi
callq 0x43b76
testq %rax, %rax
je 0x3025d
movss 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3025d
jp 0x3025d
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x63081(%rip), %rsi     # 0x932f0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0xb6b29(%rip), %rsi     # 0xe6dc0
movq 0xb7d42(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x302bd
jmp 0x302c5
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_sampled_image_op(unsigned int, unsigned int, unsigned int, unsigned int)
void CompilerGLSL::emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id)
{
	if (options.vulkan_semantics && combined_image_samplers.empty())
	{
		emit_binary_func_op(result_type, result_id, image_id, samp_id,
		                    type_to_glsl(get<SPIRType>(result_type), result_id).c_str());

		// Make sure to suppress usage tracking. It is illegal to create temporaries of opaque types.
		forwarded_temporaries.erase(result_id);
	}
	else
	{
		// Make sure to suppress usage tracking. It is illegal to create temporaries of opaque types.
		emit_op(result_type, result_id, to_combined_image_sampler(image_id, samp_id), true, true);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
cmpb $0x1, 0x43e(%rdi)
jne 0x311c7
movq 0x1d8(%rbx), %rax
cmpq 0x1e0(%rbx), %rax
je 0x3120d
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x30bcc
pushq $0x1
popq %r8
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r13, %rcx
movl %r8d, %r9d
callq 0x2f196
leaq 0x8(%rsp), %rdi
callq 0x6548
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0x90a4
movq (%rbx), %r8
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq *0x98(%r8)
movq (%r13), %r9
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %r12d, %ecx
movl %r15d, %r8d
callq 0x2fab8
leaq 0x8(%rsp), %rdi
callq 0x6548
addq $0x260, %rbx            # imm = 0x260
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a0f0
jmp 0x311fe
jmp 0x3126b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::register_control_dependent_expression(unsigned int)
void CompilerGLSL::register_control_dependent_expression(uint32_t expr)
{
	if (forwarded_temporaries.find(expr) == end(forwarded_temporaries))
		return;

	assert(current_emitting_block);
	current_emitting_block->invalidate_expressions.push_back(expr);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x260, %rdi            # imm = 0x260
movq %rax, %rsi
callq 0x1c722
testq %rax, %rax
je 0x318ea
movq 0x410(%rbx), %rdi
testq %rdi, %rdi
je 0x318f0
addq $0xe8, %rdi
leaq 0xc(%rsp), %rsi
callq 0x6c06
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6335c(%rip), %rdi     # 0x94c53
leaq 0x6042a(%rip), %rsi     # 0x91d28
leaq 0x63365(%rip), %rcx     # 0x94c6a
movl $0x182b, %edx           # imm = 0x182B
callq 0x61c0
nop