LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33081
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe480
jmp 0x33178
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
cmpl $0x1, %ecx
jne 0x3309c
cmpb $0x0, 0x62c(%r14)
je 0x3318a
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x33218
leaq 0x887a6(%rip), %rsi     # 0xbb859
movq %r13, %rdi
callq 0x64e0
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x330dd
movq %rdx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x330e5
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33117
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
xorl %r13d, %r13d
cmpl $0x0, 0x14(%r15)
je 0x3314f
decl %ebp
cmpl %r13d, %ebp
movl %r13d, %esi
cmovbl %ebp, %esi
callq 0x3336a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64e0
incl %r13d
movl 0x14(%r15), %eax
cmpl %eax, %r13d
jb 0x33123
cmpl $0x2, %eax
setae %r13b
testb %r13b, %r13b
je 0x3316d
cmpb $0x0, 0x620(%r14)
je 0x3316d
leaq 0x867fb(%rip), %rsi     # 0xb9960
movq %rbx, %rdi
callq 0x64e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq *0x98(%rax)
leaq 0x90af7(%rip), %rdx     # 0xc3ca1
leaq 0x88874(%rip), %r8      # 0xbba25
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rcx
callq 0x52f43
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33178
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x33178
jmp 0x331de
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3320f
movq 0x18(%rsp), %rsi
jmp 0x33207
jmp 0x331f8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3320f
movq (%r12), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rdx), %rax
testq %rax, %rax
je 0x3324e
movq (%rdx), %rcx
movzbl (%rcx), %ecx
cmpq $0x2d, %rcx
ja 0x33245
movabsq $0x280200000000, %rsi   # imm = 0x280200000000
btq %rcx, %rsi
jb 0x3324a
cmpl $0x7e, %ecx
jne 0x3324e
movb $0x1, %cl
jmp 0x33250
xorl %ecx, %ecx
testb %cl, %cl
jne 0x332ec
testq %rax, %rax
je 0x332e4
movq (%rdx), %rsi
leaq -0x1(%rax), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movb (%rsi,%r8), %r10b
movzbl %r10b, %r11d
cmpl $0x5a, %r11d
jg 0x3328a
cmpl $0x28, %r11d
je 0x33296
cmpl $0x29, %r11d
je 0x3329b
jmp 0x332a9
cmpl $0x5d, %r11d
je 0x3329b
cmpl $0x5b, %r11d
jne 0x332a9
incl %r9d
jmp 0x332c7
testl %r9d, %r9d
je 0x3332c
decl %r9d
jmp 0x332c7
cmpb $0x20, %r10b
sete %r10b
testl %r9d, %r9d
sete %r11b
testb %r11b, %r10b
je 0x332c7
movb $0x1, %r10b
xorl %r9d, %r9d
movb $0x1, %cl
jmp 0x332ca
xorl %r10d, %r10d
testb %r10b, %r10b
jne 0x332db
leaq 0x1(%r8), %r10
cmpq %r8, %rdi
movq %r10, %r8
jne 0x3326e
testl %r9d, %r9d
sete %sil
jmp 0x332e7
movb $0x1, %sil
testb %sil, %sil
je 0x3334b
testb $0x1, %cl
je 0x3330b
leaq 0xf(%rsp), %rsi
movb $0x28, (%rsi)
leaq 0xe(%rsp), %rcx
movb $0x29, (%rcx)
movq %rbx, %rdi
callq 0x536db
jmp 0x33323
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rdx), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe480
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x85ca9(%rip), %rdi     # 0xb8fdc
leaq 0x84a1e(%rip), %rsi     # 0xb7d58
leaq 0x85ca7(%rip), %rcx     # 0xb8fe8
movl $0x949, %edx            # imm = 0x949
callq 0x61b0
leaq 0x85cdb(%rip), %rdi     # 0xb902d
leaq 0x849ff(%rip), %rsi     # 0xb7d58
leaq 0x85c88(%rip), %rcx     # 0xb8fe8
movl $0x952, %edx            # imm = 0x952
callq 0x61b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x4, %esi
jae 0x33394
movl %esi, %eax
leaq 0x8409a(%rip), %rcx     # 0xb741c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x870fc(%rip), %rsi     # 0xba4ad
leaq 0x8710f(%rip), %rdx     # 0xba4c7
leaq 0x8(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xc99bf(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xc9997(%rip), %rsi     # 0xfcd80
movq 0xcabe8(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3341a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3341a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x33427
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::handle_invalid_expression(unsigned int)
void CompilerGLSL::handle_invalid_expression(uint32_t id)
{
	// We tried to read an invalidated expression.
	// This means we need another pass at compilation, but next time, force temporary variables so that they cannot be invalidated.
	forced_temporaries.insert(id);
	force_recompile = true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
addq $0x228, %rdi            # imm = 0x228
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, %rsi
callq 0x1fc02
movb $0x1, 0x1d0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ba12
testq %rax, %rax
je 0x34da1
cmpb $0x0, 0x39(%rax)
jne 0x34dfe
movq %r14, %rdi
movl %ebp, %esi
movl $0xa, %edx
callq 0x1299a
testb %al, %al
je 0x34dfe
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x345e6
movq %r14, %rdi
movl %ebp, %esi
callq 0x12aba
movq (%r14), %r8
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq *0x100(%r8)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34e0b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x34e0b
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x345e6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34e35
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ba12
testq %rax, %rax
je 0x34e63
cmpb $0x0, 0x39(%rax)
jne 0x34ec0
movq %r14, %rdi
movl %ebp, %esi
movl $0xa, %edx
callq 0x1299a
testb %al, %al
je 0x34ec0
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x345e6
movq %r14, %rdi
movl %ebp, %esi
callq 0x12aba
movq (%r14), %r8
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq *0x100(%r8)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34ecd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x34ecd
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x34d0e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34ef7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x34d0e
movq %r14, %rdi
movl %ebp, %esi
movl $0xa, %edx
callq 0x1299a
testb %al, %al
je 0x34f53
leaq 0x8ede4(%rip), %rdx     # 0xc3d1c
leaq 0x89bf7(%rip), %r8      # 0xbeb36
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
callq 0x53777
jmp 0x34f78
movl 0x4(%rsp), %esi
callq 0x3336a
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x868ee(%rip), %rdx     # 0xbb859
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x53822
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34f93
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x34fa1
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34fbf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x4(%rsp)
callq 0x39b7c
testb %al, %al
je 0x35019
leaq 0x6e8(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0x22474
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
cmpl $0x2, %ecx
jb 0x35019
leaq 0x228(%rbx), %rdi
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x4(%rsp), %rsi
callq 0x1fc02
movb $0x1, 0x1d0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa426
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x35152
movq %rbx, %rdi
movl $0x28, %esi
callq 0x6230
movl 0xc(%r14), %esi
movq %r15, %rdi
callq 0xa426
movq %rax, %r12
movq 0x70(%rax), %rax
subq 0x68(%r12), %rax
shrq $0x2, %rax
testl %eax, %eax
je 0x350e9
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
testl %ebp, %ebp
je 0x35097
movq %rbx, %rdi
leaq 0x86029(%rip), %rsi     # 0xbb0bb
callq 0x64e0
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x4223a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x350d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
incl %ebp
movq 0x70(%r12), %rax
subq 0x68(%r12), %rax
shrq $0x2, %rax
cmpl %eax, %ebp
jb 0x35084
movq %rbx, %rdi
movl $0x29, %esi
callq 0x6230
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3510e
jmp 0x3510e
jmp 0x3510e
movq %rax, %r14
jmp 0x35132
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x35132
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x35149
movq (%rbx), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12aba
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 0x369f6
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x345e6
leaq 0x8d2df(%rip), %rdx     # 0xc3ca1
leaq 0x8505c(%rip), %r8      # 0xbba25
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x53b79
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36a03
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x36a03
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x34d0e
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36a1e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36a50
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36a53
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x36a53
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36a6e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movl %edx, %ecx
movl %esi, %r10d
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x4(%rsp)
testl %r8d, %r8d
je 0x39c7f
movl %ecx, %eax
movq 0x228(%rbx), %rdi
movq 0x230(%rbx), %r8
xorl %r15d, %r15d
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x39c6c
movq (%rax), %r11
movq %rax, %r15
cmpl %ecx, 0x8(%r11)
je 0x39c6c
movq %rdx, %rsi
movq %r11, %r12
movq (%r11), %r11
testq %r11, %r11
je 0x39c69
movl 0x8(%r11), %edi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r15d
cmpq %rsi, %rdx
jne 0x39c6c
movq %r12, %r15
cmpl %ecx, %edi
jne 0x39c3e
jmp 0x39c6c
xorl %r15d, %r15d
testq %r15, %r15
je 0x39d15
cmpq $0x0, (%r15)
je 0x39d15
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %r10d, %edx
callq 0x397d8
leaq 0x85e50(%rip), %rcx     # 0xbfae9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x542b8
leaq 0x20(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x39cc2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x4(%rsp), %ebp
movq (%rbx), %rax
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl $0x1, %ecx
callq *0x38(%rax)
leaq 0xb(%rsp), %r8
movb $0x1, (%r8)
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x54412
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x39d53
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x39d53
testb %r9b, %r9b
jne 0x39d33
leaq 0x260(%rbx), %rdi
leaq 0x10(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x4(%rsp), %rsi
callq 0x1fc02
movl 0x4(%rsp), %esi
leaq 0x10(%rsp), %r8
movb $0x1, (%r8)
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x54270
movq %rax, %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
jne 0x39d83
jmp 0x39d90
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39d90
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39e96
testb %al, %al
je 0x39f0a
movq %r14, %rdi
movl %ebx, %esi
callq 0x39e96
movl %eax, %r13d
jmp 0x39f0d
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x34e3e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x34e3e
leaq 0x7b97b(%rip), %rdx     # 0xb58ae
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rsp, %rcx
leaq 0x8(%rsp), %r9
movq %rdx, %r8
callq 0x544e5
movzbl %r13b, %r8d
leaq 0x48(%rsp), %rcx
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x39bea
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39f81
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39f9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39fb7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x164e0
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x164e0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a002
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3a002
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a022
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3a022
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a03d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %r8, %r12
movl %ecx, %ebx
movl %edx, (%rsp)
movq %rdi, %r14
movl %esi, 0x4(%rsp)
callq 0xa426
movq %rax, %r13
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x35152
movq %r15, %rdi
movl $0x28, %esi
callq 0x6230
cmpl $0x0, 0x14(%r13)
je 0x3a100
xorl %ebp, %ebp
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x64e0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %ebp, %ecx
callq 0x34f00
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x60b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a0e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
incl %ebp
cmpl 0x14(%r13), %ebp
jae 0x3a0fa
movq %r15, %rdi
leaq 0x80fc6(%rip), %rsi     # 0xbb0bb
callq 0x64e0
cmpl 0x14(%r13), %ebp
jb 0x3a099
leaq 0x28(%rsp), %rdi
movl $0x29, %esi
callq 0x6230
movq %r14, %rdi
movl %ebx, %esi
callq 0x39e96
movzbl %al, %r8d
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
xorl %r9d, %r9d
callq 0x39bea
movq %r14, %rdi
movl (%rsp), %esi
movl %ebx, %edx
callq 0x164e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a15c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a190
jmp 0x3a190
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a193
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3a193
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a1ae
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39e96
testb %al, %al
je 0x3a8db
movq %r14, %rdi
movl %ebx, %esi
callq 0x39e96
movl %eax, %r13d
jmp 0x3a8de
xorl %r13d, %r13d
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x34d7c
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x34d7c
leaq 0x81121(%rip), %rax     # 0xbba25
movq %rax, (%rsp)
leaq 0x89392(%rip), %rdx     # 0xc3ca1
leaq 0x807a5(%rip), %r8      # 0xbb0bb
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rcx
leaq 0x18(%rsp), %r9
callq 0x54709
movzbl %r13b, %r8d
leaq 0x58(%rsp), %rcx
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x39bea
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a963
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a97e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a999
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x164e0
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x164e0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a9e4
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3a9e4
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3aa04
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3aa04
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3aa1f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
callq 0x16254
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 0x3b334
testb %bl, %bl
jne 0x3b334
movq %r14, %rdi
movl %ebp, %esi
callq 0x54a30
testq %rax, %rax
je 0x3b341
movss 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3b341
jp 0x3b341
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7dfc2(%rip), %rsi     # 0xb9320
leaq 0x7dff6(%rip), %rdx     # 0xb935b
leaq 0x8(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xc1a12(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xc19ea(%rip), %rsi     # 0xfcd80
movq 0xc2c3b(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3b3c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3b3c7
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3b3d4
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c56d
movq 0x1d8(%rbx), %rax
cmpq 0x1e0(%rbx), %rax
je 0x3c5bc
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x3be3c
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r13, %rcx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x39bea
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c629
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3c629
movq %rbx, %rdi
movl %r14d, %esi
callq 0xa426
movl 0x4(%rsp), %ecx
movq (%rbx), %r8
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq *0x98(%r8)
movq (%r13), %r9
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %r12d, %ecx
movl %r15d, %r8d
callq 0x3a8a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c615
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
addq $0x260, %rbx            # imm = 0x260
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f038
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c63a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c658
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, 0xc(%rsp)
movl %esi, %eax
movq 0x260(%rdi), %r8
movq 0x268(%rdi), %r9
xorl %r11d, %r11d
xorl %edx, %edx
divq %r9
movq (%r8,%rdx,8), %rax
testq %rax, %rax
je 0x3cede
movq (%rax), %r10
movq %rax, %r11
cmpl %esi, 0x8(%r10)
je 0x3cede
movq %rdx, %rcx
movq %r10, %rbx
movq (%r10), %r10
testq %r10, %r10
je 0x3cedb
movl 0x8(%r10), %r8d
movq %r8, %rax
xorl %edx, %edx
divq %r9
movl $0x0, %r11d
cmpq %rcx, %rdx
jne 0x3cede
movq %rbx, %r11
cmpl %esi, %r8d
jne 0x3ceaf
jmp 0x3cede
xorl %r11d, %r11d
testq %r11, %r11
je 0x3cf28
cmpq $0x0, (%r11)
je 0x3cf28
movq 0x410(%rdi), %rdi
testq %rdi, %rdi
je 0x3cf2e
movq 0xf0(%rdi), %rax
cmpq 0xf8(%rdi), %rax
je 0x3cf14
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0xf0(%rdi)
jmp 0x3cf28
addq $0xe8, %rdi
leaq 0xc(%rsp), %rdx
movq %rax, %rsi
callq 0x7a00
addq $0x10, %rsp
popq %rbx
retq
leaq 0x7dd4e(%rip), %rdi     # 0xbac83
leaq 0x7ae1c(%rip), %rsi     # 0xb7d58
leaq 0x7dd57(%rip), %rcx     # 0xbac9a
movl $0x182b, %edx           # imm = 0x182B
callq 0x61b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::bitcast_expression(spirv_cross::SPIRType const&, spirv_cross::SPIRType::BaseType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string CompilerGLSL::bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type,
                                             const std::string &expr)
{
	if (target_type.basetype == expr_type)
		return expr;

	auto src_type = target_type;
	src_type.basetype = expr_type;
	return join(bitcast_glsl_op(target_type, src_type), "(", expr, ")");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %r14
movq %rdi, %rbx
cmpl %ecx, 0xc(%rdx)
jne 0x3e412
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe480
jmp 0x3e4fd
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x1f216
movl %ebp, 0xc(%r13)
movq (%r12), %rax
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *0x168(%rax)
leaq 0x85856(%rip), %rdx     # 0xc3ca1
leaq 0x7d5d3(%rip), %r8      # 0xbba25
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x52f43
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e47b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0xbef2e(%rip), %rax     # 0xfd3b0
addq $0x10, %rax
leaq 0xc0(%rsp), %r14
movq %rax, -0xa0(%r14)
movq %r14, %rdi
callq 0xdeb6
movq -0x38(%r14), %rdi
testq %rdi, %rdi
je 0x3e4b6
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x3e4e6
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0x58(%rsp)
movl %eax, 0x60(%rsp)
movq %rax, 0x68(%rsp)
movl %eax, 0x70(%rsp)
movq %rax, 0x78(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3e4fd
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e535
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3e535
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1c438
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::register_call_out_argument(unsigned int)
void CompilerGLSL::register_call_out_argument(uint32_t id)
{
	register_write(id);

	auto *var = maybe_get<SPIRVariable>(id);
	if (var)
		flush_variable_declaration(var->self);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x12e52
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc7f4
testq %rax, %rax
je 0x3f235
movl 0x8(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4434c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_spv_amd_shader_ballot_op(unsigned int, unsigned int, unsigned int, unsigned int const*, unsigned int)
void CompilerGLSL::emit_spv_amd_shader_ballot_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args,
                                                 uint32_t)
{
	require_extension_internal("GL_AMD_shader_ballot");

	enum AMDShaderBallot
	{
		SwizzleInvocationsAMD = 1,
		SwizzleInvocationsMaskedAMD = 2,
		WriteInvocationAMD = 3,
		MbcntAMD = 4
	};

	auto op = static_cast<AMDShaderBallot>(eop);

	switch (op)
	{
	case SwizzleInvocationsAMD:
		emit_binary_func_op(result_type, id, args[0], args[1], "swizzleInvocationsAMD");
		register_control_dependent_expression(id);
		break;

	case SwizzleInvocationsMaskedAMD:
		emit_binary_func_op(result_type, id, args[0], args[1], "swizzleInvocationsMaskedAMD");
		register_control_dependent_expression(id);
		break;

	case WriteInvocationAMD:
		emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "writeInvocationAMD");
		register_control_dependent_expression(id);
		break;

	case MbcntAMD:
		emit_unary_func_op(result_type, id, args[0], "mbcntAMD");
		register_control_dependent_expression(id);
		break;

	default:
		statement("// unimplemented SPV AMD shader ballot op ", eop);
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %ecx, 0x14(%rsp)
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x7a553(%rip), %rsi     # 0xb97bb
leaq 0x7a560(%rip), %rdx     # 0xb97cf
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x7c64
movq %r14, %rdi
movq %r12, %rsi
callq 0x26a0a
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f29e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x14(%rsp), %eax
decl %eax
cmpl $0x3, %eax
ja 0x3f33c
leaq 0x776b8(%rip), %rcx     # 0xb696c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%r15), %ecx
movl 0x4(%r15), %r8d
leaq 0x7a505(%rip), %r9      # 0xb97d0
jmp 0x3f317
movl (%r15), %ecx
movl 0x4(%r15), %r8d
movl 0x8(%r15), %r9d
leaq 0x7a523(%rip), %rax     # 0xb9802
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3ae2a
jmp 0x3f323
movl (%r15), %ecx
leaq 0x7a51a(%rip), %r8      # 0xb9815
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3a790
jmp 0x3f323
movl (%r15), %ecx
movl 0x4(%r15), %r8d
leaq 0x7a4cf(%rip), %r9      # 0xb97e6
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3a8a0
movq %r14, %rdi
movl %ebx, %esi
callq 0x3ce76
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a4db(%rip), %rsi     # 0xb981e
leaq 0x14(%rsp), %rdx
movq %r14, %rdi
callq 0x5580c
jmp 0x3f32d
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f36c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_spv_amd_shader_explicit_vertex_parameter_op(unsigned int, unsigned int, unsigned int, unsigned int const*, unsigned int)
void CompilerGLSL::emit_spv_amd_shader_explicit_vertex_parameter_op(uint32_t result_type, uint32_t id, uint32_t eop,
                                                                    const uint32_t *args, uint32_t)
{
	require_extension_internal("GL_AMD_shader_explicit_vertex_parameter");

	enum AMDShaderExplicitVertexParameter
	{
		InterpolateAtVertexAMD = 1
	};

	auto op = static_cast<AMDShaderExplicitVertexParameter>(eop);

	switch (op)
	{
	case InterpolateAtVertexAMD:
		emit_binary_func_op(result_type, id, args[0], args[1], "interpolateAtVertexAMD");
		break;

	default:
		statement("// unimplemented SPV AMD shader explicit vertex parameter op ", eop);
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %ecx, 0x4(%rsp)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x7a4a8(%rip), %rsi     # 0xb9849
leaq 0x7a4c8(%rip), %rdx     # 0xb9870
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7c64
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26a0a
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f3d7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
cmpl $0x1, 0x4(%rsp)
jne 0x3f3fb
movl (%r15), %ecx
movl 0x4(%r15), %r8d
leaq 0x7a485(%rip), %r9      # 0xb9871
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x3a8a0
jmp 0x3f40f
leaq 0x7a486(%rip), %rsi     # 0xb9888
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x55930
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f438
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_spv_amd_shader_trinary_minmax_op(unsigned int, unsigned int, unsigned int, unsigned int const*, unsigned int)
void CompilerGLSL::emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t id, uint32_t eop,
                                                         const uint32_t *args, uint32_t)
{
	require_extension_internal("GL_AMD_shader_trinary_minmax");

	enum AMDShaderTrinaryMinMax
	{
		FMin3AMD = 1,
		UMin3AMD = 2,
		SMin3AMD = 3,
		FMax3AMD = 4,
		UMax3AMD = 5,
		SMax3AMD = 6,
		FMid3AMD = 7,
		UMid3AMD = 8,
		SMid3AMD = 9
	};

	auto op = static_cast<AMDShaderTrinaryMinMax>(eop);

	switch (op)
	{
	case FMin3AMD:
	case UMin3AMD:
	case SMin3AMD:
		emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "min3");
		break;

	case FMax3AMD:
	case UMax3AMD:
	case SMax3AMD:
		emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "max3");
		break;

	case FMid3AMD:
	case UMid3AMD:
	case SMid3AMD:
		emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "mid3");
		break;

	default:
		statement("// unimplemented SPV AMD shader trinary minmax op ", eop);
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %ecx, 0x14(%rsp)
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x7a45a(%rip), %rsi     # 0xb98c6
leaq 0x7a46f(%rip), %rdx     # 0xb98e2
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x7c64
movq %r14, %rdi
movq %r12, %rsi
callq 0x26a0a
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f4a2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x14(%rsp), %eax
cmpl $0x9, %eax
ja 0x3f522
movl $0xe, %ecx
btl %eax, %ecx
jb 0x3f4dd
movl $0x70, %ecx
btl %eax, %ecx
jb 0x3f4f1
movl $0x380, %ecx            # imm = 0x380
btl %eax, %ecx
jae 0x3f522
movl (%r15), %ecx
movl 0x4(%r15), %r8d
movl 0x8(%r15), %r9d
leaq 0x7a412(%rip), %rax     # 0xb98ed
jmp 0x3f503
movl (%r15), %ecx
movl 0x4(%r15), %r8d
movl 0x8(%r15), %r9d
leaq 0x7a3f4(%rip), %rax     # 0xb98e3
jmp 0x3f503
movl (%r15), %ecx
movl 0x4(%r15), %r8d
movl 0x8(%r15), %r9d
leaq 0x7a3e5(%rip), %rax     # 0xb98e8
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3ae2a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a3c9(%rip), %rsi     # 0xb98f2
leaq 0x14(%rsp), %rdx
movq %r14, %rdi
callq 0x55a54
jmp 0x3f513
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f552
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_spv_amd_gcn_shader_op(unsigned int, unsigned int, unsigned int, unsigned int const*, unsigned int)
void CompilerGLSL::emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args,
                                              uint32_t)
{
	require_extension_internal("GL_AMD_gcn_shader");

	enum AMDGCNShader
	{
		CubeFaceIndexAMD = 1,
		CubeFaceCoordAMD = 2,
		TimeAMD = 3
	};

	auto op = static_cast<AMDGCNShader>(eop);

	switch (op)
	{
	case CubeFaceIndexAMD:
		emit_unary_func_op(result_type, id, args[0], "cubeFaceIndexAMD");
		break;
	case CubeFaceCoordAMD:
		emit_unary_func_op(result_type, id, args[0], "cubeFaceCoordAMD");
		break;
	case TimeAMD:
	{
		string expr = "timeAMD()";
		emit_op(result_type, id, expr, true);
		register_control_dependent_expression(id);
		break;
	}

	default:
		statement("// unimplemented SPV AMD gcn shader op ", eop);
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r8, %r15
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %ecx, 0xc(%rsp)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7a3a0(%rip), %rsi     # 0xb9925
leaq 0x7a3aa(%rip), %rdx     # 0xb9936
leaq 0x10(%rsp), %rdi
callq 0x7c64
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x26a0a
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f5ba
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0xc(%rsp), %eax
cmpl $0x1, %eax
je 0x3f631
cmpl $0x2, %eax
je 0x3f625
cmpl $0x3, %eax
jne 0x3f649
leaq 0x10(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x7a37d(%rip), %rsi     # 0xb9959
leaq 0x7a37f(%rip), %rdx     # 0xb9962
callq 0x7c64
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x39bea
movq %r14, %rdi
movl %ebx, %esi
callq 0x3ce76
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f65d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3f65d
movl (%r15), %ecx
leaq 0x7a319(%rip), %r8      # 0xb9948
jmp 0x3f63b
movl (%r15), %ecx
leaq 0x7a2fc(%rip), %r8      # 0xb9937
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3a790
jmp 0x3f65d
leaq 0x7a313(%rip), %rsi     # 0xb9963
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x55b78
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f68a
jmp 0x3f66e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f68d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x3f68d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x64a0
nop