LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::is_hidden_variable(spirv_cross::SPIRVariable const&, bool) const
bool Compiler::is_hidden_variable(const SPIRVariable &var, bool include_builtins) const
{
	if ((is_builtin_variable(var) && !include_builtins) || var.remapped_variable)
		return true;

	// Combined image samplers are always considered active as they are "magic" variables.
	if (find_if(begin(combined_image_samplers), end(combined_image_samplers), [&var](const CombinedImageSampler &samp) {
		    return samp.combined_id == var.self;
	    }) != end(combined_image_samplers))
	{
		return false;
	}

	bool hidden = false;
	if (check_active_interface_variables && storage_class_is_interface(var.storage))
		hidden = active_interface_variables.find(var.self) == end(active_interface_variables);
	return hidden;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x18(%rbp), %rsi
callq 0x205a0
testb $0x1, %al
jne 0x2048e
jmp 0x20494
testb $0x1, -0x19(%rbp)
je 0x2049e
movq -0x18(%rbp), %rax
testb $0x1, 0x5b(%rax)
je 0x204a7
movb $0x1, -0x1(%rbp)
jmp 0x20586
movq -0x68(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x2ead0
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x2eb00
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x20620
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x2eb00
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2ea90
testb $0x1, %al
jne 0x20513
jmp 0x20519
movb $0x0, -0x1(%rbp)
jmp 0x20586
movq -0x68(%rbp), %rax
movb $0x0, -0x49(%rbp)
testb $0x1, 0x190(%rax)
je 0x2057e
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x20680
testb $0x1, %al
jne 0x2053c
jmp 0x2057e
movq -0x68(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x2eb60
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x158, %rdi            # imm = 0x158
callq 0x2eb90
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2eb30
andb $0x1, %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::is_builtin_variable(spirv_cross::SPIRVariable const&) const
bool Compiler::is_builtin_variable(const SPIRVariable &var) const
{
	if (var.compat_builtin || ir.meta[var.self].decoration.builtin)
		return true;
	else
		return is_builtin_type(get<SPIRType>(var.basetype));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0x205e5
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
testb $0x1, 0xcc(%rax)
je 0x205eb
movb $0x1, -0x1(%rbp)
jmp 0x2060c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2e6b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x206c0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: storage_class_is_interface(spv::StorageClass)
static inline bool storage_class_is_interface(spv::StorageClass storage)
{
	switch (storage)
	{
	case StorageClassInput:
	case StorageClassOutput:
	case StorageClassUniform:
	case StorageClassUniformConstant:
	case StorageClassAtomicCounter:
	case StorageClassPushConstant:
	case StorageClassStorageBuffer:
		return true;

	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x4, %eax
jb 0x206ab
jmp 0x20694
movl -0xc(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x206ab
jmp 0x206a1
movl -0xc(%rbp), %eax
subl $0xc, %eax
jne 0x206b1
jmp 0x206ab
movb $0x1, -0x1(%rbp)
jmp 0x206b5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::is_builtin_type(spirv_cross::SPIRType const&) const
bool Compiler::is_builtin_type(const SPIRType &type) const
{
	// We can have builtin structs as well. If one member of a struct is builtin, the struct must also be builtin.
	for (auto &m : ir.meta[type.self].members)
		if (m.builtin)
			return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
addq $0xd0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ebc0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ebf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2ec20
testb $0x1, %al
jne 0x20721
jmp 0x2074e
leaq -0x28(%rbp), %rdi
callq 0x2ec60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0xcc(%rax)
je 0x20741
movb $0x1, -0x1(%rbp)
jmp 0x20752
jmp 0x20743
leaq -0x28(%rbp), %rdi
callq 0x2ec80
jmp 0x2070e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::is_member_builtin(spirv_cross::SPIRType const&, unsigned int, spv::BuiltIn*) const
bool Compiler::is_member_builtin(const SPIRType &type, uint32_t index, BuiltIn *builtin) const
{
	auto &memb = ir.meta[type.self].members;
	if (index < memb.size() && memb[index].builtin)
	{
		if (builtin)
			*builtin = memb[index].builtin_type;
		return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
addq $0xd0, %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x207f5
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
testb $0x1, 0xcc(%rax)
je 0x207f5
cmpq $0x0, -0x28(%rbp)
je 0x207ef
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
movl 0xa0(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x207f9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_active_interface_variables() const
unordered_set<uint32_t> Compiler::get_active_interface_variables() const
{
	// Traverse the call graph and find all interface variables which are in use.
	unordered_set<uint32_t> variables;
	InterfaceVariableAccessHandler handler(*this, variables);
	traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler);

	// If we needed to create one, we'll need it.
	if (dummy_sampler_id)
		variables.insert(dummy_sampler_id);

	return variables;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x13cb0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2ed90
jmp 0x21a52
movq -0x60(%rbp), %rdi
movl 0x108(%rdi), %esi
callq 0x2ede0
movq %rax, -0x70(%rbp)
jmp 0x21a67
movq -0x70(%rbp), %rsi
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x21b20
jmp 0x21a7a
movq -0x60(%rbp), %rax
cmpl $0x0, 0x39c(%rax)
je 0x21ad9
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x39c, %rsi            # imm = 0x39C
callq 0x2e890
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x21aa4
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
jmp 0x21ad9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x21b02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2ee20
jmp 0x21b02
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2ee20
testb $0x1, -0x11(%rbp)
jne 0x21af5
movq -0x58(%rbp), %rdi
callq 0x13900
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x13900
movq -0x38(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::traverse_all_reachable_opcodes(spirv_cross::SPIRFunction const&, spirv_cross::Compiler::OpcodeHandler&) const
bool Compiler::traverse_all_reachable_opcodes(const SPIRFunction &func, OpcodeHandler &handler) const
{
	for (auto block : func.blocks)
		if (!traverse_all_reachable_opcodes(get<SPIRBlock>(block), handler))
			return false;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbaf0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbb20
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2e710
testb $0x1, %al
jne 0x21b75
jmp 0x21bb6
leaq -0x30(%rbp), %rdi
callq 0x2e750
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
callq 0x8a70
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x23ee0
testb $0x1, %al
jne 0x21ba9
movb $0x0, -0x1(%rbp)
jmp 0x21bba
jmp 0x21bab
leaq -0x30(%rbp), %rdi
callq 0x2e770
jmp 0x21b62
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::interface_variable_exists_in_entry_point(unsigned int) const
bool Compiler::interface_variable_exists_in_entry_point(uint32_t id) const
{
	auto &var = get<SPIRVariable>(id);
	if (var.storage != StorageClassInput && var.storage != StorageClassOutput &&
	    var.storage != StorageClassUniformConstant)
		SPIRV_CROSS_THROW("Only Input, Output variables and Uniform constants are part of a shader linking interface.");

	// This is to avoid potential problems with very old glslang versions which did
	// not emit input/output interfaces properly.
	// We can assume they only had a single entry point, and single entry point
	// shaders could easily be assumed to use every interface variable anyways.
	if (ir.entry_points.size() <= 1)
		return true;

	auto &execution = get_entry_point();
	return find(begin(execution.interface_variables), end(execution.interface_variables), id) !=
	       end(execution.interface_variables);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl -0x14(%rbp), %esi
callq 0x2e8d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0x21d1b
movq -0x20(%rbp), %rax
cmpl $0x3, 0x10(%rax)
je 0x21d1b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x21d1b
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x98(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7650
movq -0x90(%rbp), %rdx
leaq 0x11da6f(%rip), %rsi    # 0x13f705
leaq -0x40(%rbp), %rdi
callq 0x7520
jmp 0x21ca1
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9c50
jmp 0x21cb3
movq -0x98(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x18c113(%rip), %rsi    # 0x1addd8
leaq -0x1803c(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x21dbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x21cf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7708
leaq -0x41(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x55(%rbp)
jne 0x21d0a
jmp 0x21d16
movq -0x98(%rbp), %rdi
callq 0x72c0
jmp 0x21db6
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
addq $0xc8, %rdi
callq 0x30760
cmpq $0x1, %rax
ja 0x21d3e
movb $0x1, -0x1(%rbp)
jmp 0x21da8
movq -0x88(%rbp), %rdi
callq 0x25030
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
callq 0x307d0
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
callq 0x30800
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x30780
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
addq $0x48, %rdi
callq 0x30800
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2e710
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7640
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_remapped_declared_block_name[abi:cxx11](unsigned int) const
std::string Compiler::get_remapped_declared_block_name(uint32_t id) const
{
	auto itr = declared_block_names.find(id);
	if (itr != end(declared_block_names))
		return itr->second;
	else
	{
		auto &var = get<SPIRVariable>(id);
		auto &type = get<SPIRType>(var.basetype);
		auto &block_name = ir.meta[type.self].decoration.alias;
		return block_name.empty() ? get_block_fallback_name(id) : block_name;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x3d8, %rdi            # imm = 0x3D8
leaq -0x14(%rbp), %rsi
callq 0x32ab0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x3d8, %rdi            # imm = 0x3D8
callq 0x32b10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32ae0
testb $0x1, %al
jne 0x21e21
jmp 0x21e3c
leaq -0x20(%rbp), %rdi
callq 0x32b40
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x7170
jmp 0x21eaf
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e8d0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2e6b0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x75f0
testb $0x1, %al
jne 0x21e8d
jmp 0x21ea0
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %edx
movq (%rsi), %rax
callq *0x20(%rax)
jmp 0x21ead
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7170
jmp 0x21eaf
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::type_is_block_like(spirv_cross::SPIRType const&) const
bool Compiler::type_is_block_like(const SPIRType &type) const
{
	if (type.basetype != SPIRType::Struct)
		return false;

	if (has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock))
	{
		return true;
	}

	// Block-like types may have Offset decorations.
	for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++)
		if (has_member_decoration(type.self, i, DecorationOffset))
			return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xc, 0xc(%rax)
je 0x21eeb
movb $0x0, -0x1(%rbp)
jmp 0x21f7e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x2, %edx
callq 0x1f560
testb $0x1, %al
jne 0x21f1f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x3, %edx
callq 0x1f560
testb $0x1, %al
jne 0x21f1f
jmp 0x21f25
movb $0x1, -0x1(%rbp)
jmp 0x21f7e
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0x21f7a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x23, %ecx
callq 0x21f90
testb $0x1, %al
jne 0x21f67
jmp 0x21f6d
movb $0x1, -0x1(%rbp)
jmp 0x21f7e
jmp 0x21f6f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21f2c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_non_pointer_type_id(unsigned int) const
uint32_t Compiler::get_non_pointer_type_id(uint32_t type_id) const
{
	auto *p_type = &get<SPIRType>(type_id);
	while (p_type->pointer)
	{
		assert(p_type->parent_type);
		type_id = p_type->parent_type;
		p_type = &get<SPIRType>(type_id);
	}
	return type_id;
}

// 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 0x2e6b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x22dea
movq -0x18(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x22dac
jmp 0x22dcb
leaq 0x11c752(%rip), %rdi    # 0x13f505
leaq 0x11c75f(%rip), %rsi    # 0x13f519
movl $0x3c3, %edx            # imm = 0x3C3
leaq 0x11c76f(%rip), %rcx    # 0x13f535
callq 0x7260
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x9c(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
callq 0x2e6b0
movq %rax, -0x18(%rbp)
jmp 0x22d93
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_non_pointer_type(spirv_cross::SPIRType const&) const
const SPIRType &Compiler::get_non_pointer_type(const SPIRType &type) const
{
	auto *p_type = &type;
	while (p_type->pointer)
	{
		assert(p_type->parent_type);
		p_type = &get<SPIRType>(p_type->parent_type);
	}
	return *p_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x22e71
movq -0x18(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x22e39
jmp 0x22e58
leaq 0x11c6c5(%rip), %rdi    # 0x13f505
leaq 0x11c6d2(%rip), %rsi    # 0x13f519
movl $0x3cf, %edx            # imm = 0x3CF
leaq 0x11c72a(%rip), %rcx    # 0x13f57d
callq 0x7260
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x9c(%rax), %esi
callq 0x2e6b0
movq %rax, -0x18(%rbp)
jmp 0x22e20
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_member_qualified_name[abi:cxx11](unsigned int, unsigned int) const
const std::string &Compiler::get_member_qualified_name(uint32_t type_id, uint32_t index) const
{
	const static string empty;

	auto &m = ir.meta.at(type_id);
	if (index < m.members.size())
		return m.members[index].qualified_alias;
	else
		return empty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpb $0x0, 0x18c55f(%rip)    # 0x1af650
jne 0x23136
leaq 0x18c556(%rip), %rdi    # 0x1af650
callq 0x7670
cmpl $0x0, %eax
je 0x23136
leaq 0x18c525(%rip), %rdi    # 0x1af630
callq 0x7530
movq 0x18bec9(%rip), %rdi    # 0x1aefe0
leaq 0x18c512(%rip), %rsi    # 0x1af630
leaq 0x18c25b(%rip), %rdx    # 0x1af380
callq 0x7300
leaq 0x18c51f(%rip), %rdi    # 0x1af650
callq 0x7250
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa50
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x23192
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0x2319d
leaq 0x18c497(%rip), %rax    # 0x1af630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_block_fallback_name[abi:cxx11](unsigned int) const
const std::string Compiler::get_block_fallback_name(uint32_t id) const
{
	auto &var = get<SPIRVariable>(id);
	if (get_name(id).empty())
		return join("_", get<SPIRType>(var.basetype).self, "_", id);
	else
		return get_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), %esi
callq 0x2e8d0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %esi
callq 0x23340
movq %rax, %rdi
callq 0x75f0
testb $0x1, %al
jne 0x233fc
jmp 0x2342c
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2e6b0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
addq $0x8, %rdx
leaq 0x125100(%rip), %rcx    # 0x14851e
leaq -0x14(%rbp), %r8
movq %rcx, %rsi
callq 0x2fab0
jmp 0x23444
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x23340
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7170
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_binary_offset_for_decoration(unsigned int, spv::Decoration, unsigned int&) const
bool Compiler::get_binary_offset_for_decoration(uint32_t id, spv::Decoration decoration, uint32_t &word_offset) const
{
	auto &word_offsets = ir.meta.at(id).decoration_word_offset;
	auto itr = word_offsets.find(decoration);
	if (itr == end(word_offsets))
		return false;

	word_offset = itr->second;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa50
addq $0xe8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x2fb70
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2fbd0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2fba0
testb $0x1, %al
jne 0x235ed
jmp 0x235f3
movb $0x0, -0x1(%rbp)
jmp 0x23609
leaq -0x30(%rbp), %rdi
callq 0x2fc00
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::block_is_outside_flow_control_from_block(spirv_cross::SPIRBlock const&, spirv_cross::SPIRBlock const&)
bool Compiler::block_is_outside_flow_control_from_block(const SPIRBlock &from, const SPIRBlock &to)
{
	auto *start = &from;

	if (start->self == to.self)
		return true;

	// Break cycles.
	if (is_continue(start->self))
		return false;

	// If our select block doesn't merge, we must break or continue in these blocks,
	// so if continues occur branchless within these blocks, consider them branchless as well.
	// This is typically used for loop control.
	if (start->terminator == SPIRBlock::Select && start->merge == SPIRBlock::MergeNone &&
	    (block_is_outside_flow_control_from_block(get<SPIRBlock>(start->true_block), to) ||
	     block_is_outside_flow_control_from_block(get<SPIRBlock>(start->false_block), to)))
	{
		return true;
	}
	else if (start->merge_block && block_is_outside_flow_control_from_block(get<SPIRBlock>(start->merge_block), to))
	{
		return true;
	}
	else if (start->next_block && block_is_outside_flow_control_from_block(get<SPIRBlock>(start->next_block), to))
	{
		return true;
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x23b5d
movb $0x1, -0x1(%rbp)
jmp 0x23c50
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2fdb0
testb $0x1, %al
jne 0x23b73
jmp 0x23b7c
movb $0x0, -0x1(%rbp)
jmp 0x23c50
movq -0x28(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x23be0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x23be0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x87d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x23b20
testb $0x1, %al
jne 0x23bda
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x87d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x23b20
testb $0x1, %al
jne 0x23bda
jmp 0x23be0
movb $0x1, -0x1(%rbp)
jmp 0x23c50
movq -0x28(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x23c16
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x87d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x23b20
testb $0x1, %al
jne 0x23c10
jmp 0x23c16
movb $0x1, -0x1(%rbp)
jmp 0x23c50
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x23c4c
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x87d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x23b20
testb $0x1, %al
jne 0x23c46
jmp 0x23c4c
movb $0x1, -0x1(%rbp)
jmp 0x23c50
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::execution_is_noop(spirv_cross::SPIRBlock const&, spirv_cross::SPIRBlock const&) const
bool Compiler::execution_is_noop(const SPIRBlock &from, const SPIRBlock &to) const
{
	if (!execution_is_branchless(from, to))
		return false;

	auto *start = &from;
	for (;;)
	{
		if (start->self == to.self)
			return true;

		if (!start->ops.empty())
			return false;

		auto &next = get<SPIRBlock>(start->next_block);
		// Flushing phi variables does not count as noop.
		for (auto &phi : next.phi_variables)
			if (phi.parent == start->self)
				return false;

		start = &next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x23d70
testb $0x1, %al
jne 0x23c96
movb $0x0, -0x1(%rbp)
jmp 0x23d5b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x23cb7
movb $0x1, -0x1(%rbp)
jmp 0x23d5b
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x2fd70
testb $0x1, %al
jne 0x23cd1
movb $0x0, -0x1(%rbp)
jmp 0x23d5b
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x8a70
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2fc30
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2fc60
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2fc90
testb $0x1, %al
jne 0x23d1e
jmp 0x23d4e
leaq -0x40(%rbp), %rdi
callq 0x2fcd0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x23d41
movb $0x0, -0x1(%rbp)
jmp 0x23d5b
jmp 0x23d43
leaq -0x40(%rbp), %rdi
callq 0x2fcf0
jmp 0x23d0b
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x23c9e
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::execution_is_branchless(spirv_cross::SPIRBlock const&, spirv_cross::SPIRBlock const&) const
bool Compiler::execution_is_branchless(const SPIRBlock &from, const SPIRBlock &to) const
{
	auto *start = &from;
	for (;;)
	{
		if (start->self == to.self)
			return true;

		if (start->terminator == SPIRBlock::Direct && start->merge == SPIRBlock::MergeNone)
			start = &get<SPIRBlock>(start->next_block);
		else
			return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x23daa
movb $0x1, -0x1(%rbp)
jmp 0x23ddc
movq -0x28(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x23dd4
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x23dd4
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x8a70
movq %rax, -0x28(%rbp)
jmp 0x23dda
movb $0x0, -0x1(%rbp)
jmp 0x23ddc
jmp 0x23d94
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::continue_block_type(spirv_cross::SPIRBlock const&) const
SPIRBlock::ContinueBlockType Compiler::continue_block_type(const SPIRBlock &block) const
{
	// The block was deemed too complex during code emit, pick conservative fallback paths.
	if (block.complex_continue)
		return SPIRBlock::ComplexLoop;

	// In older glslang output continue block can be equal to the loop header.
	// In this case, execution is clearly branchless, so just assume a while loop header here.
	if (block.merge == SPIRBlock::MergeLoop)
		return SPIRBlock::WhileLoop;

	auto &dominator = get<SPIRBlock>(block.loop_dominator);

	if (execution_is_noop(block, dominator))
		return SPIRBlock::WhileLoop;
	else if (execution_is_branchless(block, dominator))
		return SPIRBlock::ForLoop;
	else
	{
		if (block.merge == SPIRBlock::MergeNone && block.terminator == SPIRBlock::Select &&
		    block.true_block == dominator.self && block.false_block == dominator.merge_block)
		{
			return SPIRBlock::DoWhileLoop;
		}
		else
			return SPIRBlock::ComplexLoop;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0xb1(%rax)
je 0x23e21
movl $0x4, -0x4(%rbp)
jmp 0x23ed2
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x23e37
movl $0x2, -0x4(%rbp)
jmp 0x23ed2
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xb4(%rax), %esi
callq 0x8a70
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x23c60
testb $0x1, %al
jne 0x23e65
jmp 0x23e6e
movl $0x2, -0x4(%rbp)
jmp 0x23ed2
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x23d70
testb $0x1, %al
jne 0x23e85
jmp 0x23e8e
movl $0x1, -0x4(%rbp)
jmp 0x23ed2
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x23ecb
movq -0x18(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x23ecb
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x23ecb
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x23ecb
movl $0x3, -0x4(%rbp)
jmp 0x23ed2
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::traverse_all_reachable_opcodes(spirv_cross::SPIRBlock const&, spirv_cross::Compiler::OpcodeHandler&) const
bool Compiler::traverse_all_reachable_opcodes(const SPIRBlock &block, OpcodeHandler &handler) const
{
	handler.set_current_block(block);

	// Ideally, perhaps traverse the CFG instead of all blocks in order to eliminate dead blocks,
	// but this shouldn't be a problem in practice unless the SPIR-V is doing insane things like recursing
	// inside dead blocks ...
	for (auto &i : block.ops)
	{
		auto ops = stream(i);
		auto op = static_cast<Op>(i.op);

		if (!handler.handle(op, ops, i.length))
			return false;

		if (op == OpFunctionCall)
		{
			auto &func = get<SPIRFunction>(ops[2]);
			if (handler.follow_function_call(func))
			{
				if (!handler.begin_function_scope(ops, i.length))
					return false;
				if (!traverse_all_reachable_opcodes(get<SPIRFunction>(ops[2]), handler))
					return false;
				if (!handler.end_function_scope(ops, i.length))
					return false;
			}
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2e4d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2e500
testb $0x1, %al
jne 0x23f46
jmp 0x24041
leaq -0x30(%rbp), %rdi
callq 0x2e540
movq -0x60(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x2e560
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x23f93
movb $0x0, -0x1(%rbp)
jmp 0x24045
cmpl $0x39, -0x4c(%rbp)
jne 0x24031
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2ede0
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0x23fc5
jmp 0x2402f
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x23fe4
movb $0x0, -0x1(%rbp)
jmp 0x24045
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2ede0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x21b20
testb $0x1, %al
jne 0x2400e
movb $0x0, -0x1(%rbp)
jmp 0x24045
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x2402d
movb $0x0, -0x1(%rbp)
jmp 0x24045
jmp 0x2402f
jmp 0x24031
jmp 0x24033
leaq -0x30(%rbp), %rdi
callq 0x2e690
jmp 0x23f30
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::type_struct_member_offset(spirv_cross::SPIRType const&, unsigned int) const
uint32_t Compiler::type_struct_member_offset(const SPIRType &type, uint32_t index) const
{
	// Decoration must be set in valid SPIR-V, otherwise throw.
	auto &dec = ir.meta[type.self].members.at(index);
	if (dec.decoration_flags.get(DecorationOffset))
		return dec.offset;
	else
		SPIRV_CROSS_THROW("Struct member does not have Offset set.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, %rdi
addq $0xd0, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fdf0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl $0x23, %esi
callq 0xef50
testb $0x1, %al
jne 0x240ad
jmp 0x240bd
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %eax
addq $0x70, %rsp
popq %rbp
retq
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7650
movq -0x60(%rbp), %rdx
leaq 0x11b4ea(%rip), %rsi    # 0x13f5d1
leaq -0x40(%rbp), %rdi
callq 0x7520
jmp 0x240f2
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9c50
jmp 0x24101
movq -0x68(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x189cc8(%rip), %rsi    # 0x1addd8
leaq -0x1a487(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x24166
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x24141
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7708
leaq -0x41(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x55(%rbp)
jne 0x24152
jmp 0x2415b
movq -0x68(%rbp), %rdi
callq 0x72c0
jmp 0x2415d
movq -0x50(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::type_struct_member_array_stride(spirv_cross::SPIRType const&, unsigned int) const
uint32_t Compiler::type_struct_member_array_stride(const SPIRType &type, uint32_t index) const
{
	// Decoration must be set in valid SPIR-V, otherwise throw.
	// ArrayStride is part of the array type not OpMemberDecorate.
	auto &dec = ir.meta[type.member_types[index]].decoration;
	if (dec.decoration_flags.get(DecorationArrayStride))
		return dec.array_stride;
	else
		SPIRV_CROSS_THROW("Struct member does not have ArrayStride set.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
addq $0x30, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8570
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl $0x6, %esi
callq 0xef50
testb $0x1, %al
jne 0x241ce
jmp 0x241de
movq -0x20(%rbp), %rax
movl 0xb8(%rax), %eax
addq $0x70, %rsp
popq %rbp
retq
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7650
movq -0x68(%rbp), %rdx
leaq 0x11b3f1(%rip), %rsi    # 0x13f5f9
leaq -0x40(%rbp), %rdi
callq 0x7520
jmp 0x24213
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9c50
jmp 0x24222
movq -0x70(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x189ba7(%rip), %rsi    # 0x1addd8
leaq -0x1a5a8(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x24287
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x24262
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7708
leaq -0x41(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x55(%rbp)
jne 0x24273
jmp 0x2427c
movq -0x70(%rbp), %rdi
callq 0x72c0
jmp 0x2427e
movq -0x50(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::type_struct_member_matrix_stride(spirv_cross::SPIRType const&, unsigned int) const
uint32_t Compiler::type_struct_member_matrix_stride(const SPIRType &type, uint32_t index) const
{
	// Decoration must be set in valid SPIR-V, otherwise throw.
	// MatrixStride is part of OpMemberDecorate.
	auto &dec = ir.meta[type.self].members[index];
	if (dec.decoration_flags.get(DecorationMatrixStride))
		return dec.matrix_stride;
	else
		SPIRV_CROSS_THROW("Struct member does not have MatrixStride set.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, %rdi
addq $0xd0, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl $0x7, %esi
callq 0xef50
testb $0x1, %al
jne 0x242ed
jmp 0x242fd
movq -0x20(%rbp), %rax
movl 0xbc(%rax), %eax
addq $0x70, %rsp
popq %rbp
retq
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7650
movq -0x60(%rbp), %rdx
leaq 0x11b2ff(%rip), %rsi    # 0x13f626
leaq -0x40(%rbp), %rdi
callq 0x7520
jmp 0x24332
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9c50
jmp 0x24341
movq -0x68(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x189a88(%rip), %rsi    # 0x1addd8
leaq -0x1a6c7(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x243a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x24381
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7708
leaq -0x41(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x55(%rbp)
jne 0x24392
jmp 0x2439b
movq -0x68(%rbp), %rdi
callq 0x72c0
jmp 0x2439d
movq -0x50(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_declared_struct_size(spirv_cross::SPIRType const&) const
size_t Compiler::get_declared_struct_size(const SPIRType &type) const
{
	if (type.member_types.empty())
		SPIRV_CROSS_THROW("Declared struct in block cannot be empty.");

	uint32_t last = uint32_t(type.member_types.size() - 1);
	size_t offset = type_struct_member_offset(type, last);
	size_t size = get_declared_struct_member_size(type, last);
	return offset + size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x8690
testb $0x1, %al
jne 0x243e1
jmp 0x24484
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7650
movq -0x70(%rbp), %rdx
leaq 0x11b249(%rip), %rsi    # 0x13f654
leaq -0x30(%rbp), %rdi
callq 0x7520
jmp 0x24416
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9c50
jmp 0x24425
movq -0x78(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x1899a4(%rip), %rsi    # 0x1addd8
leaq -0x1a7ab(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x244dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x24468
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7708
leaq -0x31(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x45(%rbp)
jne 0x24479
jmp 0x24482
movq -0x78(%rbp), %rdi
callq 0x72c0
jmp 0x244d4
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq -0x68(%rbp), %rdi
subq $0x1, %rax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rsi
movl -0x4c(%rbp), %edx
callq 0x24050
movq -0x68(%rbp), %rdi
movl %eax, %eax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl -0x4c(%rbp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
addq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_declared_struct_size_runtime_array(spirv_cross::SPIRType const&, unsigned long) const
size_t Compiler::get_declared_struct_size_runtime_array(const SPIRType &type, size_t array_size) const
{
	if (type.member_types.empty())
		SPIRV_CROSS_THROW("Declared struct in block cannot be empty.");

	size_t size = get_declared_struct_size(type);
	auto &last_type = get<SPIRType>(type.member_types.back());
	if (!last_type.array.empty() && last_type.array_size_literal[0] && last_type.array[0] == 0) // Runtime array
		size += array_size * type_struct_member_array_stride(type, uint32_t(type.member_types.size() - 1));

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x8690
testb $0x1, %al
jne 0x24515
jmp 0x245bb
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x78(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7650
movq -0x70(%rbp), %rdx
leaq 0x11b115(%rip), %rsi    # 0x13f654
leaq -0x38(%rbp), %rdi
callq 0x7520
jmp 0x2454a
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9c50
jmp 0x24559
movq -0x78(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x189870(%rip), %rsi    # 0x1addd8
leaq -0x1a8df(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x24686
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2459c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7708
leaq -0x39(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x4d(%rbp)
jne 0x245ad
jmp 0x245b6
movq -0x78(%rbp), %rdi
callq 0x72c0
jmp 0x2467d
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x243b0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x2fe30
movq -0x68(%rbp), %rdi
movl (%rax), %esi
callq 0x2e6b0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
callq 0x8690
testb $0x1, %al
jne 0x24670
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x118c0
testb $0x1, %al
jne 0x24610
jmp 0x24670
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8570
cmpl $0x0, (%rax)
jne 0x24670
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq -0x68(%rbp), %rdi
movq -0x88(%rbp), %rsi
subq $0x1, %rax
movl %eax, %edx
callq 0x24170
movl %eax, %ecx
movq -0x80(%rbp), %rax
movl %ecx, %ecx
imulq %rcx, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_active_buffer_ranges(unsigned int) const
std::vector<BufferRange> Compiler::get_active_buffer_ranges(uint32_t id) const
{
	std::vector<BufferRange> ranges;
	BufferAccessHandler handler(*this, ranges, id);
	traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler);
	return ranges;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x2ff90
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x70(%rbp), %rdi
callq 0x2ffb0
jmp 0x24d37
movq -0x90(%rbp), %rdi
movl 0x108(%rdi), %esi
callq 0x2ede0
movq %rax, -0xa0(%rbp)
jmp 0x24d52
movq -0xa0(%rbp), %rsi
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x21b20
jmp 0x24d6b
movb $0x1, -0x15(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x30010
testb $0x1, -0x15(%rbp)
jne 0x24db1
jmp 0x24da5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x24dc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x30010
jmp 0x24dc1
movq -0x88(%rbp), %rdi
callq 0x30050
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x30050
movq -0x78(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::set_execution_mode(spv::ExecutionMode, unsigned int, unsigned int, unsigned int)
void Compiler::set_execution_mode(ExecutionMode mode, uint32_t arg0, uint32_t arg1, uint32_t arg2)
{
	auto &execution = get_entry_point();

	execution.flags.set(mode);
	switch (mode)
	{
	case ExecutionModeLocalSize:
		execution.workgroup_size.x = arg0;
		execution.workgroup_size.y = arg1;
		execution.workgroup_size.z = arg2;
		break;

	case ExecutionModeInvocations:
		execution.invocations = arg0;
		break;

	case ExecutionModeOutputVertices:
		execution.output_vertices = arg0;
		break;

	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
callq 0x300d0
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x2511f
jmp 0x250e2
movl -0x24(%rbp), %eax
subl $0x11, %eax
je 0x250f6
jmp 0x250ec
movl -0x24(%rbp), %eax
subl $0x1a, %eax
je 0x2512e
jmp 0x2513d
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa0(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa4(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa8(%rax)
jmp 0x2513f
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xb0(%rax)
jmp 0x2513f
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xb4(%rax)
jmp 0x2513f
jmp 0x2513f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)