LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x9(%rbp)
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf970
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf9a0
testb $0x1, %al
jne 0x7199a
jmp 0x71aa8
leaq -0x20(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xfa00
cmpl $0xd, %eax
je 0x719ba
jmp 0x71a66
movq -0x30(%rbp), %rdi
callq 0xa0db0
movq -0x90(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq -0x90(%rbp), %rsi
movq %rax, -0xa0(%rbp)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x1, %ecx
callq *%rax
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
movl 0x8(%rax), %r8d
movq (%rsi), %rax
movq 0xc8(%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0x71a37
movq -0x90(%rbp), %rdi
leaq 0xd7661(%rip), %rdx     # 0x1490a6
leaq -0x58(%rbp), %rsi
callq 0xf270
jmp 0x71a50
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x78(%rbp), %rdi
callq 0x7708
movb $0x1, -0x9(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xfbd0
jmp 0x71984
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x71a9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x78(%rbp), %rdi
callq 0x7708
jmp 0x71aca
testb $0x1, -0x9(%rbp)
je 0x71ac1
movq -0x90(%rbp), %rdi
leaq 0xccde2(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_func_call_arg[abi:cxx11](unsigned int)
string CompilerGLSL::to_func_call_arg(uint32_t id)
{
	// Make sure that we use the name of the original variable, and not the parameter alias.
	uint32_t name_id = id;
	auto *var = maybe_get<SPIRVariable>(id);
	if (var && var->basevariable)
		name_id = var->basevariable;
	return to_expression(name_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %esi
callq 0x116b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x71b33
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x71b33
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %edx
callq 0x71b50
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::strip_enclosed_expression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CompilerGLSL::strip_enclosed_expression(string &expr)
{
	if (expr.size() < 2 || expr.front() != '(' || expr.back() != ')')
		return;

	// Have to make sure that our first and last parens actually enclose everything inside it.
	uint32_t paren_count = 0;
	for (auto &c : expr)
	{
		if (c == '(')
			paren_count++;
		else if (c == ')')
		{
			paren_count--;

			// If we hit 0 and this is not the final char, our first and final parens actually don't
			// enclose the expression, and we cannot strip, e.g.: (a + b) * (c + d).
			if (paren_count == 0 && &c != &expr.back())
				return;
		}
	}
	expr.erase(expr.size() - 1, 1);
	expr.erase(begin(expr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7290
cmpq $0x2, %rax
jb 0x72511
movq -0x10(%rbp), %rdi
callq 0x70e0
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x72511
movq -0x10(%rbp), %rdi
callq 0x72b0
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x72516
jmp 0x7261d
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x72f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7200
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa1200
testb $0x1, %al
jne 0x72552
jmp 0x725c4
leaq -0x28(%rbp), %rdi
callq 0xa1240
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x72576
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x725b4
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0x725b2
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x725b0
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x72b0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0x725b0
jmp 0x7261d
jmp 0x725b2
jmp 0x725b4
jmp 0x725b6
leaq -0x28(%rbp), %rdi
callq 0xa1260
jmp 0x7253f
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7290
movq -0x68(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
movl $0x1, %edx
callq 0x70a0
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa1280
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa12b0
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7440
movq %rax, -0x50(%rbp)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl -0x14(%rbp), %esi
callq 0x2e790
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x55(%rbp)
je 0x726fb
movq -0x20(%rbp), %rax
movb 0x39(%rax), %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x72782
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0xa, %edx
callq 0x1f560
testb $0x1, %al
jne 0x72720
jmp 0x72782
movq -0x60(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x71b50
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f760
movq %rax, -0x78(%rbp)
jmp 0x72742
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq (%rsi), %rax
movq 0x100(%rax), %rax
leaq -0x48(%rbp), %rdx
callq *%rax
jmp 0x72760
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x72792
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x7279f
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x71b50
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl -0x14(%rbp), %esi
callq 0x2e790
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x55(%rbp)
je 0x727fb
movq -0x20(%rbp), %rax
movb 0x39(%rax), %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x72882
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0xa, %edx
callq 0x1f560
testb $0x1, %al
jne 0x72820
jmp 0x72882
movq -0x60(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x71b50
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f760
movq %rax, -0x78(%rbp)
jmp 0x72842
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq (%rsi), %rax
movq 0x100(%rax), %rax
leaq -0x48(%rbp), %rdx
callq *%rax
jmp 0x72860
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x72892
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x7289f
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x72630
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
callq 0x72630
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0xa, %edx
callq 0x1f560
movb %al, -0x51(%rbp)
jmp 0x728fe
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x72907
jmp 0x72948
movq -0x70(%rbp), %rdi
leaq 0xdaa96(%rip), %rdx     # 0x14d3a8
leaq 0xd578c(%rip), %r8      # 0x1480a5
leaq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rcx
callq 0xa13b0
jmp 0x72928
movl $0x1, -0x48(%rbp)
jmp 0x72983
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7708
jmp 0x72999
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x70100
movq %rax, -0x78(%rbp)
jmp 0x7295a
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xd23c0(%rip), %rdx     # 0x144d2d
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rcx
callq 0xa1470
jmp 0x7297c
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7708
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x78490
testb $0x1, %al
jne 0x729d5
jmp 0x72a2c
movq -0x30(%rbp), %rdi
addq $0x6e8, %rdi            # imm = 0x6E8
leaq -0xc(%rbp), %rsi
callq 0x30850
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jb 0x72a2a
movq -0x30(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
leaq -0xc(%rbp), %rsi
callq 0x2e890
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movb %dl, -0x20(%rbp)
movb $0x1, 0x1d0(%rax)
jmp 0x72a2c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq %rax, %rdx
callq 0x72bf0
movq -0x68(%rbp), %rdi
movl $0x28, %esi
callq 0x7220
jmp 0x72a9a
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x80(%rbp)
jmp 0x72ab0
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq %rax, %rcx
movl -0x84(%rbp), %eax
cmpl %ecx, %eax
jae 0x72b60
cmpl $0x0, -0x3c(%rbp)
je 0x72b0d
movq -0x68(%rbp), %rdi
leaq 0xd1a9c(%rip), %rsi     # 0x14458f
callq 0x7340
jmp 0x72afa
jmp 0x72b0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x72b90
movq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x3c(%rbp), %ecx
leaq -0x60(%rbp), %rdi
callq 0x85e40
jmp 0x72b23
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7470
jmp 0x72b32
leaq -0x60(%rbp), %rdi
callq 0x7708
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x72abf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7708
jmp 0x72b90
movq -0x68(%rbp), %rdi
movl $0x29, %esi
callq 0x7220
jmp 0x72b70
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x72b83
movq -0x68(%rbp), %rdi
callq 0x7708
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7708
movq -0x28(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: is_unsigned_opcode(spv::Op)
static bool is_unsigned_opcode(Op op)
{
	// Don't have to be exhaustive, only relevant for legacy target checking ...
	switch (op)
	{
	case OpShiftRightLogical:
	case OpUGreaterThan:
	case OpUGreaterThanEqual:
	case OpULessThan:
	case OpULessThanEqual:
	case OpUConvert:
	case OpUDiv:
	case OpUMod:
	case OpUMulExtended:
	case OpConvertUToF:
	case OpConvertFToU:
		return true;

	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x6d, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x55, %eax
ja 0x72be2
movq -0x10(%rbp), %rax
leaq 0xcd631(%rip), %rcx     # 0x140204
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x72be6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: glsl_opcode_is_sign_invariant(spv::Op)
static bool glsl_opcode_is_sign_invariant(Op opcode)
{
	switch (opcode)
	{
	case OpIEqual:
	case OpINotEqual:
	case OpISub:
	case OpIAdd:
	case OpIMul:
	case OpShiftLeftLogical:
	case OpBitwiseOr:
	case OpBitwiseXor:
	case OpBitwiseAnd:
		return true;

	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x80, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x47, %eax
ja 0x74792
movq -0x10(%rbp), %rax
leaq 0xcbbf9(%rip), %rcx     # 0x14037c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x74796
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x1c(%rbp), %esi
callq 0x1f760
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x168(%rax)
leaq -0x40(%rbp), %rdi
callq 0x75f0
testb $0x1, %al
jne 0x74a5a
jmp 0x74a86
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdi
movl -0x1c(%rbp), %edx
callq 0x72630
jmp 0x74a6f
movl $0x1, -0x50(%rbp)
jmp 0x74ae5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x74afe
movq -0x80(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x70(%rbp), %rdi
callq 0x71b50
jmp 0x74a98
movq -0x90(%rbp), %rdi
leaq 0xd8887(%rip), %rdx     # 0x14d32d
leaq 0xd044c(%rip), %r8      # 0x144ef9
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rcx
callq 0xa1880
jmp 0x74abc
leaq -0x70(%rbp), %rdi
callq 0x7708
movl $0x1, -0x50(%rbp)
jmp 0x74ae5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7708
jmp 0x74afe
leaq -0x40(%rbp), %rdi
callq 0x7708
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x7708
movq -0x48(%rbp), %rdi
callq 0x7640
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::should_forward(unsigned int)
bool CompilerGLSL::should_forward(uint32_t id)
{
	// Immutable expression can always be forwarded.
	// If not immutable, we can speculate about it by forwarding potentially mutable variables.
	auto *var = maybe_get<SPIRVariable>(id);
	bool forward = var ? var->forwardable : false;
	return (is_immutable(id) || forward) && !options.force_temporary;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x78846
movq -0x18(%rbp), %rax
movb 0x58(%rax), %al
movb %al, -0x29(%rbp)
jmp 0x7884d
xorl %eax, %eax
movb %al, -0x29(%rbp)
jmp 0x7884d
movq -0x28(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movl -0xc(%rbp), %esi
callq 0x1fbd0
testb $0x1, %al
jne 0x78870
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x2a(%rbp)
je 0x7887f
movq -0x28(%rbp), %rax
movb 0x43d(%rax), %al
xorb $-0x1, %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl -0x14(%rbp), %esi
callq 0x78810
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x95(%rbp)
jne 0x788d4
jmp 0x788e9
movq -0xa0(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x78810
movb %al, -0x95(%rbp)
movq -0xa0(%rbp), %rsi
movb -0x95(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa8(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0x14(%rbp), %edx
leaq -0x68(%rbp), %rdi
callq 0x727b0
movq -0xa0(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x88(%rbp), %rdi
callq 0x727b0
jmp 0x78931
leaq 0xc5f65(%rip), %r8      # 0x13e89d
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x20(%rbp), %rcx
leaq -0x88(%rbp), %r9
movq %r8, %rdx
callq 0xa2890
jmp 0x78955
movl -0xa4(%rbp), %edx
movl -0xa8(%rbp), %esi
movq -0xa0(%rbp), %rdi
movzbl -0x21(%rbp), %r8d
andl $0x1, %r8d
leaq -0x48(%rbp), %rcx
xorl %r9d, %r9d
callq 0x784f0
jmp 0x7897f
leaq -0x48(%rbp), %rdi
callq 0x7708
leaq -0x88(%rbp), %rdi
callq 0x7708
leaq -0x68(%rbp), %rdi
callq 0x7708
movq -0xa0(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x25500
movq -0xa0(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x25500
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x78a19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x78a0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
leaq -0x88(%rbp), %rdi
callq 0x7708
leaq -0x68(%rbp), %rdi
callq 0x7708
movq -0x90(%rbp), %rdi
callq 0x7640
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl -0xc(%rbp), %esi
callq 0xea90
movq -0x88(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x72bf0
movq -0x80(%rbp), %rdi
movl $0x28, %esi
callq 0x7220
jmp 0x78a8b
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x78b3f
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7340
jmp 0x78ab1
movq -0x88(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x58(%rbp), %ecx
leaq -0x78(%rbp), %rdi
callq 0x728b0
jmp 0x78ac9
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x7470
jmp 0x78ad8
leaq -0x78(%rbp), %rdi
callq 0x7708
movl -0x58(%rbp), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x78b2f
leaq 0xcba98(%rip), %rsi     # 0x14458f
leaq -0x48(%rbp), %rdi
callq 0x7340
jmp 0x78b02
jmp 0x78b2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x78bcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x7708
jmp 0x78bcd
jmp 0x78b31
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x78a92
leaq -0x48(%rbp), %rdi
movl $0x29, %esi
callq 0x7220
jmp 0x78b4f
movq -0x88(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x94(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x14(%rbp), %esi
callq 0x78810
movb %al, -0x89(%rbp)
jmp 0x78b78
movl -0x90(%rbp), %edx
movl -0x94(%rbp), %esi
movq -0x88(%rbp), %rdi
movb -0x89(%rbp), %al
movzbl %al, %r8d
andl $0x1, %r8d
leaq -0x48(%rbp), %rcx
xorl %r9d, %r9d
callq 0x784f0
jmp 0x78ba7
movq -0x88(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x25500
jmp 0x78bbb
leaq -0x48(%rbp), %rdi
callq 0x7708
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x7708
movq -0x50(%rbp), %rdi
callq 0x7640
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl -0x14(%rbp), %esi
callq 0x78810
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x95(%rbp)
jne 0x79374
jmp 0x79389
movq -0xa0(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x78810
movb %al, -0x95(%rbp)
movq -0xa0(%rbp), %rsi
movb -0x95(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa8(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0x14(%rbp), %edx
leaq -0x68(%rbp), %rdi
callq 0x726b0
movq -0xa0(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x88(%rbp), %rdi
callq 0x726b0
jmp 0x793d1
leaq 0xcbb21(%rip), %rcx     # 0x144ef9
movq %rsp, %rax
movq %rcx, (%rax)
leaq 0xd3f48(%rip), %rdx     # 0x14d32d
leaq 0xcb1a3(%rip), %r8      # 0x14458f
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rcx
leaq -0x88(%rbp), %r9
callq 0xa2af0
jmp 0x79406
movl -0xa4(%rbp), %edx
movl -0xa8(%rbp), %esi
movq -0xa0(%rbp), %rdi
movzbl -0x21(%rbp), %r8d
andl $0x1, %r8d
leaq -0x48(%rbp), %rcx
xorl %r9d, %r9d
callq 0x784f0
jmp 0x79430
leaq -0x48(%rbp), %rdi
callq 0x7708
leaq -0x88(%rbp), %rdi
callq 0x7708
leaq -0x68(%rbp), %rdi
callq 0x7708
movq -0xa0(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x25500
movq -0xa0(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x25500
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x794ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x794be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
leaq -0x88(%rbp), %rdi
callq 0x7708
leaq -0x68(%rbp), %rdi
callq 0x7708
movq -0x90(%rbp), %rdi
callq 0x7640
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x25150
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0xa0800
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x5e(%rbp)
jne 0x79dea
jmp 0x79dfb
movq -0x18(%rbp), %rax
cmpl $0x4, 0xb8(%rax)
sete %al
movb %al, -0x5e(%rbp)
movb -0x5e(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x79eec
cmpl $0x0, -0xc(%rbp)
je 0x79eec
movq -0x68(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xa2eb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x79e4a
movq -0x28(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xa1ea0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x79e4a
jp 0x79e4a
jmp 0x79eea
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7650
movq -0x70(%rbp), %rdx
leaq 0xc8980(%rip), %rsi     # 0x1427f4
leaq -0x48(%rbp), %rdi
callq 0x7520
jmp 0x79e7f
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9c50
jmp 0x79e8e
movq -0x78(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0x133f3b(%rip), %rsi    # 0x1addd8
leaq -0x70214(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x79f03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x79ece
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
leaq -0x49(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x5d(%rbp)
jne 0x79edf
jmp 0x79ee8
movq -0x78(%rbp), %rdi
callq 0x72c0
jmp 0x79efa
jmp 0x79eec
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0x43e(%rax)
je 0x7bb5c
movq -0x70(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0xa10a0
testb $0x1, %al
jne 0x7baba
jmp 0x7bb5c
movq -0x70(%rbp), %rdi
movl -0xc(%rbp), %esi
movl %esi, -0x80(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x74(%rbp)
callq 0xea90
movq -0x70(%rbp), %rsi
movq %rax, %rdx
movl -0x10(%rbp), %ecx
movq (%rsi), %rax
movq 0x98(%rax), %rax
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq *%rax
movq -0x88(%rbp), %rdi
callq 0x7160
movq -0x70(%rbp), %rdi
movl -0x80(%rbp), %esi
movl -0x7c(%rbp), %edx
movl -0x78(%rbp), %ecx
movl -0x74(%rbp), %r8d
movq %rax, %r9
callq 0x79330
jmp 0x7bb23
leaq -0x38(%rbp), %rdi
callq 0x7708
movq -0x70(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
leaq -0x10(%rbp), %rsi
callq 0x3ceb0
jmp 0x7bbd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7708
jmp 0x7bbda
movq -0x70(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, -0x98(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x94(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7afa0
movq -0x70(%rbp), %rdi
movl -0x98(%rbp), %esi
movl -0x94(%rbp), %edx
movq -0x90(%rbp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x784f0
jmp 0x7bbaf
leaq -0x68(%rbp), %rdi
callq 0x7708
jmp 0x7bbd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7708
jmp 0x7bbda
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x260, %rdi            # imm = 0x260
leaq -0xc(%rbp), %rsi
callq 0x2ff00
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x260, %rdi            # imm = 0x260
callq 0x2ff30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2eb30
testb $0x1, %al
jne 0x7c642
jmp 0x7c644
jmp 0x7c68e
movq -0x28(%rbp), %rax
cmpq $0x0, 0x410(%rax)
je 0x7c654
jmp 0x7c673
leaq 0xc7afc(%rip), %rdi     # 0x144157
leaq 0xc4bca(%rip), %rsi     # 0x14122c
movl $0x182b, %edx           # imm = 0x182B
leaq 0xc7b00(%rip), %rcx     # 0x14416e
callq 0x7260
movq -0x28(%rbp), %rax
movq 0x410(%rax), %rdi
addq $0xe8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x88f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x148(%rbp)
movq %rdi, %rax
movq %rax, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x7e02b
movq -0x148(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7170
jmp 0x7e0f3
movq -0x18(%rbp), %rsi
leaq -0x100(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x3d730
movq -0x138(%rbp), %rsi
movq -0x150(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl %eax, -0xf4(%rbp)
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x168(%rax), %rax
leaq -0x120(%rbp), %rdi
callq *%rax
jmp 0x7e072
movq -0x148(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq 0xcf2a9(%rip), %rdx     # 0x14d32d
leaq 0xc6e6e(%rip), %r8      # 0x144ef9
leaq -0x120(%rbp), %rsi
callq 0xa0840
jmp 0x7e099
leaq -0x120(%rbp), %rdi
callq 0x7708
leaq -0x100(%rbp), %rdi
callq 0x314e0
jmp 0x7e0f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0x7e0e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x7708
leaq -0x100(%rbp), %rdi
callq 0x314e0
jmp 0x7e103
movq -0x140(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x128(%rbp), %rdi
callq 0x7640
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: is_unsigned_glsl_opcode(GLSLstd450)
static bool is_unsigned_glsl_opcode(GLSLstd450 op)
{
	// Don't have to be exhaustive, only relevant for legacy target checking ...
	switch (op)
	{
	case GLSLstd450UClamp:
	case GLSLstd450UMin:
	case GLSLstd450UMax:
	case GLSLstd450FindUMsb:
		return true;

	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x26, %eax
je 0x7f652
jmp 0x7f634
movl -0xc(%rbp), %eax
subl $0x29, %eax
je 0x7f652
jmp 0x7f63e
movl -0xc(%rbp), %eax
subl $0x2c, %eax
je 0x7f652
jmp 0x7f648
movl -0xc(%rbp), %eax
subl $0x4b, %eax
jne 0x7f658
jmp 0x7f652
movb $0x1, -0x1(%rbp)
jmp 0x7f65c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
callq 0x1fd60
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7f6b6
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x88710
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7650
movq -0x68(%rbp), %rdx
leaq 0xc3460(%rip), %rsi     # 0x142d1d
leaq -0x48(%rbp), %rdi
callq 0x7520
jmp 0x7f8c8
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x589d0
jmp 0x7f8d7
leaq -0x48(%rbp), %rdi
callq 0x7708
leaq -0x49(%rbp), %rdi
callq 0x73d0
movl -0x14(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
subl $0x1, %eax
je 0x7f927
jmp 0x7f94d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7f91c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
leaq -0x49(%rbp), %rdi
callq 0x73d0
jmp 0x7f967
movq -0x70(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %r8d
leaq 0xc33ff(%rip), %r9      # 0x142d45
callq 0x79330
jmp 0x7f961
movq -0x70(%rbp), %rdi
leaq 0xc3404(%rip), %rsi     # 0x142d5c
leaq -0x14(%rbp), %rdx
callq 0xa3f30
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x7640
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::bitcast_expression[abi:cxx11](spirv_cross::SPIRType::BaseType, unsigned int)
std::string CompilerGLSL::bitcast_expression(SPIRType::BaseType target_type, uint32_t arg)
{
	auto expr = to_expression(arg);
	auto &src_type = expression_type(arg);
	if (src_type.basetype != target_type)
	{
		auto target = src_type;
		target.basetype = target_type;
		expr = join(bitcast_glsl_op(target, src_type), "(", expr, ")");
	}

	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x170(%rbp)
movq %rdi, %rax
movq %rax, -0x168(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x160(%rbp)
movb $0x0, -0x19(%rbp)
movl -0x18(%rbp), %edx
callq 0x71b50
movq -0x160(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x1f760
movq %rax, -0x158(%rbp)
jmp 0x82a59
movq -0x158(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x82b5b
movq -0x28(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x3d730
jmp 0x82a86
movq -0x160(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, -0x104(%rbp)
movq -0x28(%rbp), %rcx
movq (%rsi), %rax
movq 0x168(%rax), %rax
leaq -0x150(%rbp), %rdi
leaq -0x110(%rbp), %rdx
callq *%rax
jmp 0x82ab6
movq -0x170(%rbp), %rcx
leaq 0xca869(%rip), %rdx     # 0x14d32d
leaq 0xc242e(%rip), %r8      # 0x144ef9
leaq -0x130(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0xa4290
jmp 0x82ae0
movq -0x170(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x7430
leaq -0x130(%rbp), %rdi
callq 0x7708
leaq -0x150(%rbp), %rdi
callq 0x7708
leaq -0x110(%rbp), %rdi
callq 0x314e0
jmp 0x82b5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x82b81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x82b4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x7708
leaq -0x110(%rbp), %rdi
callq 0x314e0
jmp 0x82b81
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x82b71
movq -0x170(%rbp), %rdi
callq 0x7708
movq -0x168(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x170(%rbp), %rdi
callq 0x7708
movq -0x30(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::variable_decl_function_local[abi:cxx11](spirv_cross::SPIRVariable&)
string CompilerGLSL::variable_decl_function_local(SPIRVariable &var)
{
	// These variables are always function local,
	// so make sure we emit the variable without storage qualifiers.
	// Some backends will inject custom variables locally in a function
	// with a storage qualifier which is not function-local.
	auto old_storage = var.storage;
	var.storage = StorageClassFunction;
	auto expr = variable_decl(var);
	var.storage = old_storage;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x7, 0x10(%rax)
movb $0x0, -0x1d(%rbp)
movq -0x18(%rbp), %rdx
callq 0x62d60
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x876b2
movq -0x30(%rbp), %rdi
callq 0x7708
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::end_scope()
void CompilerGLSL::end_scope()
{
	if (!indent)
		SPIRV_CROSS_THROW("Popping empty indent stack.");
	indent--;
	statement("}");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, 0x638(%rax)
jne 0x87781
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7650
movq -0x50(%rbp), %rdx
leaq 0xbd9b2(%rip), %rsi     # 0x1450bd
leaq -0x28(%rbp), %rdi
callq 0x7520
jmp 0x87716
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9c50
jmp 0x87725
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x1266a4(%rip), %rsi    # 0x1addd8
leaq -0x7daab(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x877af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x87765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7708
leaq -0x29(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x3d(%rbp)
jne 0x87776
jmp 0x8777f
movq -0x58(%rbp), %rdi
callq 0x72c0
jmp 0x877a6
movq -0x48(%rbp), %rdi
movl 0x638(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x638(%rdi)
leaq 0xbaed2(%rip), %rsi     # 0x14266d
callq 0xa9740
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: vector_swizzle(int, int)
static const char *vector_swizzle(int vecsize, int index)
{
	static const char *swizzle[4][4] = {
		{ ".x", ".y", ".z", ".w" }, { ".xy", ".yz", ".zw" }, { ".xyz", ".yzw" }, { "" }
	};

	assert(vecsize >= 1 && vecsize <= 4);
	assert(index >= 0 && index < 4);
	assert(swizzle[vecsize - 1][index]);

	return swizzle[vecsize - 1][index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x4(%rbp)
movb %al, -0x9(%rbp)
jl 0x88383
cmpl $0x4, -0x4(%rbp)
setle %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x8838c
jmp 0x8838e
jmp 0x883ad
leaq 0xbce9a(%rip), %rdi     # 0x14522f
leaq 0xb8e90(%rip), %rsi     # 0x14122c
movl $0x108, %edx            # imm = 0x108
leaq 0xbcea4(%rip), %rcx     # 0x14524c
callq 0x7260
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0xa(%rbp)
jl 0x883c2
cmpl $0x4, -0x8(%rbp)
setl %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0x883cb
jmp 0x883cd
jmp 0x883ec
leaq 0xbce9d(%rip), %rdi     # 0x145271
leaq 0xb8e51(%rip), %rsi     # 0x14122c
movl $0x109, %edx            # imm = 0x109
leaq 0xbce65(%rip), %rcx     # 0x14524c
callq 0x7260
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x126f94(%rip), %rax    # 0x1af390
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x88410
jmp 0x8842f
leaq 0xbce72(%rip), %rdi     # 0x145289
leaq 0xb8e0e(%rip), %rsi     # 0x14122c
movl $0x10a, %edx            # imm = 0x10A
leaq 0xbce22(%rip), %rcx     # 0x14524c
callq 0x7260
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x126f51(%rip), %rax    # 0x1af390
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)