LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, -0x20(%rbp)
movl -0x10(%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
jb 0x556a3
jmp 0x5576b
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movl -0x14(%rbp), %esi
callq 0x30130
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x5574a
jmp 0x556d9
movl -0x34(%rbp), %eax
subl $0xb, %eax
je 0x5570d
jmp 0x556e3
movl -0x34(%rbp), %eax
subl $0x1e, %eax
je 0x5571a
jmp 0x556ed
movl -0x34(%rbp), %eax
subl $0x1f, %eax
je 0x5572a
jmp 0x556f7
movl -0x34(%rbp), %eax
subl $0x23, %eax
je 0x5573a
jmp 0x55701
movl -0x34(%rbp), %eax
subl $0x1603, %eax           # imm = 0x1603
je 0x5575a
jmp 0x55769
movq -0x28(%rbp), %rax
movb $0x0, 0xcc(%rax)
jmp 0x5576b
movq -0x28(%rbp), %rax
movl $0x0, 0xa4(%rax)
jmp 0x5576b
movq -0x28(%rbp), %rax
movl $0x0, 0xa8(%rax)
jmp 0x5576b
movq -0x28(%rbp), %rax
movl $0x0, 0xb4(%rax)
jmp 0x5576b
movq -0x28(%rbp), %rax
movl $0x0, 0xc4(%rax)
jmp 0x5576b
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x74b0
jmp 0x5576b
jmp 0x5576b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
callq 0x8e20
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x557f0
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x55880
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
movq -0x20(%rbp), %rsi
callq 0x55910
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::Bitset::merge_and(spirv_cross::Bitset const&)
inline void merge_and(const Bitset &other)
	{
		lower &= other.lower;
		std::unordered_set<uint32_t> tmp_set;
		for (auto &v : higher)
			if (other.higher.count(v) != 0)
				tmp_set.insert(v);
		higher = std::move(tmp_set);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
andq (%rax), %rcx
movq %rcx, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x13cb0
movq -0x90(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x31e60
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x31e90
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2fed0
testb $0x1, %al
jne 0x55aa3
jmp 0x55b33
leaq -0x58(%rbp), %rdi
callq 0x31ec0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x68(%rbp), %rsi
callq 0x13520
movq %rax, -0x98(%rbp)
jmp 0x55aca
movq -0x98(%rbp), %rax
cmpq $0x0, %rax
je 0x55b23
movq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2e890
movb %dl, -0xa1(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0x55af3
movb -0xa1(%rbp), %al
movq -0xa0(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
jmp 0x55b23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x13900
jmp 0x55b59
jmp 0x55b25
leaq -0x58(%rbp), %rdi
callq 0x31ef0
jmp 0x55a8d
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
callq 0x2ee40
leaq -0x48(%rbp), %rdi
callq 0x13900
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::Variant::operator=(spirv_cross::Variant&&)
Variant &operator=(Variant &&other) SPIRV_CROSS_NOEXCEPT
	{
		if (this != &other)
		{
			holder = std::move(other.holder);
			type = other.type;
			allow_type_rewrite = other.allow_type_rewrite;
			other.type = TypeNone;
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x563d1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x361f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movb 0xc(%rcx), %cl
andb $0x1, %cl
movb %cl, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7530
movq -0x10(%rbp), %rdi
callq 0x7290
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x75a0
jmp 0x577fb
movb $0x0, -0x25(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7330
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7680
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9e140
testb $0x1, %al
jne 0x57834
jmp 0x5789f
leaq -0x38(%rbp), %rdi
callq 0x9e180
movb (%rax), %al
movb %al, -0x41(%rbp)
movsbl -0x41(%rbp), %eax
cmpl $0x5f, %eax
jne 0x5787f
testb $0x1, -0x25(%rbp)
je 0x5786a
jmp 0x57894
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7708
jmp 0x578bc
movq -0x50(%rbp), %rdi
movsbl -0x41(%rbp), %esi
callq 0x7220
jmp 0x57879
movb $0x1, -0x25(%rbp)
jmp 0x57892
movq -0x50(%rbp), %rdi
movsbl -0x41(%rbp), %esi
callq 0x7220
jmp 0x5788e
movb $0x0, -0x25(%rbp)
jmp 0x57894
leaq -0x38(%rbp), %rdi
callq 0x9e1a0
jmp 0x57821
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x578b2
movq -0x50(%rbp), %rdi
callq 0x7708
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, 0x1d0(%rdi)
addq $0x198, %rdi            # imm = 0x198
callq 0x32140
movq -0x30(%rbp), %rdi
movq $0x0, 0x148(%rdi)
addq $0x6e8, %rdi            # imm = 0x6E8
callq 0x9e1c0
movq -0x30(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
callq 0x32140
movq -0x30(%rbp), %rdi
addq $0x488, %rdi            # imm = 0x488
callq 0x9e1e0
movq -0x30(%rbp), %rdi
addq $0x4c0, %rdi            # imm = 0x4C0
callq 0x9e1e0
movq -0x30(%rbp), %rdi
addq $0x4f8, %rdi            # imm = 0x4F8
callq 0x9e1e0
movq -0x30(%rbp), %rdi
addq $0x530, %rdi            # imm = 0x530
callq 0x9e1e0
movq -0x30(%rbp), %rdi
addq $0x568, %rdi            # imm = 0x568
callq 0x9e1e0
movq -0x30(%rbp), %rdi
addq $0x5a0, %rdi            # imm = 0x5A0
callq 0x9e200
movq -0x30(%rbp), %rax
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf940
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf970
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf9a0
testb $0x1, %al
jne 0x579c2
jmp 0x57a4f
leaq -0x18(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x2, %eax
jne 0x579f4
movq -0x28(%rbp), %rdi
callq 0xfd10
movq %rax, %rdi
addq $0x40, %rdi
callq 0x8a00
jmp 0x57a3f
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x9, %eax
jne 0x57a0d
movq -0x28(%rbp), %rdi
callq 0x9e220
jmp 0x57a3d
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x4, %eax
jne 0x57a3b
movq -0x28(%rbp), %rdi
callq 0x1c140
movb $0x0, 0xc8(%rax)
movq -0x28(%rbp), %rdi
callq 0x1c140
movb $0x1, 0xc9(%rax)
jmp 0x57a3d
jmp 0x57a3f
jmp 0x57a41
leaq -0x18(%rbp), %rdi
callq 0xfbd0
jmp 0x579ac
movq -0x30(%rbp), %rax
movl $0x0, 0x750(%rax)
movl $0x0, 0x638(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::fixup_image_load_store_access()
void CompilerGLSL::fixup_image_load_store_access()
{
	for (auto &id : ir.ids)
	{
		if (id.get_type() != TypeVariable)
			continue;

		uint32_t var = id.get<SPIRVariable>().self;
		auto &vartype = expression_type(var);
		if (vartype.basetype == SPIRType::Image)
		{
			// Older glslangValidator does not emit required qualifiers here.
			// Solve this by making the image access as restricted as possible and loosen up if we need to.
			// If any no-read/no-write flags are actually set, assume that the compiler knows what it's doing.

			auto &flags = ir.meta.at(var).decoration.decoration_flags;
			if (!flags.get(DecorationNonWritable) && !flags.get(DecorationNonReadable))
			{
				flags.set(DecorationNonWritable);
				flags.set(DecorationNonReadable);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf940
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf970
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf9a0
testb $0x1, %al
jne 0x58dd0
jmp 0x58e89
leaq -0x18(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x2, %eax
je 0x58df0
jmp 0x58e7b
movq -0x28(%rbp), %rdi
callq 0xfd10
movq -0x48(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
callq 0x1f760
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0xd, 0xc(%rax)
jne 0x58e79
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x2f5c0
addq $0x60, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0xef50
testb $0x1, %al
jne 0x58e77
movq -0x40(%rbp), %rdi
movl $0x19, %esi
callq 0xef50
testb $0x1, %al
jne 0x58e77
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0x300d0
movq -0x40(%rbp), %rdi
movl $0x19, %esi
callq 0x300d0
jmp 0x58e79
jmp 0x58e7b
leaq -0x18(%rbp), %rdi
callq 0xfbd0
jmp 0x58dba
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
addq $0xd0, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5c33e
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, %rdi
callq 0x75f0
testb $0x1, %al
jne 0x5c33e
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x75f0
testb $0x1, %al
jne 0x5c2da
jmp 0x5c2dc
jmp 0x5c33e
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x76d0
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x5c326
movq -0x28(%rbp), %rdi
callq 0x7290
cmpq $0x2, %rax
jb 0x5c326
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x76d0
movsbl (%rax), %edi
callq 0x7320
cmpl $0x0, %eax
je 0x5c326
movq -0x28(%rbp), %rdi
callq 0x74b0
jmp 0x5c33e
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa0, %rsi
movq -0x28(%rbp), %rdx
callq 0x22a50
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, 0x638(%rax)
jne 0x5c411
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7650
movq -0x50(%rbp), %rdx
leaq 0xe8d22(%rip), %rsi     # 0x1450bd
leaq -0x28(%rbp), %rdi
callq 0x7520
jmp 0x5c3a6
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9c50
jmp 0x5c3b5
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x151a14(%rip), %rsi    # 0x1addd8
leaq -0x5273b(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x5c43f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5c3f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7708
leaq -0x29(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x3d(%rbp)
jne 0x5c406
jmp 0x5c40f
movq -0x58(%rbp), %rdi
callq 0x72c0
jmp 0x5c436
movq -0x48(%rbp), %rdi
movl 0x638(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x638(%rdi)
leaq 0xefd23(%rip), %rsi     # 0x14c14e
callq 0xa8e60
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7530
movq -0x18(%rbp), %rdi
movl $0xe, %esi
callq 0xef50
movb %al, -0x2d(%rbp)
jmp 0x5c47b
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x5c484
jmp 0x5c4b2
movq -0x40(%rbp), %rdi
leaq 0xe4acd(%rip), %rsi     # 0x140f5c
callq 0x7340
jmp 0x5c496
jmp 0x5c4b2
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7708
jmp 0x5c5ef
movq -0x18(%rbp), %rdi
movl $0xd, %esi
callq 0xef50
movb %al, -0x41(%rbp)
jmp 0x5c4c5
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5c4ce
jmp 0x5c4e2
movq -0x40(%rbp), %rdi
leaq 0xe4a89(%rip), %rsi     # 0x140f62
callq 0x7340
jmp 0x5c4e0
jmp 0x5c4e2
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0xef50
movb %al, -0x42(%rbp)
jmp 0x5c4f5
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x5c4fe
jmp 0x5c512
movq -0x40(%rbp), %rdi
leaq 0xe4a68(%rip), %rsi     # 0x140f71
callq 0x7340
jmp 0x5c510
jmp 0x5c512
movq -0x18(%rbp), %rdi
movl $0xf, %esi
callq 0xef50
movb %al, -0x43(%rbp)
jmp 0x5c525
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x5c52e
jmp 0x5c542
movq -0x40(%rbp), %rdi
leaq 0xe4a42(%rip), %rsi     # 0x140f7b
callq 0x7340
jmp 0x5c540
jmp 0x5c542
movq -0x18(%rbp), %rdi
movl $0x11, %esi
callq 0xef50
movb %al, -0x44(%rbp)
jmp 0x5c555
movb -0x44(%rbp), %al
testb $0x1, %al
jne 0x5c55e
jmp 0x5c572
movq -0x40(%rbp), %rdi
leaq 0xe4a19(%rip), %rsi     # 0x140f82
callq 0x7340
jmp 0x5c570
jmp 0x5c572
movq -0x18(%rbp), %rdi
movl $0x12, %esi
callq 0xef50
movb %al, -0x45(%rbp)
jmp 0x5c585
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x5c58e
jmp 0x5c5a2
movq -0x40(%rbp), %rdi
leaq 0xe49f1(%rip), %rsi     # 0x140f8a
callq 0x7340
jmp 0x5c5a0
jmp 0x5c5a2
movq -0x18(%rbp), %rdi
movl $0x1387, %esi           # imm = 0x1387
callq 0xef50
movb %al, -0x46(%rbp)
jmp 0x5c5b5
movb -0x46(%rbp), %al
testb $0x1, %al
jne 0x5c5be
jmp 0x5c5d2
movq -0x40(%rbp), %rdi
leaq 0xe49cc(%rip), %rsi     # 0x140f95
callq 0x7340
jmp 0x5c5d0
jmp 0x5c5d2
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5c5e5
movq -0x40(%rbp), %rdi
callq 0x7708
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x5c(%rbp)
addl $-0x4, %eax
subl $0x2, %eax
jb 0x5d4ee
jmp 0x5d4b7
movl -0x5c(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x5d4e2
jmp 0x5d4c4
movl -0x5c(%rbp), %eax
subl $0x9, %eax
je 0x5d4fa
jmp 0x5d4ce
movl -0x5c(%rbp), %eax
subl $0xa, %eax
je 0x5d4ee
jmp 0x5d4d8
movl -0x5c(%rbp), %eax
subl $0xb, %eax
jne 0x5d506
jmp 0x5d4e2
movl $0x8, -0x4(%rbp)
jmp 0x5d5a6
movl $0x4, -0x4(%rbp)
jmp 0x5d5a6
movl $0x2, -0x4(%rbp)
jmp 0x5d5a6
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 0xe3c8e(%rip), %rsi     # 0x1411be
leaq -0x40(%rbp), %rdi
callq 0x7520
jmp 0x5d53b
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9c50
jmp 0x5d54a
movq -0x70(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x15087f(%rip), %rsi    # 0x1addd8
leaq -0x538d0(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x5d5b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5d58a
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 0x5d59b
jmp 0x5d5a4
movq -0x70(%rbp), %rdi
callq 0x72c0
jmp 0x5d5af
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: packing_is_vec4_padded(spirv_cross::BufferPackingStandard)
static bool packing_is_vec4_padded(BufferPackingStandard packing)
{
	switch (packing)
	{
	case BufferPackingHLSLCbuffer:
	case BufferPackingHLSLCbufferPackOffset:
	case BufferPackingStd140:
	case BufferPackingStd140EnhancedLayout:
		return true;

	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x5daba
jmp 0x5daa3
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x5daba
jmp 0x5daad
movl -0xc(%rbp), %eax
addl $-0x4, %eax
subl $0x1, %eax
ja 0x5dac0
jmp 0x5daba
movb $0x1, -0x1(%rbp)
jmp 0x5dac4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0x9c(%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x5db34
jmp 0x5db53
leaq 0xe36ea(%rip), %rdi     # 0x141225
leaq 0xe36ea(%rip), %rsi     # 0x14122c
movl $0x3f4, %edx            # imm = 0x3F4
leaq 0xe36f9(%rip), %rcx     # 0x141247
callq 0x7260
movq -0x40(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0xea90
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x5dbd0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x8690
testb $0x1, %al
jne 0x5db8d
jmp 0x5dbbd
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x5d5c0
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
subl $0x1, %eax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5dbc3
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x8650
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x3dc60
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x5dfa7
jmp 0x5dfc6
leaq 0xe6afe(%rip), %rdi     # 0x144aac
leaq 0xe3277(%rip), %rsi     # 0x14122c
movl $0x2138, %edx           # imm = 0x2138
leaq 0xe6b1f(%rip), %rcx     # 0x144ae0
callq 0x7260
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x118c0
testb $0x1, %al
jne 0x5dfde
jmp 0x5dff7
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8570
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5e02f
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8570
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2e950
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2f560
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: packing_has_flexible_offset(spirv_cross::BufferPackingStandard)
static bool packing_has_flexible_offset(BufferPackingStandard packing)
{
	switch (packing)
	{
	case BufferPackingStd140:
	case BufferPackingStd430:
	case BufferPackingHLSLCbuffer:
		return false;

	default:
		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
jb 0x5e45e
jmp 0x5e454
movl -0xc(%rbp), %eax
subl $0x4, %eax
jne 0x5e464
jmp 0x5e45e
movb $0x0, -0x1(%rbp)
jmp 0x5e468
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: packing_to_substruct_packing(spirv_cross::BufferPackingStandard)
static BufferPackingStandard packing_to_substruct_packing(BufferPackingStandard packing)
{
	switch (packing)
	{
	case BufferPackingStd140EnhancedLayout:
		return BufferPackingStd140;
	case BufferPackingStd430EnhancedLayout:
		return BufferPackingStd430;
	case BufferPackingHLSLCbufferPackOffset:
		return BufferPackingHLSLCbuffer;
	default:
		return packing;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
je 0x5e498
jmp 0x5e484
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x5e4a1
jmp 0x5e48e
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x5e4aa
jmp 0x5e4b3
movl $0x0, -0x4(%rbp)
jmp 0x5e4b9
movl $0x1, -0x4(%rbp)
jmp 0x5e4b9
movl $0x4, -0x4(%rbp)
jmp 0x5e4b9
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x678, %rdi            # imm = 0x678
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x13520
cmpq $0x0, %rax
je 0x601a1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x601e0
jmp 0x601cc
movq -0x18(%rbp), %rax
testb $0x1, 0x43e(%rax)
je 0x601bd
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x605d0
jmp 0x601ca
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x60600
jmp 0x601cc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_push_constant_block_glsl(spirv_cross::SPIRVariable const&)
void CompilerGLSL::emit_push_constant_block_glsl(const SPIRVariable &var)
{
	// OpenGL has no concept of push constant blocks, implement it as a uniform struct.
	auto &type = get<SPIRType>(var.basetype);

	auto &flags = ir.meta[var.self].decoration.decoration_flags;
	flags.clear(DecorationBinding);
	flags.clear(DecorationDescriptorSet);

#if 0
    if (flags & ((1ull << DecorationBinding) | (1ull << DecorationDescriptorSet)))
        SPIRV_CROSS_THROW("Push constant blocks cannot be compiled to GLSL with Binding or Set syntax. "
                            "Remap to location with reflection API first or disable these decorations.");
#endif

	// We're emitting the push constant block as a regular struct, so disable the block qualifier temporarily.
	// Otherwise, we will end up emitting layout() qualifiers on naked structs which is not allowed.
	auto &block_flags = ir.meta[type.self].decoration.decoration_flags;
	bool block_flag = block_flags.get(DecorationBlock);
	block_flags.clear(DecorationBlock);

	emit_struct(type);

	if (block_flag)
		block_flags.set(DecorationBlock);

	emit_uniform(var);
	statement("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x21, %esi
callq 0x30130
movq -0x20(%rbp), %rdi
movl $0x22, %esi
callq 0x30130
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0xef50
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x30130
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5bf00
testb $0x1, -0x29(%rbp)
je 0x606ca
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x300d0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xf8(%rax)
movq -0x38(%rbp), %rdi
leaq 0xde1b8(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_buffer_block(spirv_cross::SPIRVariable const&)
void CompilerGLSL::emit_buffer_block(const SPIRVariable &var)
{
	if (flattened_buffer_blocks.count(var.self))
		emit_buffer_block_flattened(var);
	else if (is_legacy() || (!options.es && options.version == 130))
		emit_buffer_block_legacy(var);
	else
		emit_buffer_block_native(var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x678, %rdi            # imm = 0x678
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x13520
cmpq $0x0, %rax
je 0x60741
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x601e0
jmp 0x60789
movq -0x18(%rbp), %rdi
callq 0x9f610
testb $0x1, %al
jne 0x6076b
movq -0x18(%rbp), %rax
testb $0x1, 0x43c(%rax)
jne 0x6077a
movq -0x18(%rbp), %rax
cmpl $0x82, 0x438(%rax)
jne 0x6077a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x60790
jmp 0x60787
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x60950
jmp 0x60789
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::emit_buffer_block_legacy(spirv_cross::SPIRVariable const&)
void CompilerGLSL::emit_buffer_block_legacy(const SPIRVariable &var)
{
	auto &type = get<SPIRType>(var.basetype);
	bool ssbo = var.storage == StorageClassStorageBuffer ||
	            ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
	if (ssbo)
		SPIRV_CROSS_THROW("SSBOs not supported in legacy targets.");

	// We're emitting the push constant block as a regular struct, so disable the block qualifier temporarily.
	// Otherwise, we will end up emitting layout() qualifiers on naked structs which is not allowed.
	auto &block_flags = ir.meta[type.self].decoration.decoration_flags;
	bool block_flag = block_flags.get(DecorationBlock);
	block_flags.clear(DecorationBlock);
	emit_struct(type);
	if (block_flag)
		block_flags.set(DecorationBlock);
	emit_uniform(var);
	statement("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0xc, 0x10(%rcx)
movb %al, -0x62(%rbp)
je 0x607f8
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0x60, %rdi
movl $0x3, %esi
callq 0xef50
movb %al, -0x62(%rbp)
movb -0x62(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x608b0
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x80(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7650
movq -0x78(%rbp), %rdx
leaq 0xe0c82(%rip), %rsi     # 0x1414b6
leaq -0x40(%rbp), %rdi
callq 0x7520
jmp 0x6083f
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9c50
jmp 0x6084e
movq -0x80(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x14d57b(%rip), %rsi    # 0x1addd8
leaq -0x56bd4(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x60947
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x60891
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 0x608a2
jmp 0x608ab
movq -0x80(%rbp), %rdi
callq 0x72c0
jmp 0x6093e
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
addq $0x60, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movl $0x2, %esi
callq 0xef50
andb $0x1, %al
movb %al, -0x61(%rbp)
movq -0x60(%rbp), %rdi
movl $0x2, %esi
callq 0x30130
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5bf00
testb $0x1, -0x61(%rbp)
je 0x60914
movq -0x60(%rbp), %rdi
movl $0x2, %esi
callq 0x300d0
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xf8(%rax)
movq -0x70(%rbp), %rdi
leaq 0xddf6e(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::add_variable(std::unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CompilerGLSL::add_variable(unordered_set<string> &variables, string &name)
{
	if (name.empty())
		return;

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

	// Avoid double underscores.
	name = sanitize_underscores(name);

	update_name_cache(variables, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x75f0
testb $0x1, %al
jne 0x611ab
jmp 0x611ad
jmp 0x6122b
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x76d0
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x611f7
movq -0x18(%rbp), %rdi
callq 0x7290
cmpq $0x2, %rax
jb 0x611f7
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x76d0
movsbl (%rax), %edi
callq 0x7320
cmpl $0x0, %eax
je 0x611f7
movq -0x18(%rbp), %rdi
callq 0x74b0
jmp 0x6122b
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x577c0
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7430
leaq -0x38(%rbp), %rdi
callq 0x7708
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x22a50
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::end_scope_decl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CompilerGLSL::end_scope_decl(const string &decl)
{
	if (!indent)
		SPIRV_CROSS_THROW("Popping empty indent stack.");
	indent--;
	statement("} ", decl, ";");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, 0x638(%rax)
jne 0x61305
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7650
movq -0x58(%rbp), %rdx
leaq 0xe3e2e(%rip), %rsi     # 0x1450bd
leaq -0x30(%rbp), %rdi
callq 0x7520
jmp 0x6129a
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9c50
jmp 0x612a9
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x14cb20(%rip), %rsi    # 0x1addd8
leaq -0x5762f(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x6133e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x612e9
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 0x612fa
jmp 0x61303
movq -0x60(%rbp), %rdi
callq 0x72c0
jmp 0x61335
movq -0x50(%rbp), %rdi
movl 0x638(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x638(%rdi)
movq -0x10(%rbp), %rdx
leaq 0xe3db6(%rip), %rsi     # 0x1450d9
leaq 0xe7d7c(%rip), %rcx     # 0x1490a6
callq 0xa9860
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7640
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_storage_qualifiers_glsl(spirv_cross::SPIRVariable const&)
const char *CompilerGLSL::to_storage_qualifiers_glsl(const SPIRVariable &var)
{
	auto &execution = get_entry_point();

	if (var.storage == StorageClassInput || var.storage == StorageClassOutput)
	{
		if (is_legacy() && execution.model == ExecutionModelVertex)
			return var.storage == StorageClassInput ? "attribute " : "varying ";
		else if (is_legacy() && execution.model == ExecutionModelFragment)
			return "varying "; // Fragment outputs are renamed so they never hit this case.
		else
			return var.storage == StorageClassInput ? "in " : "out ";
	}
	else if (var.storage == StorageClassUniformConstant || var.storage == StorageClassUniform ||
	         var.storage == StorageClassPushConstant)
	{
		return "uniform ";
	}

	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x25150
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0x61ad9
movq -0x18(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x61b65
movq -0x28(%rbp), %rdi
callq 0x9f610
testb $0x1, %al
jne 0x61ae8
jmp 0x61b1a
movq -0x20(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
jne 0x61b1a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0xdfa7f(%rip), %rax     # 0x141582
leaq 0xdfa6d(%rip), %rcx     # 0x141577
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x61b9d
movq -0x28(%rbp), %rdi
callq 0x9f610
testb $0x1, %al
jne 0x61b29
jmp 0x61b43
movq -0x20(%rbp), %rax
cmpl $0x4, 0xb8(%rax)
jne 0x61b43
leaq 0xdfa45(%rip), %rax     # 0x141582
movq %rax, -0x8(%rbp)
jmp 0x61b9d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0xe2f56(%rip), %rax     # 0x144aa7
leaq 0xdfa33(%rip), %rcx     # 0x14158b
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x61b9d
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x61b83
movq -0x18(%rbp), %rax
cmpl $0x2, 0x10(%rax)
je 0x61b83
movq -0x18(%rbp), %rax
cmpl $0x9, 0x10(%rax)
jne 0x61b90
leaq 0xdf972(%rip), %rax     # 0x1414fc
movq %rax, -0x8(%rbp)
jmp 0x61b9d
jmp 0x61b92
leaq 0xdcd05(%rip), %rax     # 0x13e89e
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::to_member_name[abi:cxx11](spirv_cross::SPIRType const&, unsigned int)
string CompilerGLSL::to_member_name(const SPIRType &type, uint32_t index)
{
	auto &memb = ir.meta[type.self].members;
	if (index < memb.size() && !memb[index].alias.empty())
		return memb[index].alias;
	else
		return join("_m", index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
addq $0xd0, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x622c8
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, %rdi
callq 0x75f0
testb $0x1, %al
jne 0x622c8
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x7170
jmp 0x622dc
movq -0x40(%rbp), %rdi
leaq 0xe2778(%rip), %rsi     # 0x144a4b
leaq -0x1c(%rbp), %rdx
callq 0xa6f20
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::replace_fragment_outputs()
void CompilerGLSL::replace_fragment_outputs()
{
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeVariable)
		{
			auto &var = id.get<SPIRVariable>();
			auto &type = get<SPIRType>(var.basetype);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf940
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf970
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf9a0
testb $0x1, %al
jne 0x6fc70
jmp 0x6fcfa
leaq -0x18(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x2, %eax
jne 0x6fcea
movq -0x28(%rbp), %rdi
callq 0xfd10
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
callq 0x205a0
testb $0x1, %al
jne 0x6fce8
movq -0x30(%rbp), %rax
testb $0x1, 0x5b(%rax)
jne 0x6fce8
movq -0x38(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x6fce8
movq -0x30(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x6fce8
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6f820
jmp 0x6fcea
jmp 0x6fcec
leaq -0x18(%rbp), %rdi
callq 0xfbd0
jmp 0x6fc5a
addq $0x40, %rsp
popq %rbp
retq
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::index_to_swizzle(unsigned int)
const char *CompilerGLSL::index_to_swizzle(uint32_t index)
{
	switch (index)
	{
	case 0:
		return "x";
	case 1:
		return "y";
	case 2:
		return "z";
	case 3:
		return "w";
	default:
		SPIRV_CROSS_THROW("Swizzle index out of range");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x58(%rbp)
subq $0x3, %rax
ja 0x70170
movq -0x58(%rbp), %rax
leaq 0xd00a1(%rip), %rcx     # 0x1401c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd412a(%rip), %rax     # 0x144261
movq %rax, -0x8(%rbp)
jmp 0x70210
leaq 0xd50d3(%rip), %rax     # 0x14521a
movq %rax, -0x8(%rbp)
jmp 0x70210
leaq 0xd50c6(%rip), %rax     # 0x14521d
movq %rax, -0x8(%rbp)
jmp 0x70210
leaq 0xd50b9(%rip), %rax     # 0x145220
movq %rax, -0x8(%rbp)
jmp 0x70210
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7650
movq -0x60(%rbp), %rdx
leaq 0xd37e7(%rip), %rsi     # 0x143981
leaq -0x38(%rbp), %rdi
callq 0x7520
jmp 0x701a5
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9c50
jmp 0x701b4
movq -0x68(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x13dc15(%rip), %rsi    # 0x1addd8
leaq -0x6653a(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x70223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x701f4
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 0x70205
jmp 0x7020e
movq -0x68(%rbp), %rdi
callq 0x72c0
jmp 0x7021a
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.cpp
// Function: spirv_cross::CompilerGLSL::pls_decl[abi:cxx11](spirv_cross::PlsRemap const&)
string CompilerGLSL::pls_decl(const PlsRemap &var)
{
	auto &variable = get<SPIRVariable>(var.id);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x178(%rbp)
movq %rdi, %rax
movq %rax, -0x170(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x168(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xfec0
movq %rax, -0x20(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x31440
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x95010
movl %eax, -0x15c(%rbp)
jmp 0x70bb2
movl -0x15c(%rbp), %eax
movl %eax, -0xe4(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x960f0
movl %eax, -0x17c(%rbp)
jmp 0x70bd2
movl -0x17c(%rbp), %eax
movl %eax, -0xec(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x96140
movq %rax, -0x188(%rbp)
jmp 0x70bf3
movq -0x168(%rbp), %rdi
movq -0x188(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x20(%rbp), %rsi
callq 0x96030
movq %rax, -0x190(%rbp)
jmp 0x70c1a
movq -0x168(%rbp), %rsi
movq -0x190(%rbp), %rax
movq %rax, -0x118(%rbp)
movq (%rsi), %rax
movq 0x98(%rax), %rax
leaq -0x138(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
xorl %ecx, %ecx
callq *%rax
jmp 0x70c4d
movq -0x168(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq -0x158(%rbp), %rdi
movl $0x1, %ecx
callq *%rax
jmp 0x70c72
movq -0x178(%rbp), %rdi
leaq 0xcdc1d(%rip), %r8      # 0x13e89d
leaq -0x110(%rbp), %rsi
leaq -0x118(%rbp), %rdx
leaq -0x138(%rbp), %rcx
leaq -0x158(%rbp), %r9
callq 0xa74e0
jmp 0x70ca3
leaq -0x158(%rbp), %rdi
callq 0x7708
leaq -0x138(%rbp), %rdi
callq 0x7708
leaq -0xf8(%rbp), %rdi
callq 0x314e0
movq -0x170(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0x70d29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0x70d1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x7708
leaq -0x138(%rbp), %rdi
callq 0x7708
leaq -0xf8(%rbp), %rdi
callq 0x314e0
movq -0x100(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)