LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::buffer_is_hlsl_counter_buffer(unsigned int) const
bool Compiler::buffer_is_hlsl_counter_buffer(uint32_t id) const
{
	// First, check for the proper decoration.
	if (ir.meta.at(id).hlsl_is_magic_counter_buffer)
		return true;

	// Check for legacy fallback method.
	// FIXME: This should be deprecated eventually.

	if (ir.meta.at(id).hlsl_magic_counter_buffer_candidate)
	{
		auto *var = maybe_get<SPIRVariable>(id);
		// Ensure that this is actually a buffer object.
		return var && (var->storage == StorageClassStorageBuffer ||
		               has_decoration(get<SPIRType>(var->basetype).self, DecorationBufferBlock));
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa50
testb $0x1, 0x141(%rax)
je 0x2bf0b
movb $0x1, -0x1(%rbp)
jmp 0x2bf8d
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa50
testb $0x1, 0x140(%rax)
je 0x2bf89
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2ecf0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0x2bf7f
movq -0x20(%rbp), %rcx
movb $0x1, %al
cmpl $0xc, 0x10(%rcx)
movb %al, -0x2a(%rbp)
je 0x2bf79
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2e6b0
movq -0x28(%rbp), %rdi
movl 0x8(%rax), %esi
movl $0x3, %edx
callq 0x1f560
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2bf8d
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::buffer_get_hlsl_counter_buffer(unsigned int, unsigned int&) const
bool Compiler::buffer_get_hlsl_counter_buffer(uint32_t id, uint32_t &counter_id) const
{
	// First, check for the proper decoration.
	if (ir.meta[id].hlsl_magic_counter_buffer != 0)
	{
		counter_id = ir.meta[id].hlsl_magic_counter_buffer;
		return true;
	}

	// Check for legacy fallback method.
	// FIXME: This should be deprecated eventually.

	auto &name = get_name(id);
	uint32_t id_bound = get_current_id_bound();
	for (uint32_t i = 0; i < id_bound; i++)
	{
		if (ir.meta[i].hlsl_magic_counter_buffer_candidate && ir.meta[i].hlsl_magic_counter_buffer_name == name)
		{
			auto *var = maybe_get<SPIRVariable>(i);
			// Ensure that this is actually a buffer object.
			if (var && (var->storage == StorageClassStorageBuffer ||
			            has_decoration(get<SPIRType>(var->basetype).self, DecorationBufferBlock)))
			{
				counter_id = i;
				return true;
			}
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
cmpl $0x0, 0x144(%rax)
je 0x2c001
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movl 0x144(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2c0ef
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x23340
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x82e0
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x2c0eb
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
testb $0x1, 0x140(%rax)
je 0x2c0db
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, %rdi
addq $0x120, %rdi            # imm = 0x120
movq -0x28(%rbp), %rsi
callq 0x32740
testb $0x1, %al
jne 0x2c082
jmp 0x2c0db
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x2ecf0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2c0d9
movq -0x38(%rbp), %rax
cmpl $0xc, 0x10(%rax)
je 0x2c0ca
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2e6b0
movq -0x40(%rbp), %rdi
movl 0x8(%rax), %esi
movl $0x3, %edx
callq 0x1f560
testb $0x1, %al
jne 0x2c0ca
jmp 0x2c0d9
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2c0ef
jmp 0x2c0db
jmp 0x2c0dd
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c024
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::combined_decoration_for_member(spirv_cross::SPIRType const&, unsigned int) const
Bitset Compiler::combined_decoration_for_member(const SPIRType &type, uint32_t index) const
{
	Bitset flags;
	auto &memb = ir.meta[type.self].members;
	if (index >= memb.size())
		return flags;
	auto &dec = memb[index];

	// If our type is a struct, traverse all the members as well recursively.
	flags.merge_or(dec.decoration_flags);
	for (uint32_t i = 0; i < type.member_types.size(); i++)
		flags.merge_or(combined_decoration_for_member(get<SPIRType>(type.member_types[i]), i));

	return flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x10710
movq -0x98(%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, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jb 0x2c6f8
movb $0x1, -0x1d(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x2c7fb
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
movq -0xa8(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
addq $0x60, %rsi
callq 0x32b70
jmp 0x2c720
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x2c7f0
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x8570
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x2e6b0
movq %rax, -0xb8(%rbp)
jmp 0x2c77a
movq -0xb8(%rbp), %rdx
movq -0x98(%rbp), %rsi
movl -0x48(%rbp), %ecx
leaq -0x88(%rbp), %rdi
callq 0x2c660
jmp 0x2c799
movq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x32b70
jmp 0x2c7ae
leaq -0x88(%rbp), %rdi
callq 0xf250
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x2c727
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2c81d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xf250
jmp 0x2c81d
movb $0x1, -0x1d(%rbp)
movl $0x1, -0x2c(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x2c80d
movq -0xa8(%rbp), %rdi
callq 0xf250
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0xf250
movq -0x40(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::is_desktop_only_format(spv::ImageFormat)
bool Compiler::is_desktop_only_format(spv::ImageFormat format)
{
	switch (format)
	{
	// Desktop-only formats
	case ImageFormatR11fG11fB10f:
	case ImageFormatR16f:
	case ImageFormatRgb10A2:
	case ImageFormatR8:
	case ImageFormatRg8:
	case ImageFormatR16:
	case ImageFormatRg16:
	case ImageFormatRgba16:
	case ImageFormatR16Snorm:
	case ImageFormatRg16Snorm:
	case ImageFormatRgba16Snorm:
	case ImageFormatR8Snorm:
	case ImageFormatRg8Snorm:
	case ImageFormatR8ui:
	case ImageFormatRg8ui:
	case ImageFormatR16ui:
	case ImageFormatRgb10a2ui:
	case ImageFormatR8i:
	case ImageFormatRg8i:
	case ImageFormatR16i:
		return true;
	default:
		break;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x8, %eax
subl $0xd, %eax
jb 0x2c87b
jmp 0x2c857
movl -0xc(%rbp), %eax
addl $-0x1b, %eax
subl $0x3, %eax
jb 0x2c87b
jmp 0x2c864
movl -0xc(%rbp), %eax
subl $0x22, %eax
je 0x2c87b
jmp 0x2c86e
movl -0xc(%rbp), %eax
addl $-0x25, %eax
subl $0x2, %eax
ja 0x2c881
jmp 0x2c87b
movb $0x1, -0x1(%rbp)
jmp 0x2c887
jmp 0x2c883
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::SPIRConstant::make_null(spirv_cross::SPIRType const&)
inline void make_null(const SPIRType &constant_type_)
	{
		m = {};
		m.columns = constant_type_.columns;
		for (auto &c : m.c)
			c.vecsize = constant_type_.vecsize;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x41450
movq -0x130(%rbp), %rdi
addq $0x10, %rdi
leaq -0x108(%rbp), %rsi
movl $0xf4, %edx
callq 0x72e0
movq -0x130(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x100(%rax)
addq $0x10, %rax
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x110(%rbp), %rax
addq $0xe0, %rax
movq %rax, -0x120(%rbp)
movq -0x118(%rbp), %rax
cmpq -0x120(%rbp), %rax
je 0x32a9a
movq -0x118(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x128(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x118(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x118(%rbp)
jmp 0x32a57
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::Variant::operator=(spirv_cross::Variant const&)
Variant &operator=(const Variant &other)
	{
#ifdef SPIRV_CROSS_COPY_CONSTRUCTOR_SANITIZE
		abort();
#endif
		if (this != &other)
		{
			holder.reset();
			if (other.holder)
				holder = other.holder->clone();
			type = other.type;
			allow_type_rewrite = other.allow_type_rewrite;
		}
		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, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x360a1
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x361a0
movq -0x10(%rbp), %rdi
callq 0x9c20
testb $0x1, %al
jne 0x3605a
jmp 0x36086
movq -0x10(%rbp), %rdi
callq 0x361d0
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x18(%rbp), %rdi
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x361f0
leaq -0x18(%rbp), %rdi
callq 0x18450
movq -0x20(%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 -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::Bitset::operator==(spirv_cross::Bitset const&) const
inline bool operator==(const Bitset &other) const
	{
		if (lower != other.lower)
			return false;

		if (higher.size() != other.higher.size())
			return false;

		for (auto &v : higher)
			if (other.higher.count(v) == 0)
				return false;

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x4139d
movb $0x0, -0x1(%rbp)
jmp 0x41441
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x31c80
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x31c80
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x413cd
movb $0x0, -0x1(%rbp)
jmp 0x41441
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x31ca0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x31cd0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fed0
testb $0x1, %al
jne 0x41406
jmp 0x4143d
leaq -0x28(%rbp), %rdi
callq 0x31d00
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
callq 0x13520
cmpq $0x0, %rax
jne 0x41430
movb $0x0, -0x1(%rbp)
jmp 0x41441
jmp 0x41432
leaq -0x28(%rbp), %rdi
callq 0x31d30
jmp 0x413f3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::SPIRAccessChain& spirv_cross::variant_set<spirv_cross::SPIRAccessChain, unsigned int const&, spv::StorageClass const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&>(spirv_cross::Variant&, unsigned int const&, spv::StorageClass const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&)
T &variant_set(Variant &var, P &&... args)
{
	auto uptr = std::unique_ptr<T>(new T(std::forward<P>(args)...));
	auto ptr = uptr.get();
	var.set(std::move(uptr), T::type);
	return *ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x68, %edi
callq 0x7360
movq %rax, -0xb0(%rbp)
movb $0x1, -0x89(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xa4(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x7170
jmp 0xed292
movq -0x28(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x7170
jmp 0xed2a4
movl -0xa4(%rbp), %edx
movl -0xa8(%rbp), %esi
movq -0xb0(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %r9d
leaq -0x58(%rbp), %rcx
leaq -0x88(%rbp), %r8
callq 0xed410
jmp 0xed2d0
movq -0xb0(%rbp), %rsi
movb $0x0, -0x89(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xed4d0
leaq -0x88(%rbp), %rdi
callq 0x7708
leaq -0x58(%rbp), %rdi
callq 0x7708
movq -0xc8(%rbp), %rdi
callq 0xed500
movq -0xc8(%rbp), %rsi
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xed530
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl $0xc, %edx
callq 0x4c740
jmp 0xed355
leaq -0xa0(%rbp), %rdi
callq 0x18450
movq -0x98(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xed580
movq -0xd0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xed3c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xed3bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x7708
leaq -0x58(%rbp), %rdi
callq 0x7708
testb $0x1, -0x89(%rbp)
jne 0xed3d0
jmp 0xed3e1
movq -0xb0(%rbp), %rdi
movl $0x68, %esi
callq 0x7370
jmp 0xed404
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x18450
leaq -0x38(%rbp), %rdi
callq 0xed580
movq -0x60(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::Variant::set(std::unique_ptr<spirv_cross::IVariant, std::default_delete<spirv_cross::IVariant>>, unsigned int)
void set(std::unique_ptr<IVariant> val, uint32_t new_type)
	{
		holder = std::move(val);
		if (!allow_type_rewrite && type != TypeNone && type != new_type)
			SPIRV_CROSS_THROW("Overwriting a variant with new type.");
		type = new_type;
		allow_type_rewrite = false;
	}

// 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
movq %rdi, -0x58(%rbp)
callq 0x361f0
movq -0x58(%rbp), %rax
testb $0x1, 0xc(%rax)
jne 0x4c82c
movq -0x58(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x4c82c
movq -0x58(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x4c82c
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 0xf32eb(%rip), %rsi     # 0x13faa1
leaq -0x38(%rbp), %rdi
callq 0x7520
jmp 0x4c7c1
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9c50
jmp 0x4c7d0
movq -0x68(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x1615f9(%rip), %rsi    # 0x1addd8
leaq -0x42b56(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x4c849
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4c810
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 0x4c821
jmp 0x4c82a
movq -0x68(%rbp), %rdi
callq 0x72c0
jmp 0x4c840
movq -0x58(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movb $0x0, 0xc(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_member_name[abi:cxx11](unsigned int, unsigned int) const
const string &ParsedIR::get_member_name(uint32_t id, uint32_t index) const
{
	auto &m = meta[id];
	if (index >= m.members.size())
	{
		static string empty;
		return empty;
	}

	return m.members[index].alias;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x541b4
cmpb $0x0, 0x15b516(%rip)    # 0x1af678
jne 0x541a7
leaq 0x15b50d(%rip), %rdi    # 0x1af678
callq 0x7670
cmpl $0x0, %eax
je 0x541a7
leaq 0x15b4dc(%rip), %rdi    # 0x1af658
callq 0x7530
movq 0x15ae58(%rip), %rdi    # 0x1aefe0
leaq 0x15b4c9(%rip), %rsi    # 0x1af658
leaq 0x15b1ea(%rip), %rdx    # 0x1af380
callq 0x7300
leaq 0x15b4d6(%rip), %rdi    # 0x1af678
callq 0x7250
leaq 0x15b4aa(%rip), %rax    # 0x1af658
movq %rax, -0x8(%rbp)
jmp 0x541cd
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
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_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_name(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_name(uint32_t id, const string &name)
{
	auto &str = meta[id].decoration.alias;
	str.clear();

	if (name.empty())
		return;

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

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

	str = ensure_valid_identifier(name, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x74b0
movq -0x18(%rbp), %rdi
callq 0x75f0
testb $0x1, %al
jne 0x54228
jmp 0x5422d
jmp 0x54376
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x28(%rbp)
testb $0x1, 0x10a(%rax)
je 0x542f5
movq -0x18(%rbp), %rdi
callq 0x7290
cmpq $0x6, %rax
jb 0x542f5
movq -0x18(%rbp), %rdi
leaq 0xebbd7(%rip), %rsi     # 0x13fe4c
xorl %eax, %eax
movl %eax, %edx
callq 0x76c0
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7290
movq %rax, %rcx
movq -0x78(%rbp), %rax
subq $0x6, %rcx
cmpq %rcx, %rax
jne 0x542f5
movq -0x28(%rbp), %rax
movb $0x1, 0x140(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xebb93(%rip), %rsi     # 0x13fe4c
xorl %eax, %eax
movl %eax, %edx
callq 0x76c0
movq -0x80(%rbp), %rsi
movq %rax, %rcx
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x73a0
movq -0x28(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x48(%rbp), %rsi
callq 0x7430
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x54310
movq -0x28(%rbp), %rax
movb $0x0, 0x140(%rax)
movq -0x28(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x74b0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x73e0
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x54351
movq -0x18(%rbp), %rdi
callq 0x7290
cmpq $0x2, %rax
jb 0x54351
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x73e0
movsbl (%rax), %edi
callq 0x7320
cmpl $0x0, %eax
je 0x54351
jmp 0x54376
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
xorl %edx, %edx
callq 0x54380
movq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7430
leaq -0x68(%rbp), %rdi
callq 0x7708
addq $0x80, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_member_name(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_member_name(uint32_t id, uint32_t index, const string &name)
{
	meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));

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

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

	str = ensure_valid_identifier(name, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq -0x58(%rbp), %rdi
addq $0xd0, %rax
movq %rax, -0x60(%rbp)
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9730
movq -0x60(%rbp), %rdi
movq (%rax), %rsi
callq 0x2f9a0
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0xd0, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x74b0
movq -0x18(%rbp), %rdi
callq 0x75f0
testb $0x1, %al
jne 0x546b1
jmp 0x546b3
jmp 0x54732
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x73e0
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x5470a
movq -0x18(%rbp), %rdi
callq 0x7290
cmpq $0x3, %rax
jb 0x5470a
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x73e0
movsbl (%rax), %eax
cmpl $0x6d, %eax
jne 0x5470a
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x73e0
movsbl (%rax), %edi
callq 0x7320
cmpl $0x0, %eax
je 0x5470a
jmp 0x54732
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x1, %edx
callq 0x54380
movq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7430
leaq -0x50(%rbp), %rdi
callq 0x7708
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_decoration_string(unsigned int, spv::Decoration, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_decoration_string(uint32_t id, Decoration decoration, const string &argument)
{
	auto &dec = meta[id].decoration;
	dec.decoration_flags.set(decoration);

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

	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0x10(%rbp), %esi
callq 0x300d0
movl -0x10(%rbp), %eax
subl $0x1603, %eax           # imm = 0x1603
jne 0x5479b
jmp 0x54788
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x7050
jmp 0x5479d
jmp 0x5479d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_member_decoration(unsigned int, unsigned int, spv::Decoration, unsigned int)
void ParsedIR::set_member_decoration(uint32_t id, uint32_t index, Decoration decoration, uint32_t argument)
{
	meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));
	auto &dec = meta[id].members[index];
	dec.decoration_flags.set(decoration);

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

	case DecorationLocation:
		dec.location = argument;
		break;

	case DecorationComponent:
		dec.component = argument;
		break;

	case DecorationBinding:
		dec.binding = argument;
		break;

	case DecorationOffset:
		dec.offset = argument;
		break;

	case DecorationSpecId:
		dec.spec_id = argument;
		break;

	case DecorationMatrixStride:
		dec.matrix_stride = argument;
		break;

	case DecorationIndex:
		dec.index = argument;
		break;

	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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
addq $0x30, %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq -0x40(%rbp), %rdi
addq $0xd0, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
incq %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9730
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x2f9a0
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0xd0, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movl -0x14(%rbp), %esi
callq 0x300d0
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x22, %eax
ja 0x54afe
movq -0x38(%rbp), %rax
leaq 0xeb216(%rip), %rcx     # 0x13fc88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movb $0x1, 0xcc(%rax)
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xa0(%rax)
jmp 0x54b00
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xa4(%rax)
jmp 0x54b00
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xa8(%rax)
jmp 0x54b00
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xb0(%rax)
jmp 0x54b00
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xb4(%rax)
jmp 0x54b00
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc4(%rax)
jmp 0x54b00
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xbc(%rax)
jmp 0x54b00
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc8(%rax)
jmp 0x54b00
jmp 0x54b00
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::mark_used_as_array_length(unsigned int)
void ParsedIR::mark_used_as_array_length(uint32_t id)
{
	switch (ids[id].get_type())
	{
	case TypeConstant:
		get<SPIRConstant>(id).is_used_as_array_length = true;
		break;

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

	case TypeUndef:
		break;

	default:
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xbdb0
movq %rax, %rdi
callq 0xfa00
movl %eax, %ecx
movl %ecx, -0x38(%rbp)
subl $0x3, %eax
je 0x54b64
jmp 0x54b49
movl -0x38(%rbp), %eax
subl $0xa, %eax
je 0x54b7c
jmp 0x54b53
movl -0x38(%rbp), %eax
subl $0xd, %eax
je 0x54bec
jmp 0x54bee
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x559a0
movb $0x1, 0x109(%rax)
jmp 0x54c0d
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x559d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x86d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8700
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8730
testb $0x1, %al
jne 0x54bc5
jmp 0x54bea
leaq -0x28(%rbp), %rdi
callq 0x8770
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
callq 0x54b10
leaq -0x28(%rbp), %rdi
callq 0x8790
jmp 0x54bb2
jmp 0x54c0d
jmp 0x54c0d
leaq 0xf859a(%rip), %rdi     # 0x14d18f
leaq 0xeb257(%rip), %rsi     # 0x13fe53
movl $0x113, %edx            # imm = 0x113
leaq 0xeb271(%rip), %rcx     # 0x13fe79
callq 0x7260
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::get_buffer_block_flags(spirv_cross::SPIRVariable const&) const
Bitset ParsedIR::get_buffer_block_flags(const SPIRVariable &var) const
{
	auto &type = get<SPIRType>(var.basetype);
	assert(type.basetype == SPIRType::Struct);

	// Some flags like non-writable, non-readable are actually found
	// as member decorations. If all members have a decoration set, propagate
	// the decoration up as a regular variable decoration.
	Bitset base_flags = meta[var.self].decoration.decoration_flags;

	if (type.member_types.empty())
		return base_flags;

	Bitset all_members_flags = get_member_decoration_bitset(type.self, 0);
	for (uint32_t i = 1; i < uint32_t(type.member_types.size()); i++)
		all_members_flags.merge_and(get_member_decoration_bitset(type.self, i));

	base_flags.merge_or(all_members_flags);
	return base_flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x55a00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, 0xc(%rax)
jne 0x54c6c
jmp 0x54c8b
leaq 0xeb246(%rip), %rdi     # 0x13feb9
leaq 0xeb1d9(%rip), %rsi     # 0x13fe53
movl $0x11a, %edx            # imm = 0x11A
leaq 0xeb255(%rip), %rcx     # 0x13fedb
callq 0x7260
movq -0x80(%rbp), %rdi
movb $0x0, -0x21(%rbp)
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
addq $0x60, %rsi
callq 0xef10
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x8690
testb $0x1, %al
jne 0x54ccb
jmp 0x54cdb
movb $0x1, -0x21(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x54db8
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
xorl %edx, %edx
callq 0x54df0
movq %rax, -0x98(%rbp)
jmp 0x54cf6
movq -0x98(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xef10
jmp 0x54d08
movl $0x1, -0x78(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq %rax, %rcx
movl -0x9c(%rbp), %eax
cmpl %ecx, %eax
jae 0x54d92
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x78(%rbp), %edx
callq 0x54df0
movq %rax, -0xa8(%rbp)
jmp 0x54d4e
movq -0xa8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x55a30
jmp 0x54d60
jmp 0x54d62
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x54d0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x54dda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf250
jmp 0x54dda
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x32b70
jmp 0x54da4
movb $0x1, -0x21(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf250
testb $0x1, -0x21(%rbp)
jne 0x54dca
movq -0x90(%rbp), %rdi
callq 0xf250
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xf250
movq -0x70(%rbp), %rdi
callq 0x7640
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_member_decoration_bitset(unsigned int, unsigned int) const
const Bitset &ParsedIR::get_member_decoration_bitset(uint32_t id, uint32_t index) const
{
	auto &m = meta[id];
	if (index >= m.members.size())
	{
		static const Bitset cleared = {};
		return cleared;
	}

	return m.members[index].decoration_flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x54ea7
cmpb $0x0, 0x15a87e(%rip)    # 0x1af6c0
jne 0x54e9a
leaq 0x15a875(%rip), %rdi    # 0x1af6c0
callq 0x7670
cmpl $0x0, %eax
je 0x54e9a
leaq 0x15a824(%rip), %rdi    # 0x1af680
xorl %esi, %esi
movl $0x40, %edx
callq 0x71d0
leaq 0x15a811(%rip), %rdi    # 0x1af680
callq 0x10710
leaq -0x45c2b(%rip), %rdi    # 0xf250
leaq 0x15a7fe(%rip), %rsi    # 0x1af680
leaq 0x15a4f7(%rip), %rdx    # 0x1af380
callq 0x7300
leaq 0x15a82b(%rip), %rdi    # 0x1af6c0
callq 0x7250
leaq 0x15a7df(%rip), %rax    # 0x1af680
movq %rax, -0x8(%rbp)
jmp 0x54ec4
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
addq $0x60, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_decoration(unsigned int, spv::Decoration) const
uint32_t ParsedIR::get_decoration(uint32_t id, Decoration decoration) const
{
	auto &dec = meta[id].decoration;
	if (!dec.decoration_flags.get(decoration))
		return 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0x18(%rbp), %esi
callq 0xef50
testb $0x1, %al
jne 0x54f98
movl $0x0, -0x4(%rbp)
jmp 0x55072
movl -0x18(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x2a, %eax
ja 0x5506b
movq -0x28(%rbp), %rax
leaq 0xead5d(%rip), %rcx     # 0x13fd14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl 0xa0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xa4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xc0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xc4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xb8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xbc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movq -0x20(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55072
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_decoration_string[abi:cxx11](unsigned int, spv::Decoration) const
const string &ParsedIR::get_decoration_string(uint32_t id, Decoration decoration) const
{
	auto &dec = meta[id].decoration;
	static const string empty;

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

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

	default:
		return empty;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, -0x20(%rbp)
cmpb $0x0, 0x15a639(%rip)    # 0x1af6e8
jne 0x550f4
leaq 0x15a630(%rip), %rdi    # 0x1af6e8
callq 0x7670
cmpl $0x0, %eax
je 0x550f4
leaq 0x15a5ff(%rip), %rdi    # 0x1af6c8
callq 0x7530
movq 0x159f0b(%rip), %rdi    # 0x1aefe0
leaq 0x15a5ec(%rip), %rsi    # 0x1af6c8
leaq 0x15a29d(%rip), %rdx    # 0x1af380
callq 0x7300
leaq 0x15a5f9(%rip), %rdi    # 0x1af6e8
callq 0x7250
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0x18(%rbp), %esi
callq 0xef50
testb $0x1, %al
jne 0x55115
leaq 0x15a5b9(%rip), %rax    # 0x1af6c8
movq %rax, -0x8(%rbp)
jmp 0x5513a
movl -0x18(%rbp), %eax
subl $0x1603, %eax           # imm = 0x1603
jne 0x5512f
jmp 0x55121
movq -0x20(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
jmp 0x5513a
leaq 0x15a592(%rip), %rax    # 0x1af6c8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::unset_decoration(unsigned int, spv::Decoration)
void ParsedIR::unset_decoration(uint32_t id, Decoration decoration)
{
	auto &dec = meta[id].decoration;
	dec.decoration_flags.clear(decoration);
	switch (decoration)
	{
	case DecorationBuiltIn:
		dec.builtin = false;
		break;

	case DecorationLocation:
		dec.location = 0;
		break;

	case DecorationComponent:
		dec.component = 0;
		break;

	case DecorationOffset:
		dec.offset = 0;
		break;

	case DecorationBinding:
		dec.binding = 0;
		break;

	case DecorationDescriptorSet:
		dec.set = 0;
		break;

	case DecorationInputAttachmentIndex:
		dec.input_attachment = 0;
		break;

	case DecorationSpecId:
		dec.spec_id = 0;
		break;

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

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

	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movl -0x10(%rbp), %esi
callq 0x30130
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x5528e
jmp 0x5519d
movl -0x24(%rbp), %eax
subl $0xb, %eax
je 0x55212
jmp 0x551a7
movl -0x24(%rbp), %eax
subl $0x1e, %eax
je 0x55222
jmp 0x551b1
movl -0x24(%rbp), %eax
subl $0x1f, %eax
je 0x55235
jmp 0x551bb
movl -0x24(%rbp), %eax
subl $0x21, %eax
je 0x5525b
jmp 0x551c9
movl -0x24(%rbp), %eax
subl $0x22, %eax
je 0x5526e
jmp 0x551d7
movl -0x24(%rbp), %eax
subl $0x23, %eax
je 0x55248
jmp 0x551e1
movl -0x24(%rbp), %eax
subl $0x2b, %eax
je 0x5527e
jmp 0x551ef
movl -0x24(%rbp), %eax
subl $0x1602, %eax           # imm = 0x1602
je 0x552ad
jmp 0x551ff
movl -0x24(%rbp), %eax
subl $0x1603, %eax           # imm = 0x1603
je 0x5529e
jmp 0x552fa
movq -0x18(%rbp), %rax
movb $0x0, 0xcc(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rax
movl $0x0, 0xa4(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rax
movl $0x0, 0xa8(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rax
movl $0x0, 0xb4(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rax
movl $0x0, 0xb0(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rax
movl $0x0, 0xac(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rax
movl $0x0, 0xc0(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rax
movl $0x0, 0xc4(%rax)
jmp 0x552fc
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x74b0
jmp 0x552fc
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
addq $0x144, %rax            # imm = 0x144
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x552f8
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0xead0
movb $0x0, 0x141(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0x552fc
jmp 0x552fc
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_member_decoration(unsigned int, unsigned int, spv::Decoration) const
uint32_t ParsedIR::get_member_decoration(uint32_t id, uint32_t index, Decoration decoration) const
{
	auto &m = meta[id];
	if (index >= m.members.size())
		return 0;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jb 0x553aa
movl $0x0, -0x4(%rbp)
jmp 0x55477
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movl -0x1c(%rbp), %esi
callq 0xef50
testb $0x1, %al
jne 0x553e3
movl $0x0, -0x4(%rbp)
jmp 0x55477
movl -0x1c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x22, %eax
ja 0x55470
movq -0x40(%rbp), %rax
leaq 0xea9c2(%rip), %rcx     # 0x13fdc0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movl 0xa0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55477
movq -0x30(%rbp), %rax
movl 0xa4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55477
movq -0x30(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55477
movq -0x30(%rbp), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55477
movq -0x30(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55477
movq -0x30(%rbp), %rax
movl 0xc4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55477
movq -0x30(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x55477
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::set_member_decoration_string(unsigned int, unsigned int, spv::Decoration, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ParsedIR::set_member_decoration_string(uint32_t id, uint32_t index, Decoration decoration, const string &argument)
{
	meta[id].members.resize(max(meta[id].members.size(), size_t(index) + 1));
	auto &dec = meta[id].members[index];
	dec.decoration_flags.set(decoration);

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

	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq -0x40(%rbp), %rdi
addq $0xd0, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
incq %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9730
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x2f9a0
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0xd0, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movl -0x14(%rbp), %esi
callq 0x300d0
movl -0x14(%rbp), %eax
subl $0x1603, %eax           # imm = 0x1603
jne 0x55552
jmp 0x5553f
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0x7050
jmp 0x55554
jmp 0x55554
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross_parsed_ir.cpp
// Function: spirv_cross::ParsedIR::get_member_decoration_string[abi:cxx11](unsigned int, unsigned int, spv::Decoration) const
const string &ParsedIR::get_member_decoration_string(uint32_t id, uint32_t index, Decoration decoration) const
{
	static const string empty;
	auto &m = meta[id];

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

	auto &dec = m.members[index];

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

	default:
		return empty;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpb $0x0, 0x15a18c(%rip)    # 0x1af710
jne 0x555c9
leaq 0x15a183(%rip), %rdi    # 0x1af710
callq 0x7670
cmpl $0x0, %eax
je 0x555c9
leaq 0x15a152(%rip), %rdi    # 0x1af6f0
callq 0x7530
movq 0x159a36(%rip), %rdi    # 0x1aefe0
leaq 0x15a13f(%rip), %rsi    # 0x1af6f0
leaq 0x159dc8(%rip), %rdx    # 0x1af380
callq 0x7300
leaq 0x15a14c(%rip), %rdi    # 0x1af710
callq 0x7250
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x55310
testb $0x1, %al
jne 0x55602
leaq 0x15a0f4(%rip), %rax    # 0x1af6f0
movq %rax, -0x8(%rbp)
jmp 0x55640
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2ecd0
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1603, %eax           # imm = 0x1603
jne 0x55635
jmp 0x55627
movq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
jmp 0x55640
leaq 0x15a0b4(%rip), %rax    # 0x1af6f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)