LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_name(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_name(uint32_t id, const string &name)
{
	auto &str = meta[id].decoration.alias;
	str.clear();

	if (name.empty())
		return;

	// glslang uses identifiers to pass along meaningful information
	// about HLSL reflection.
	// FIXME: This should be deprecated eventually.
	auto &m = meta[id];
	if (source.hlsl && name.size() >= 6 && name.find("@count") == name.size() - 6)
	{
		m.hlsl_magic_counter_buffer_candidate = true;
		m.hlsl_magic_counter_buffer_name = name.substr(0, name.find("@count"));
	}
	else
	{
		m.hlsl_magic_counter_buffer_candidate = false;
		m.hlsl_magic_counter_buffer_name.clear();
	}

	// Reserved for temporaries.
	if (name[0] == '_' && name.size() >= 2 && isdigit(name[1]))
		return;

	str = ensure_valid_identifier(name, false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %eax
movq 0x30(%rdi), %rbx
imulq $0x148, %rax, %r13      # imm = 0x148
movq $0x0, 0x8(%rbx,%r13)
movq (%rbx,%r13), %rax
movb $0x0, (%rax)
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x24107
movq %rdx, %r14
movq 0x30(%rdi), %r15
addq %r13, %r15
cmpq $0x6, %rax
jb 0x24097
cmpb $0x0, 0x10a(%rdi)
je 0x24097
leaq 0x91525(%rip), %rsi     # 0xb5540
movl $0x6, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x6490
movq 0x8(%r14), %rcx
addq $-0x6, %rcx
cmpq %rcx, %rax
jne 0x24097
movb $0x1, 0x140(%r15)
leaq 0x914fa(%rip), %rsi     # 0xb5540
movl $0x6, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x6490
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x6290
addq $0x120, %r15            # imm = 0x120
movq %r15, %rdi
movq %r12, %rsi
callq 0x6310
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x240b4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x240b4
xorl %eax, %eax
movb %al, 0x140(%r15)
movq $0x0, 0x128(%r15)
movq 0x120(%r15), %rcx
movb %al, (%rcx)
movq (%r14), %rax
cmpb $0x5f, (%rax)
jne 0x240cf
cmpq $0x2, 0x8(%r14)
jb 0x240cf
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x24107
addq %r13, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x24115
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6310
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x24107
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ensure_valid_identifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
static string ensure_valid_identifier(const string &name, bool member)
{
	// Functions in glslangValidator are mangled with name(<mangled> stuff.
	// Normally, we would never see '(' in any legal identifiers, so just strip them out.
	auto str = name.substr(0, name.find('('));

	for (uint32_t i = 0; i < str.size(); i++)
	{
		auto &c = str[i];

		if (member)
		{
			// _m<num> variables are reserved by the internal implementation,
			// otherwise, make sure the name is a valid identifier.
			if (i == 0)
				c = isalpha(c) ? c : '_';
			else if (i == 2 && str[0] == '_' && str[1] == 'm')
				c = isalpha(c) ? c : '_';
			else
				c = isalnum(c) ? c : '_';
		}
		else
		{
			// _<num> variables are reserved by the internal implementation,
			// otherwise, make sure the name is a valid identifier.
			if (i == 0 || (str[0] == '_' && i == 1))
				c = isalpha(c) ? c : '_';
			else
				c = isalnum(c) ? c : '_';
		}
	}
	return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
movq %rsi, %rdi
movl $0x28, %esi
xorl %edx, %edx
callq 0x6340
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x6290
cmpq $0x0, 0x8(%r14)
je 0x241b8
movq (%r14), %r15
testb %bl, %bl
je 0x24162
cmpl $0x2, %r12d
je 0x24175
testl %r12d, %r12d
je 0x24182
jmp 0x24191
testl %r12d, %r12d
je 0x24182
cmpl $0x1, %r12d
jne 0x24191
cmpb $0x5f, (%r15)
je 0x24182
jmp 0x24191
cmpb $0x5f, (%r15)
jne 0x24191
cmpb $0x6d, 0x1(%r15)
jne 0x24191
movb (%r15,%r12), %bpl
movsbl %bpl, %edi
callq 0x6420
jmp 0x2419e
movb (%r15,%r12), %bpl
movsbl %bpl, %edi
callq 0x6270
movl $0x5f, %ecx
testl %eax, %eax
je 0x241ab
movzbl %bpl, %ecx
movb %cl, (%r15,%r12)
incl %r12d
cmpq %r12, 0x8(%r14)
ja 0x2414e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_member_name(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_member_name(uint32_t id, uint32_t index, const string &name)
{
	meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));

	auto &str = meta[id].members[index].alias;
	str.clear();
	if (name.empty())
		return;

	// Reserved for unnamed members.
	if (name[0] == '_' && name.size() >= 3 && name[1] == 'm' && isdigit(name[2]))
		return;

	str = ensure_valid_identifier(name, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, %eax
movq 0x30(%rdi), %rcx
imulq $0x148, %rax, %r15      # imm = 0x148
leaq 0xd0(%r15), %rdi
addq %rcx, %rdi
movq 0xd8(%rcx,%r15), %rax
subq 0xd0(%rcx,%r15), %rax
sarq $0x4, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rsi # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %rsi
movl %edx, %r12d
leaq 0x1(%r12), %rax
cmpq %rax, %rsi
cmovbeq %rax, %rsi
callq 0x1b92e
movq 0x30(%r14), %rax
movq 0xd0(%rax,%r15), %r14
imulq $0xd0, %r12, %rax
movq $0x0, 0x8(%r14,%rax)
movq (%r14,%rax), %rcx
movb $0x0, (%rcx)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x242a9
cmpq $0x3, %rcx
jb 0x2426c
movq (%rbx), %rcx
cmpb $0x5f, (%rcx)
jne 0x2426c
cmpb $0x6d, 0x1(%rcx)
jne 0x2426c
movsbl 0x2(%rcx), %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x242a9
addq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x24115
movq %r14, %rdi
movq %r15, %rsi
callq 0x6310
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x242a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_decoration_string(unsigned int, spv::Decoration, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_decoration_string(uint32_t id, Decoration decoration, const string &argument)
{
	auto &dec = meta[id].decoration;
	dec.decoration_flags.set(decoration);

	switch (decoration)
	{
	case DecorationHlslSemanticGOOGLE:
		dec.hlsl_semantic = argument;
		break;

	default:
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %eax
imulq $0x148, %rax, %r14      # imm = 0x148
addq 0x30(%rdi), %r14
movl %edx, 0x4(%rsp)
cmpl $0x3f, %edx
ja 0x242e6
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
orq %rax, 0x60(%r14)
jmp 0x24316
movq %rcx, %rbx
leaq 0x68(%r14), %rdi
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x4(%rsp), %rsi
callq 0x1f510
cmpl $0x1603, %ebp           # imm = 0x1603
jne 0x24316
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6170
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_decoration(unsigned int, spv::Decoration, unsigned int)
void ParsedIR::set_decoration(uint32_t id, Decoration decoration, uint32_t argument)
{
	auto &dec = meta[id].decoration;
	dec.decoration_flags.set(decoration);

	switch (decoration)
	{
	case DecorationBuiltIn:
		dec.builtin = true;
		dec.builtin_type = static_cast<BuiltIn>(argument);
		break;

	case DecorationLocation:
		dec.location = argument;
		break;

	case DecorationComponent:
		dec.component = argument;
		break;

	case DecorationOffset:
		dec.offset = argument;
		break;

	case DecorationArrayStride:
		dec.array_stride = argument;
		break;

	case DecorationMatrixStride:
		dec.matrix_stride = argument;
		break;

	case DecorationBinding:
		dec.binding = argument;
		break;

	case DecorationDescriptorSet:
		dec.set = argument;
		break;

	case DecorationInputAttachmentIndex:
		dec.input_attachment = argument;
		break;

	case DecorationSpecId:
		dec.spec_id = argument;
		break;

	case DecorationIndex:
		dec.index = argument;
		break;

	case DecorationHlslCounterBufferGOOGLE:
		meta[id].hlsl_magic_counter_buffer = argument;
		meta[id].hlsl_is_magic_counter_buffer = true;
		break;

	default:
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movq %rdi, %r15
movl %esi, %eax
imulq $0x148, %rax, %r13      # imm = 0x148
movq 0x30(%rdi), %r12
addq %r13, %r12
movl %edx, 0x4(%rsp)
cmpl $0x3f, %edx
ja 0x24360
movl $0x1, %eax
movl %r14d, %ecx
shlq %cl, %rax
orq %rax, 0x60(%r12)
jmp 0x24377
leaq 0x68(%r12), %rdi
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x4(%rsp), %rsi
callq 0x1f510
cmpl $0xa, %r14d
jle 0x243a3
leal -0x1e(%r14), %eax
cmpl $0xd, %eax
ja 0x243c6
leaq 0x910db(%rip), %rcx     # 0xb5468
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %ebx, 0xa4(%r12)
jmp 0x2444d
cmpl $0x1, %r14d
je 0x243e8
cmpl $0x6, %r14d
je 0x243f2
cmpl $0x7, %r14d
jne 0x2444d
movl %ebx, 0xbc(%r12)
jmp 0x2444d
cmpl $0x1602, %r14d          # imm = 0x1602
je 0x24438
cmpl $0xb, %r14d
jne 0x2444d
movb $0x1, 0xcc(%r12)
movl %ebx, 0xa0(%r12)
jmp 0x2444d
movl %ebx, 0xc4(%r12)
jmp 0x2444d
movl %ebx, 0xb8(%r12)
jmp 0x2444d
movl %ebx, 0xac(%r12)
jmp 0x2444d
movl %ebx, 0xb4(%r12)
jmp 0x2444d
movl %ebx, 0xa8(%r12)
jmp 0x2444d
movl %ebx, 0xb0(%r12)
jmp 0x2444d
movl %ebx, 0xc8(%r12)
jmp 0x2444d
movl %ebx, 0xc0(%r12)
jmp 0x2444d
movq 0x30(%r15), %rax
movl %ebx, 0x144(%rax,%r13)
movb $0x1, 0x141(%rax,%r13)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_member_decoration(unsigned int, unsigned int, spv::Decoration, unsigned int)
void ParsedIR::set_member_decoration(uint32_t id, uint32_t index, Decoration decoration, uint32_t argument)
{
	meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));
	auto &dec = meta[id].members[index];
	dec.decoration_flags.set(decoration);

	switch (decoration)
	{
	case DecorationBuiltIn:
		dec.builtin = true;
		dec.builtin_type = static_cast<BuiltIn>(argument);
		break;

	case DecorationLocation:
		dec.location = argument;
		break;

	case DecorationComponent:
		dec.component = argument;
		break;

	case DecorationBinding:
		dec.binding = argument;
		break;

	case DecorationOffset:
		dec.offset = argument;
		break;

	case DecorationSpecId:
		dec.spec_id = argument;
		break;

	case DecorationMatrixStride:
		dec.matrix_stride = argument;
		break;

	case DecorationIndex:
		dec.index = argument;
		break;

	default:
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movl %ecx, %r14d
movq %rdi, %r15
movl %esi, %eax
movq 0x30(%rdi), %rcx
imulq $0x148, %rax, %r12      # imm = 0x148
leaq 0xd0(%r12), %rdi
addq %rcx, %rdi
movq 0xd8(%rcx,%r12), %rax
subq 0xd0(%rcx,%r12), %rax
sarq $0x4, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rsi # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %rsi
movl %edx, %r13d
leaq 0x1(%r13), %rax
cmpq %rax, %rsi
cmovbeq %rax, %rsi
callq 0x1b92e
movq 0x30(%r15), %rax
imulq $0xd0, %r13, %r15
addq 0xd0(%rax,%r12), %r15
movl %r14d, 0x4(%rsp)
cmpl $0x3f, %r14d
ja 0x244ee
movl $0x1, %eax
movl %r14d, %ecx
shlq %cl, %rax
orq %rax, 0x60(%r15)
jmp 0x24504
leaq 0x68(%r15), %rdi
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x4(%rsp), %rsi
callq 0x1f510
cmpl $0x1d, %r14d
jle 0x2452d
addl $-0x1e, %r14d
cmpl $0x5, %r14d
ja 0x24584
leaq 0x90f85(%rip), %rax     # 0xb54a0
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %ebx, 0xa4(%r15)
jmp 0x24584
cmpl $0x1, %r14d
je 0x24574
cmpl $0x7, %r14d
je 0x2457d
cmpl $0xb, %r14d
jne 0x24584
movb $0x1, 0xcc(%r15)
movl %ebx, 0xa0(%r15)
jmp 0x24584
movl %ebx, 0xb0(%r15)
jmp 0x24584
movl %ebx, 0xc8(%r15)
jmp 0x24584
movl %ebx, 0xa8(%r15)
jmp 0x24584
movl %ebx, 0xb4(%r15)
jmp 0x24584
movl %ebx, 0xc4(%r15)
jmp 0x24584
movl %ebx, 0xbc(%r15)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::mark_used_as_array_length(unsigned int)
void ParsedIR::mark_used_as_array_length(uint32_t id)
{
	switch (ids[id].get_type())
	{
	case TypeConstant:
		get<SPIRConstant>(id).is_used_as_array_length = true;
		break;

	case TypeConstantOp:
	{
		auto &cop = get<SPIRConstantOp>(id);
		for (uint32_t arg_id : cop.arguments)
			mark_used_as_array_length(arg_id);
		break;
	}

	case TypeUndef:
		break;

	default:
		assert(0);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %ecx
movq 0x18(%rdi), %rdi
shlq $0x4, %rcx
movl 0x8(%rdi,%rcx), %eax
cmpl $0xd, %eax
je 0x245c6
addq %rcx, %rdi
cmpl $0xa, %eax
je 0x245cc
cmpl $0x3, %eax
jne 0x245ef
callq 0x1b808
movb $0x1, 0x109(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x2584c
movq 0x10(%rax), %r14
movq 0x18(%rax), %r15
cmpq %r15, %r14
je 0x245c6
movl (%r14), %esi
movq %rbx, %rdi
callq 0x24592
addq $0x4, %r14
jmp 0x245d9
leaq 0x9e4dd(%rip), %rdi     # 0xc2ad3
leaq 0x90f4a(%rip), %rsi     # 0xb5547
leaq 0x90f69(%rip), %rcx     # 0xb556d
movl $0x113, %edx            # imm = 0x113
callq 0x61b0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_member_decoration_bitset(unsigned int, unsigned int) const
const Bitset &ParsedIR::get_member_decoration_bitset(uint32_t id, uint32_t index) const
{
	auto &m = meta[id];
	if (index >= m.members.size())
	{
		static const Bitset cleared = {};
		return cleared;
	}

	return m.members[index].decoration_flags;
}

// Assembly:
movl %esi, %ecx
movq 0x30(%rdi), %rsi
movl %edx, %eax
imulq $0x148, %rcx, %rdx      # imm = 0x148
movq 0xd0(%rsi,%rdx), %rcx
movq 0xd8(%rsi,%rdx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
movabsq $0x4ec4ec4ec4ec4ec5, %rsi # imm = 0x4EC4EC4EC4EC4EC5
imulq %rdx, %rsi
cmpq %rax, %rsi
jbe 0x248fc
imulq $0xd0, %rax, %rax
addq %rcx, %rax
addq $0x60, %rax
retq
movb 0xd8c4e(%rip), %al      # 0xfd550
testb %al, %al
je 0x2490e
leaq 0xd8c03(%rip), %rax     # 0xfd510
retq
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6b6b
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_decoration(unsigned int, spv::Decoration) const
uint32_t ParsedIR::get_decoration(uint32_t id, Decoration decoration) const
{
	auto &dec = meta[id].decoration;
	if (!dec.decoration_flags.get(decoration))
		return 0;

	switch (decoration)
	{
	case DecorationBuiltIn:
		return dec.builtin_type;
	case DecorationLocation:
		return dec.location;
	case DecorationComponent:
		return dec.component;
	case DecorationOffset:
		return dec.offset;
	case DecorationBinding:
		return dec.binding;
	case DecorationDescriptorSet:
		return dec.set;
	case DecorationInputAttachmentIndex:
		return dec.input_attachment;
	case DecorationSpecId:
		return dec.spec_id;
	case DecorationArrayStride:
		return dec.array_stride;
	case DecorationMatrixStride:
		return dec.matrix_stride;
	case DecorationIndex:
		return dec.index;
	default:
		return 1;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %eax
imulq $0x148, %rax, %r14      # imm = 0x148
addq 0x30(%rdi), %r14
movl %edx, 0x4(%rsp)
cmpl $0x3f, %edx
ja 0x249b2
movq 0x60(%r14), %rax
btq %rbx, %rax
jb 0x249c5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x68(%r14), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1f4b4
testq %rax, %rax
je 0x249a8
movl $0x1, %eax
cmpl $0xa, %ebx
jle 0x249f0
leal -0x1e(%rbx), %ecx
cmpl $0xd, %ecx
ja 0x24a1a
leaq 0x90ada(%rip), %rdx     # 0xb54b8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0xa4(%r14), %eax
jmp 0x249aa
cmpl $0x1, %ebx
je 0x24a08
cmpl $0x6, %ebx
je 0x24a11
cmpl $0x7, %ebx
jne 0x249aa
movl 0xbc(%r14), %eax
jmp 0x249aa
movl 0xc4(%r14), %eax
jmp 0x249aa
movl 0xb8(%r14), %eax
jmp 0x249aa
cmpl $0xb, %ebx
jne 0x249aa
movl 0xa0(%r14), %eax
jmp 0x249aa
movl 0xb4(%r14), %eax
jmp 0x249aa
movl 0xac(%r14), %eax
jmp 0x249aa
movl 0xc8(%r14), %eax
jmp 0x249aa
movl 0xb0(%r14), %eax
jmp 0x249aa
movl 0xa8(%r14), %eax
jmp 0x249aa
movl 0xc0(%r14), %eax
jmp 0x249aa
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_decoration_string[abi:cxx11](unsigned int, spv::Decoration) const
const string &ParsedIR::get_decoration_string(uint32_t id, Decoration decoration) const
{
	auto &dec = meta[id].decoration;
	static const string empty;

	if (!dec.decoration_flags.get(decoration))
		return empty;

	switch (decoration)
	{
	case DecorationHlslSemanticGOOGLE:
		return dec.hlsl_semantic;

	default:
		return empty;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %eax
imulq $0x148, %rax, %r14      # imm = 0x148
addq 0x30(%rdi), %r14
movb 0xd8aef(%rip), %al      # 0xfd578
testb %al, %al
je 0x24add
movl %ebx, 0x4(%rsp)
cmpl $0x3f, %ebx
ja 0x24aa3
movq 0x60(%r14), %rax
btq %rbx, %rax
setb %al
jmp 0x24ab7
leaq 0x68(%r14), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1f4b4
testq %rax, %rax
setne %al
addq $0x40, %r14
leaq 0xd8a96(%rip), %rcx     # 0xfd558
testb %al, %al
cmoveq %rcx, %r14
cmpl $0x1603, %ebx           # imm = 0x1603
cmovneq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x6bfa
jmp 0x24a8d
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::unset_decoration(unsigned int, spv::Decoration)
void ParsedIR::unset_decoration(uint32_t id, Decoration decoration)
{
	auto &dec = meta[id].decoration;
	dec.decoration_flags.clear(decoration);
	switch (decoration)
	{
	case DecorationBuiltIn:
		dec.builtin = false;
		break;

	case DecorationLocation:
		dec.location = 0;
		break;

	case DecorationComponent:
		dec.component = 0;
		break;

	case DecorationOffset:
		dec.offset = 0;
		break;

	case DecorationBinding:
		dec.binding = 0;
		break;

	case DecorationDescriptorSet:
		dec.set = 0;
		break;

	case DecorationInputAttachmentIndex:
		dec.input_attachment = 0;
		break;

	case DecorationSpecId:
		dec.spec_id = 0;
		break;

	case DecorationHlslSemanticGOOGLE:
		dec.hlsl_semantic.clear();
		break;

	case DecorationHlslCounterBufferGOOGLE:
	{
		auto &counter = meta[id].hlsl_magic_counter_buffer;
		if (counter)
		{
			meta[counter].hlsl_is_magic_counter_buffer = false;
			counter = 0;
		}
		break;
	}

	default:
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl %esi, %eax
imulq $0x148, %rax, %r12      # imm = 0x148
movq 0x30(%rdi), %r15
addq %r12, %r15
movl %edx, 0x4(%rsp)
cmpl $0x3f, %edx
ja 0x24b1c
movq $-0x2, %rax
movl %ebx, %ecx
rolq %cl, %rax
andq %rax, 0x60(%r15)
jmp 0x24b2a
leaq 0x68(%r15), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1e95a
cmpl $0x1d, %ebx
jle 0x24b57
leal -0x1e(%rbx), %eax
cmpl $0xd, %eax
ja 0x24b72
leaq 0x909b2(%rip), %rcx     # 0xb54f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0xa4(%r15)
jmp 0x24c16
cmpl $0x1, %ebx
je 0x24bd8
cmpl $0xb, %ebx
jne 0x24c16
movb $0x0, 0xcc(%r15)
jmp 0x24c16
cmpl $0x1602, %ebx           # imm = 0x1602
je 0x24be5
cmpl $0x1603, %ebx           # imm = 0x1603
jne 0x24c16
movq $0x0, 0x48(%r15)
movq 0x40(%r15), %rax
movb $0x0, (%rax)
jmp 0x24c16
movl $0x0, 0xb0(%r15)
jmp 0x24c16
movl $0x0, 0xc0(%r15)
jmp 0x24c16
movl $0x0, 0xa8(%r15)
jmp 0x24c16
movl $0x0, 0xb4(%r15)
jmp 0x24c16
movl $0x0, 0xac(%r15)
jmp 0x24c16
movl $0x0, 0xc4(%r15)
jmp 0x24c16
movq 0x30(%r14), %rax
movl 0x144(%rax,%r12), %ecx
testq %rcx, %rcx
je 0x24c16
leaq (%rax,%r12), %rdx
addq $0x144, %rdx            # imm = 0x144
imulq $0x148, %rcx, %rcx      # imm = 0x148
movb $0x0, 0x141(%rax,%rcx)
movl $0x0, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_member_decoration(unsigned int, unsigned int, spv::Decoration) const
uint32_t ParsedIR::get_member_decoration(uint32_t id, uint32_t index, Decoration decoration) const
{
	auto &m = meta[id];
	if (index >= m.members.size())
		return 0;

	auto &dec = m.members[index];
	if (!dec.decoration_flags.get(decoration))
		return 0;

	switch (decoration)
	{
	case DecorationBuiltIn:
		return dec.builtin_type;
	case DecorationLocation:
		return dec.location;
	case DecorationComponent:
		return dec.component;
	case DecorationBinding:
		return dec.binding;
	case DecorationOffset:
		return dec.offset;
	case DecorationSpecId:
		return dec.spec_id;
	case DecorationIndex:
		return dec.index;
	default:
		return 1;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r14d
movl %esi, %ecx
movq 0x30(%rdi), %rsi
movl %edx, %eax
imulq $0x148, %rcx, %rcx      # imm = 0x148
movq 0xd0(%rsi,%rcx), %r15
movq 0xd8(%rsi,%rcx), %rcx
subq %r15, %rcx
sarq $0x4, %rcx
movabsq $0x4ec4ec4ec4ec4ec5, %rdx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rcx, %rdx
xorl %ebx, %ebx
cmpq %rax, %rdx
jbe 0x24d46
imulq $0xd0, %rax, %rax
addq %rax, %r15
movl %r14d, 0xc(%rsp)
cmpl $0x3f, %r14d
ja 0x24ccc
movq 0x60(%r15), %rax
btq %r14, %rax
jb 0x24cdf
jmp 0x24d46
leaq 0x68(%r15), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1f4b4
testq %rax, %rax
je 0x24d46
movl $0x1, %ebx
leal -0x1e(%r14), %eax
cmpl $0x5, %eax
ja 0x24d06
leaq 0x90834(%rip), %rcx     # 0xb5528
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xa4(%r15), %ebx
jmp 0x24d46
cmpl $0x1, %r14d
je 0x24d3f
cmpl $0xb, %r14d
jne 0x24d46
movl 0xa0(%r15), %ebx
jmp 0x24d46
movl 0xa8(%r15), %ebx
jmp 0x24d46
movl 0xc8(%r15), %ebx
jmp 0x24d46
movl 0xb0(%r15), %ebx
jmp 0x24d46
movl 0xb4(%r15), %ebx
jmp 0x24d46
movl 0xc4(%r15), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_member_decoration_string(unsigned int, unsigned int, spv::Decoration, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_member_decoration_string(uint32_t id, uint32_t index, Decoration decoration, const string &argument)
{
	meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));
	auto &dec = meta[id].members[index];
	dec.decoration_flags.set(decoration);

	switch (decoration)
	{
	case DecorationHlslSemanticGOOGLE:
		dec.hlsl_semantic = argument;
		break;

	default:
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdi, %r14
movl %esi, %eax
movq 0x30(%rdi), %rcx
imulq $0x148, %rax, %r15      # imm = 0x148
leaq 0xd0(%r15), %rdi
addq %rcx, %rdi
movq 0xd8(%rcx,%r15), %rax
subq 0xd0(%rcx,%r15), %rax
sarq $0x4, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rsi # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %rsi
movl %edx, %r12d
leaq 0x1(%r12), %rax
cmpq %rax, %rsi
cmovbeq %rax, %rsi
callq 0x1b92e
movq 0x30(%r14), %rax
imulq $0xd0, %r12, %r14
addq 0xd0(%rax,%r15), %r14
movl %ebp, 0x4(%rsp)
cmpl $0x3f, %ebp
ja 0x24ddf
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
orq %rax, 0x60(%r14)
jmp 0x24e0c
leaq 0x68(%r14), %rdi
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x4(%rsp), %rsi
callq 0x1f510
cmpl $0x1603, %ebp           # imm = 0x1603
jne 0x24e0c
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6170
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_member_decoration_string[abi:cxx11](unsigned int, unsigned int, spv::Decoration) const
const string &ParsedIR::get_member_decoration_string(uint32_t id, uint32_t index, Decoration decoration) const
{
	static const string empty;
	auto &m = meta[id];

	if (!has_member_decoration(id, index, decoration))
		return empty;

	auto &dec = m.members[index];

	switch (decoration)
	{
	case DecorationHlslSemanticGOOGLE:
		return dec.hlsl_semantic;

	default:
		return empty;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movb 0xd876e(%rip), %al      # 0xfd5a0
testb %al, %al
je 0x24e90
movq 0x30(%r15), %r12
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x24c22
testb %al, %al
je 0x24e80
movl %r14d, %eax
imulq $0x148, %rax, %rax      # imm = 0x148
movl %ebp, %ecx
movq 0xd0(%r12,%rax), %rax
imulq $0xd0, %rcx, %rcx
cmpl $0x1603, %ebx           # imm = 0x1603
leaq 0x40(%rax,%rcx), %rcx
leaq 0xd8706(%rip), %rax     # 0xfd580
cmoveq %rcx, %rax
jmp 0x24e87
leaq 0xd86f9(%rip), %rax     # 0xfd580
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x6c51
jmp 0x24e36
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::unset_member_decoration(unsigned int, unsigned int, spv::Decoration)
void ParsedIR::unset_member_decoration(uint32_t id, uint32_t index, Decoration decoration)
{
	auto &m = meta[id];
	if (index >= m.members.size())
		return;

	auto &dec = m.members[index];

	dec.decoration_flags.clear(decoration);
	switch (decoration)
	{
	case DecorationBuiltIn:
		dec.builtin = false;
		break;

	case DecorationLocation:
		dec.location = 0;
		break;

	case DecorationComponent:
		dec.component = 0;
		break;

	case DecorationOffset:
		dec.offset = 0;
		break;

	case DecorationSpecId:
		dec.spec_id = 0;
		break;

	case DecorationHlslSemanticGOOGLE:
		dec.hlsl_semantic.clear();
		break;

	default:
		break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %esi, %ecx
movq 0x30(%rdi), %rsi
movl %edx, %eax
imulq $0x148, %rcx, %rcx      # imm = 0x148
movq 0xd0(%rsi,%rcx), %r14
movq 0xd8(%rsi,%rcx), %rcx
subq %r14, %rcx
sarq $0x4, %rcx
movabsq $0x4ec4ec4ec4ec4ec5, %rdx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x24f81
imulq $0xd0, %rax, %rax
addq %rax, %r14
movl %ebx, 0x4(%rsp)
cmpl $0x3f, %ebx
ja 0x24f00
movq $-0x2, %rax
movl %ebx, %ecx
rolq %cl, %rax
andq %rax, 0x60(%r14)
jmp 0x24f0e
leaq 0x68(%r14), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1e95a
cmpl $0x1e, %ebx
jg 0x24f2f
cmpl $0x1, %ebx
je 0x24f52
cmpl $0xb, %ebx
je 0x24f6c
cmpl $0x1e, %ebx
jne 0x24f81
movl $0x0, 0xa4(%r14)
jmp 0x24f81
cmpl $0x1f, %ebx
je 0x24f5f
cmpl $0x23, %ebx
je 0x24f76
cmpl $0x1603, %ebx           # imm = 0x1603
jne 0x24f81
movq $0x0, 0x48(%r14)
movq 0x40(%r14), %rax
movb $0x0, (%rax)
jmp 0x24f81
movl $0x0, 0xc4(%r14)
jmp 0x24f81
movl $0x0, 0xa8(%r14)
jmp 0x24f81
movb $0x0, 0xcc(%r14)
jmp 0x24f81
movl $0x0, 0xb4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::increase_bound_by(unsigned int)
uint32_t ParsedIR::increase_bound_by(uint32_t incr_amount)
{
	auto curr_bound = ids.size();
	auto new_bound = curr_bound + incr_amount;
	ids.resize(new_bound);
	meta.resize(new_bound);
	block_meta.resize(new_bound);
	return uint32_t(curr_bound);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
subq 0x18(%rdi), %r14
addq $0x18, %rdi
sarq $0x4, %r14
movl %esi, %r15d
addq %r14, %r15
movq %r15, %rsi
callq 0x24fd4
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x25050
addq $0x78, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x250d0
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::sanitize_underscores(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CompilerGLSL::sanitize_underscores(const string &str)
{
	string res;
	res.reserve(str.size());

	bool last_underscore = false;
	for (auto c : str)
	{
		if (c == '_')
		{
			if (last_underscore)
				continue;

			res += c;
			last_underscore = true;
		}
		else
		{
			res += c;
			last_underscore = false;
		}
	}
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x6400
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x259d6
movq (%r14), %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
movl %ebp, %ecx
movb (%r14,%r13), %al
cmpb $0x5f, %al
sete %bpl
testb %cl, %bpl
jne 0x259ce
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6230
incq %r13
cmpq %r13, %r12
jne 0x259b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x259ea
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x25a00
movq (%r15), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::reset()
void CompilerGLSL::reset()
{
	// We do some speculative optimizations which should pretty much always work out,
	// but just in case the SPIR-V is rather weird, recompile until it's happy.
	// This typically only means one extra pass.
	force_recompile = false;

	// Clear invalid expression tracking.
	invalid_expressions.clear();
	current_function = nullptr;

	// Clear temporary usage tracking.
	expression_usage_counts.clear();
	forwarded_temporaries.clear();

	resource_names.clear();
	block_input_names.clear();
	block_output_names.clear();
	block_ubo_names.clear();
	block_ssbo_names.clear();
	function_overloads.clear();

	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeVariable)
		{
			// Clear unflushed dependees.
			id.get<SPIRVariable>().dependees.clear();
		}
		else if (id.get_type() == TypeExpression)
		{
			// And remove all expressions.
			id.reset();
		}
		else if (id.get_type() == TypeFunction)
		{
			// Reset active state for all functions.
			id.get<SPIRFunction>().active = false;
			id.get<SPIRFunction>().flush_undeclared = true;
		}
	}

	statement_count = 0;
	indent = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x1d0(%rdi)
addq $0x198, %rdi            # imm = 0x198
callq 0xd500
movq $0x0, 0x148(%rbx)
leaq 0x6e8(%rbx), %rdi
callq 0xdd00
leaq 0x260(%rbx), %rdi
callq 0xd500
leaq 0x488(%rbx), %rdi
callq 0xd940
leaq 0x4c0(%rbx), %rdi
callq 0xd940
leaq 0x4f8(%rbx), %rdi
callq 0xd940
leaq 0x530(%rbx), %rdi
callq 0xd940
leaq 0x568(%rbx), %rdi
callq 0xd940
leaq 0x5a0(%rbx), %rdi
callq 0xdd70
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r15
cmpq %r15, %r14
je 0x25b09
movl 0x8(%r14), %eax
cmpl $0x9, %eax
je 0x25ae6
cmpl $0x4, %eax
je 0x25ac6
cmpl $0x2, %eax
jne 0x25b03
movq %r14, %rdi
callq 0xb2a4
movq 0x40(%rax), %rcx
cmpq %rcx, 0x48(%rax)
je 0x25b03
movq %rcx, 0x48(%rax)
jmp 0x25b03
movq %r14, %rdi
callq 0x10274
movb $0x0, 0xc8(%rax)
movq %r14, %rdi
callq 0x10274
movb $0x1, 0xc9(%rax)
jmp 0x25b03
movq (%r14), %rdi
movq $0x0, (%r14)
testq %rdi, %rdi
je 0x25afb
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, 0x8(%r14)
addq $0x10, %r14
jmp 0x25a96
xorl %eax, %eax
movl %eax, 0x750(%rbx)
movl %eax, 0x638(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::remap_pls_variables()
void CompilerGLSL::remap_pls_variables()
{
	for (auto &input : pls_inputs)
	{
		auto &var = get<SPIRVariable>(input.id);

		bool input_is_target = false;
		if (var.storage == StorageClassUniformConstant)
		{
			auto &type = get<SPIRType>(var.basetype);
			input_is_target = type.image.dim == DimSubpassData;
		}

		if (var.storage != StorageClassInput && !input_is_target)
			SPIRV_CROSS_THROW("Can only use in and target variables for PLS inputs.");
		var.remapped_variable = true;
	}

	for (auto &output : pls_outputs)
	{
		auto &var = get<SPIRVariable>(output.id);
		if (var.storage != StorageClassOutput)
			SPIRV_CROSS_THROW("Can only use out variables for PLS outputs.");
		var.remapped_variable = true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x758(%rdi), %r15
movq 0x760(%rdi), %r12
cmpq %r12, %r15
je 0x25b87
movl (%r15), %esi
movq %rbx, %rdi
callq 0xb3ca
movq %rax, %r14
movl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x25b59
xorl %eax, %eax
jmp 0x25b73
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xa3ea
cmpl $0x6, 0x84(%rax)
sete %al
movl 0x10(%r14), %ecx
cmpl $0x1, %ecx
je 0x25b7c
testb %al, %al
je 0x25bc2
movb $0x1, 0x5b(%r14)
addq $0x8, %r15
jmp 0x25b3b
movq 0x770(%rbx), %r14
movq 0x778(%rbx), %r15
cmpq %r15, %r14
je 0x25bb5
movl (%r14), %esi
movq %rbx, %rdi
callq 0xb3ca
cmpl $0x3, 0x10(%rax)
jne 0x25c24
movb $0x1, 0x5b(%rax)
addq $0x8, %r14
jmp 0x25b95
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x908f1(%rip), %rsi     # 0xb64d0
leaq 0x9091e(%rip), %rdx     # 0xb6504
movq %rsp, %rdi
callq 0x7be0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xd61c5(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd619d(%rip), %rsi     # 0xfbdb0
movq 0xd73be(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x25c84
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x908c4(%rip), %rsi     # 0xb6505
leaq 0x908e8(%rip), %rdx     # 0xb6530
movq %rsp, %rdi
callq 0x7be0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xd6163(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd613b(%rip), %rsi     # 0xfbdb0
movq 0xd735c(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
jmp 0x25c88
jmp 0x25ca8
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x25ca1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
jne 0x25cab
jmp 0x25cb3
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::add_member_name(spirv_cross::SPIRType&, unsigned int)
void CompilerGLSL::add_member_name(SPIRType &type, uint32_t index)
{
	auto &memb = ir.meta[type.self].members;
	if (index < memb.size() && !memb[index].alias.empty())
	{
		auto &name = memb[index].alias;
		if (name.empty())
			return;

		// Reserved for temporaries.
		if (name[0] == '_' && name.size() >= 2 && isdigit(name[1]))
		{
			name.clear();
			return;
		}

		update_name_cache(type.member_name_cache, name);
	}
}

// Assembly:
movl 0x8(%rsi), %eax
movq 0x38(%rdi), %rcx
imulq $0x148, %rax, %r8       # imm = 0x148
movl %edx, %eax
movq 0xd0(%rcx,%r8), %rdx
movq 0xd8(%rcx,%r8), %rcx
subq %rdx, %rcx
sarq $0x4, %rcx
movabsq $0x4ec4ec4ec4ec4ec5, %r8 # imm = 0x4EC4EC4EC4EC4EC5
imulq %rcx, %r8
cmpq %rax, %r8
jbe 0x28263
imulq $0xd0, %rax, %rcx
movq 0x8(%rdx,%rcx), %rax
testq %rax, %rax
je 0x28263
addq %rcx, %rdx
cmpq $0x1, %rax
je 0x28264
movq (%rdx), %rax
cmpb $0x5f, (%rax)
jne 0x28264
movsbl 0x1(%rax), %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0x28264
movq $0x0, 0x8(%rdx)
movb $0x0, (%rax)
retq
addq $0xa0, %rsi
jmp 0x14712
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::end_scope_decl()
void CompilerGLSL::end_scope_decl()
{
	if (!indent)
		SPIRV_CROSS_THROW("Popping empty indent stack.");
	indent--;
	statement("};");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x638(%rdi), %eax
testl %eax, %eax
je 0x282a2
decl %eax
movl %eax, 0x638(%rdi)
leaq 0x997ff(%rip), %rsi     # 0xc1a92
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x594d4
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9291a(%rip), %rsi     # 0xbabd9
leaq 0x9292e(%rip), %rdx     # 0xbabf4
leaq 0x8(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xd3ae1(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd3ab9(%rip), %rsi     # 0xfbdb0
movq 0xd4cda(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x28320
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
jne 0x2832a
jmp 0x28332
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_interpolation_qualifiers[abi:cxx11](spirv_cross::Bitset const&)
string CompilerGLSL::to_interpolation_qualifiers(const Bitset &flags)
{
	string res;
	//if (flags & (1ull << DecorationSmooth))
	//    res += "smooth ";
	if (flags.get(DecorationFlat))
		res += "flat ";
	if (flags.get(DecorationNoPerspective))
		res += "noperspective ";
	if (flags.get(DecorationCentroid))
		res += "centroid ";
	if (flags.get(DecorationPatch))
		res += "patch ";
	if (flags.get(DecorationSample))
		res += "sample ";
	if (flags.get(DecorationInvariant))
		res += "invariant ";
	if (flags.get(DecorationExplicitInterpAMD))
		res += "__explicitInterpAMD ";

	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rdx), %rax
btl $0xe, %eax
jae 0x28377
leaq 0x8e70c(%rip), %rsi     # 0xb6a78
movq %rbx, %rdi
callq 0x64e0
movq (%r14), %rax
btl $0xd, %eax
jae 0x2838f
leaq 0x8e6fa(%rip), %rsi     # 0xb6a7e
movq %rbx, %rdi
callq 0x64e0
movq (%r14), %rax
btl $0x10, %eax
jae 0x283a7
leaq 0x8e6f1(%rip), %rsi     # 0xb6a8d
movq %rbx, %rdi
callq 0x64e0
movq (%r14), %rax
testw %ax, %ax
jns 0x283be
leaq 0x8e6e4(%rip), %rsi     # 0xb6a97
movq %rbx, %rdi
callq 0x64e0
movq (%r14), %rax
btl $0x11, %eax
jae 0x283d6
leaq 0x8e6d3(%rip), %rsi     # 0xb6a9e
movq %rbx, %rdi
callq 0x64e0
movq (%r14), %rax
btl $0x12, %eax
jae 0x283eb
leaq 0x8e6c3(%rip), %rsi     # 0xb6aa6
movq %rbx, %rdi
callq 0x64e0
leaq 0xc(%rsp), %rsi
movl $0x1387, (%rsi)         # imm = 0x1387
addq $0x8, %r14
movq %r14, %rdi
callq 0x1f4b4
testq %rax, %rax
je 0x28416
leaq 0x8e6a3(%rip), %rsi     # 0xb6ab1
movq %rbx, %rdi
callq 0x64e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x28439
movq (%r15), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::can_use_io_location(spv::StorageClass, bool)
bool CompilerGLSL::can_use_io_location(StorageClass storage, bool block)
{
	// Location specifiers are must have in SPIR-V, but they aren't really supported in earlier versions of GLSL.
	// Be very explicit here about how to solve the issue.
	if ((get_execution_model() != ExecutionModelVertex && storage == StorageClassInput) ||
	    (get_execution_model() != ExecutionModelFragment && storage == StorageClassOutput))
	{
		uint32_t minimum_desktop_version = block ? 440 : 410;
		// ARB_enhanced_layouts vs ARB_separate_shader_objects ...

		if (!options.es && options.version < minimum_desktop_version && !options.separate_shader_objects)
			return false;
		else if (options.es && options.version < 310)
			return false;
	}

	if ((get_execution_model() == ExecutionModelVertex && storage == StorageClassInput) ||
	    (get_execution_model() == ExecutionModelFragment && storage == StorageClassOutput))
	{
		if (options.es && options.version < 300)
			return false;
		else if (!options.es && options.version < 330)
			return false;
	}

	if (storage == StorageClassUniform || storage == StorageClassUniformConstant)
	{
		if (options.es && options.version < 310)
			return false;
		else if (!options.es && options.version < 430)
			return false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x16118
cmpl $0x1, %ebp
jne 0x289ae
testl %eax, %eax
jne 0x289c0
movq %rbx, %rdi
callq 0x16118
cmpl $0x3, %ebp
jne 0x289fb
cmpl $0x4, %eax
je 0x289fb
cmpb $0x0, 0x43c(%rbx)
je 0x289da
cmpl $0x136, 0x438(%rbx)     # imm = 0x136
jae 0x289fb
jmp 0x28a67
testb %r14b, %r14b
movl $0x1b8, %eax            # imm = 0x1B8
movl $0x19a, %ecx            # imm = 0x19A
cmovnel %eax, %ecx
cmpl %ecx, 0x438(%rbx)
jae 0x289fb
cmpb $0x0, 0x43f(%rbx)
je 0x28a67
movl %ebp, %r14d
xorl $0x1, %r14d
movq %rbx, %rdi
callq 0x16118
orl %r14d, %eax
je 0x28a23
movq %rbx, %rdi
callq 0x16118
xorl $0x4, %eax
movl %ebp, %ecx
xorl $0x3, %ecx
orl %eax, %ecx
jne 0x28a3f
cmpb $0x0, 0x43c(%rbx)
movl $0x12b, %eax            # imm = 0x12B
movl $0x149, %ecx            # imm = 0x149
cmovnel %eax, %ecx
cmpl %ecx, 0x438(%rbx)
jbe 0x28a67
testl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
jne 0x28a63
cmpb $0x0, 0x43c(%rbx)
movl $0x135, %eax            # imm = 0x135
movl $0x1ad, %ecx            # imm = 0x1AD
cmovnel %eax, %ecx
cmpl %ecx, 0x438(%rbx)
jbe 0x28a67
movb $0x1, %al
jmp 0x28a69
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::type_to_packed_base_size(spirv_cross::SPIRType const&, spirv_cross::BufferPackingStandard)
uint32_t CompilerGLSL::type_to_packed_base_size(const SPIRType &type, BufferPackingStandard)
{
	switch (type.basetype)
	{
	case SPIRType::Double:
	case SPIRType::Int64:
	case SPIRType::UInt64:
		return 8;
	case SPIRType::Float:
	case SPIRType::Int:
	case SPIRType::UInt:
		return 4;
	case SPIRType::Half:
		return 2;

	default:
		SPIRV_CROSS_THROW("Unrecognized type in type_to_packed_base_size.");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xc(%rsi), %eax
addl $-0x4, %eax
cmpl $0x8, %eax
jae 0x28b82
movl $0xef, %ecx
btl %eax, %ecx
jae 0x28b82
movl %eax, %eax
leaq 0x92418(%rip), %rcx     # 0xbaf8c
movl (%rcx,%rax,4), %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 0x8e13b(%rip), %rsi     # 0xb6cda
leaq 0x8e162(%rip), %rdx     # 0xb6d08
leaq 0x8(%rsp), %rdi
callq 0x7be0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0xd3201(%rip), %rax     # 0xfbdc8
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd31d9(%rip), %rsi     # 0xfbdb0
movq 0xd43fa(%rip), %rdx     # 0xfcfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x28c00
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
testb %bpl, %bpl
jne 0x28c0a
jmp 0x28c12
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::type_to_packed_array_stride(spirv_cross::SPIRType const&, spirv_cross::Bitset const&, spirv_cross::BufferPackingStandard)
uint32_t CompilerGLSL::type_to_packed_array_stride(const SPIRType &type, const Bitset &flags,
                                                   BufferPackingStandard packing)
{
	// Array stride is equal to aligned size of the underlying type.
	uint32_t parent = type.parent_type;
	assert(parent);

	auto &tmp = get<SPIRType>(parent);

	uint32_t size = type_to_packed_size(tmp, flags, packing);
	if (tmp.array.empty())
	{
		uint32_t alignment = type_to_packed_alignment(type, flags, packing);
		return (size + alignment - 1) & ~(alignment - 1);
	}
	else
	{
		// For multidimensional arrays, array stride always matches size of subtype.
		// The alignment cannot change because multidimensional arrays are basically N * M array elements.
		return size;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl 0x9c(%rsi), %esi
testl %esi, %esi
je 0x28fbc
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r12
callq 0xa3ea
movq %rax, %rbp
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x28fdc
movl %eax, %r13d
movq 0x20(%rbp), %rax
cmpq 0x28(%rbp), %rax
jne 0x28faa
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x28c1a
leal (%rax,%r13), %ecx
decl %ecx
negl %eax
andl %ecx, %eax
movl %eax, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8dd7e(%rip), %rdi     # 0xb6d41
leaq 0x8dd7e(%rip), %rsi     # 0xb6d48
leaq 0x8dd92(%rip), %rcx     # 0xb6d63
movl $0x3f4, %edx            # imm = 0x3F4
callq 0x61b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_array_size_literal(spirv_cross::SPIRType const&, unsigned int) const
uint32_t CompilerGLSL::to_array_size_literal(const SPIRType &type, uint32_t index) const
{
	assert(type.array.size() == type.array_size_literal.size());

	if (type.array_size_literal[index])
	{
		return type.array[index];
	}
	else
	{
		// Use the default spec constant value.
		// This is the best we can do.
		uint32_t array_size_id = type.array[index];
		uint32_t array_size = get<SPIRConstant>(array_size_id).scalar();
		return array_size;
	}
}

// Assembly:
pushq %rax
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %r8
subq %rax, %r8
sarq $0x2, %r8
movq 0x48(%rsi), %r9
movl 0x50(%rsi), %r10d
movq 0x38(%rsi), %rcx
subq %rcx, %r9
leaq (%r10,%r9,8), %rsi
cmpq %rsi, %r8
jne 0x292f8
movl %edx, %esi
movl %edx, %r8d
shrl $0x6, %r8d
movq (%rcx,%r8,8), %rcx
btq %rdx, %rcx
leaq (%rax,%rsi,4), %rax
jb 0x292f4
movl (%rax), %esi
callq 0x1b4c6
addq $0x10, %rax
movl (%rax), %eax
popq %rcx
retq
leaq 0x912c9(%rip), %rdi     # 0xba5c8
leaq 0x8da42(%rip), %rsi     # 0xb6d48
leaq 0x912ef(%rip), %rcx     # 0xba5fc
movl $0x2138, %edx           # imm = 0x2138
callq 0x61b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_push_constant_block(spirv_cross::SPIRVariable const&)
void CompilerGLSL::emit_push_constant_block(const SPIRVariable &var)
{
	if (flattened_buffer_blocks.count(var.self))
		emit_buffer_block_flattened(var);
	else if (options.vulkan_semantics)
		emit_push_constant_block_vulkan(var);
	else
		emit_push_constant_block_glsl(var);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x678, %rdi            # imm = 0x678
addq $0x8, %rsi
callq 0x1f4b4
testq %rax, %rax
je 0x2a77f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a7b4
cmpb $0x1, 0x43e(%r14)
jne 0x2a7a2
movq (%r14), %rax
movq 0xe8(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2abe0