LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_work_group_size_specialization_constants(spirv_cross::SpecializationConstant&, spirv_cross::SpecializationConstant&, spirv_cross::SpecializationConstant&) const
uint32_t Compiler::get_work_group_size_specialization_constants(SpecializationConstant &x, SpecializationConstant &y,
                                                                SpecializationConstant &z) const
{
	auto &execution = get_entry_point();
	x = { 0, 0 };
	y = { 0, 0 };
	z = { 0, 0 };

	if (execution.workgroup_size.constant != 0)
	{
		auto &c = get<SPIRConstant>(execution.workgroup_size.constant);

		if (c.m.c[0].id[0] != 0)
		{
			x.id = c.m.c[0].id[0];
			x.constant_id = get_decoration(c.m.c[0].id[0], DecorationSpecId);
		}

		if (c.m.c[0].id[1] != 0)
		{
			y.id = c.m.c[0].id[1];
			y.constant_id = get_decoration(c.m.c[0].id[1], DecorationSpecId);
		}

		if (c.m.c[0].id[2] != 0)
		{
			z.id = c.m.c[0].id[2];
			z.constant_id = get_decoration(c.m.c[0].id[2], DecorationSpecId);
		}
	}

	return execution.workgroup_size.constant;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x25030
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xac(%rax)
je 0x2531d
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0xac(%rax), %esi
callq 0x2e950
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x252b1
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movl 0x30(%rax), %esi
movl $0x1, %edx
callq 0x23520
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x48(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x252e6
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movl 0x34(%rax), %esi
movl $0x1, %edx
callq 0x23520
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x48(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x2531b
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movl 0x38(%rax), %esi
movl $0x1, %edx
callq 0x23520
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x2531d
movq -0x28(%rbp), %rax
movl 0xac(%rax), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_execution_mode_argument(spv::ExecutionMode, unsigned int) const
uint32_t Compiler::get_execution_mode_argument(spv::ExecutionMode mode, uint32_t index) const
{
	auto &execution = get_entry_point();
	switch (mode)
	{
	case ExecutionModeLocalSize:
		switch (index)
		{
		case 0:
			return execution.workgroup_size.x;
		case 1:
			return execution.workgroup_size.y;
		case 2:
			return execution.workgroup_size.z;
		default:
			return 0;
		}

	case ExecutionModeInvocations:
		return execution.invocations;

	case ExecutionModeOutputVertices:
		return execution.output_vertices;

	default:
		return 0;
	}
}

// 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
callq 0x25030
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x253c5
jmp 0x2535b
movl -0x24(%rbp), %eax
subl $0x11, %eax
je 0x2536f
jmp 0x25365
movl -0x24(%rbp), %eax
subl $0x1a, %eax
je 0x253d4
jmp 0x253e3
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x2538f
jmp 0x2537b
movl -0x28(%rbp), %eax
subl $0x1, %eax
je 0x2539e
jmp 0x25385
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x253ad
jmp 0x253bc
movq -0x20(%rbp), %rax
movl 0xa0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x253ea
movq -0x20(%rbp), %rax
movl 0xa4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x253ea
movq -0x20(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x253ea
movl $0x0, -0x4(%rbp)
jmp 0x253ea
movq -0x20(%rbp), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x253ea
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x253ea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_entry_points[abi:cxx11]() const
vector<string> Compiler::get_entry_points() const
{
	vector<string> entries;
	for (auto &entry : ir.entry_points)
		entries.push_back(entry.second.orig_name);
	return entries;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x30390
movq -0x50(%rbp), %rax
addq $0x8, %rax
addq $0xc8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x303b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x303e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2f500
testb $0x1, %al
jne 0x257eb
jmp 0x2582f
leaq -0x28(%rbp), %rdi
callq 0x30410
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
callq 0x30440
jmp 0x2580b
jmp 0x2580d
leaq -0x28(%rbp), %rdi
callq 0x304b0
jmp 0x257d8
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x14cd0
jmp 0x2584c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x25842
movq -0x60(%rbp), %rdi
callq 0x14cd0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_entry_points_and_stages() const
vector<EntryPoint> Compiler::get_entry_points_and_stages() const
{
	vector<EntryPoint> entries;
	for (auto &entry : ir.entry_points)
		entries.push_back({ entry.second.orig_name, entry.second.model });
	return entries;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x304e0
movq -0x78(%rbp), %rax
addq $0x8, %rax
addq $0xc8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x303b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x303e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2f500
testb $0x1, %al
jne 0x258d1
jmp 0x25949
leaq -0x28(%rbp), %rdi
callq 0x30410
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
leaq -0x60(%rbp), %rdi
callq 0x7170
jmp 0x258f1
movq -0x88(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0xc0(%rax), %eax
movl %eax, -0x40(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x30500
jmp 0x25910
leaq -0x60(%rbp), %rdi
callq 0x30530
leaq -0x28(%rbp), %rdi
callq 0x304b0
jmp 0x258be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2596c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x30530
jmp 0x2596c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2595f
movq -0x88(%rbp), %rdi
callq 0x30550
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x30550
movq -0x68(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_first_entry_point(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SPIREntryPoint &Compiler::get_first_entry_point(const std::string &name)
{
	auto itr = find_if(
	    begin(ir.entry_points), end(ir.entry_points),
	    [&](const std::pair<uint32_t, SPIREntryPoint> &entry) -> bool { return entry.second.orig_name == name; });

	if (itr == end(ir.entry_points))
		SPIRV_CROSS_THROW("Entry point does not exist.");

	return itr->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
addq $0xc8, %rdi
callq 0x305b0
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
addq $0xc8, %rdi
callq 0x305e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x25f70
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
addq $0xc8, %rdi
callq 0x305e0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x30610
testb $0x1, %al
jne 0x25a72
jmp 0x25b1e
movb $0x1, -0x6d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7650
movq -0x80(%rbp), %rdx
leaq 0x119c4a(%rip), %rsi    # 0x13f6e9
leaq -0x58(%rbp), %rdi
callq 0x7520
jmp 0x25aaa
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9c50
jmp 0x25abc
movq -0x88(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x18830a(%rip), %rsi    # 0x1addd8
leaq -0x1be45(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x25b3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x25aff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x59(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x6d(%rbp)
jne 0x25b10
jmp 0x25b1c
movq -0x88(%rbp), %rdi
callq 0x72c0
jmp 0x25b34
leaq -0x18(%rbp), %rdi
callq 0x30640
addq $0x8, %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_entry_point(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spv::ExecutionModel)
SPIREntryPoint &Compiler::get_entry_point(const std::string &name, ExecutionModel model)
{
	auto itr = find_if(begin(ir.entry_points), end(ir.entry_points),
	                   [&](const std::pair<uint32_t, SPIREntryPoint> &entry) -> bool {
		                   return entry.second.orig_name == name && entry.second.model == model;
	                   });

	if (itr == end(ir.entry_points))
		SPIRV_CROSS_THROW("Entry point does not exist.");

	return itr->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
addq $0xc8, %rdi
callq 0x305b0
movq -0x88(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
addq $0xc8, %rdi
callq 0x305e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x26030
movq -0x88(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
addq $0xc8, %rdi
callq 0x305e0
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x30610
testb $0x1, %al
jne 0x25c4a
jmp 0x25cfc
movb $0x1, -0x7d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7650
movq -0x90(%rbp), %rdx
leaq 0x119a6c(%rip), %rsi    # 0x13f6e9
leaq -0x68(%rbp), %rdi
callq 0x7520
jmp 0x25c88
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9c50
jmp 0x25c9a
movq -0x98(%rbp), %rdi
movb $0x0, -0x7d(%rbp)
leaq 0x18812c(%rip), %rsi    # 0x1addd8
leaq -0x1c023(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x25d1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x25cdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7708
leaq -0x69(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x7d(%rbp)
jne 0x25cee
jmp 0x25cfa
movq -0x98(%rbp), %rdi
callq 0x72c0
jmp 0x25d12
leaq -0x20(%rbp), %rdi
callq 0x30640
addq $0x8, %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::CombinedImageSamplerHandler::push_remap_parameters(spirv_cross::SPIRFunction const&, unsigned int const*, unsigned int)
void Compiler::CombinedImageSamplerHandler::push_remap_parameters(const SPIRFunction &func, const uint32_t *args,
                                                                  uint32_t length)
{
	// If possible, pipe through a remapping table so that parameters know
	// which variables they actually bind to in this scope.
	unordered_map<uint32_t, uint32_t> remapping;
	for (uint32_t i = 0; i < length; i++)
		remapping[func.arguments[i].id] = remap_parameter(args[i]);
	parameter_remapping.push(move(remapping));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x30830
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x2639b
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl (%rax,%rcx,4), %esi
callq 0x263d0
movl %eax, -0x7c(%rbp)
jmp 0x26342
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x30880
movq %rax, %rsi
addq $0x4, %rsi
leaq -0x58(%rbp), %rdi
callq 0x30850
movq %rax, -0x88(%rbp)
jmp 0x2636d
movq -0x88(%rbp), %rax
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x26322
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x150d0
jmp 0x263c0
movq -0x78(%rbp), %rdi
addq $0x10, %rdi
leaq -0x58(%rbp), %rsi
callq 0x308a0
jmp 0x263ae
leaq -0x58(%rbp), %rdi
callq 0x150d0
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::CombinedImageSamplerHandler::remap_parameter(unsigned int)
uint32_t Compiler::CombinedImageSamplerHandler::remap_parameter(uint32_t id)
{
	auto *var = compiler.maybe_get_backing_variable(id);
	if (var)
		id = var->self;

	if (parameter_remapping.empty())
		return id;

	auto &remapping = parameter_remapping.top();
	auto itr = remapping.find(id);
	if (itr != end(remapping))
		return itr->second;
	else
		return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x1fa90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26408
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
callq 0x308f0
testb $0x1, %al
jne 0x2641b
jmp 0x26423
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2647c
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
callq 0x30910
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x30930
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30990
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x30960
testb $0x1, %al
jne 0x26465
jmp 0x26476
leaq -0x30(%rbp), %rdi
callq 0x309c0
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2647c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::CombinedImageSamplerHandler::begin_function_scope(unsigned int const*, unsigned int)
bool Compiler::CombinedImageSamplerHandler::begin_function_scope(const uint32_t *args, uint32_t length)
{
	if (length < 3)
		return false;

	auto &callee = compiler.get<SPIRFunction>(args[2]);
	args += 3;
	length -= 3;
	push_remap_parameters(callee, args, length);
	functions.push(&callee);
	return true;
}

// 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)
cmpl $0x3, -0x1c(%rbp)
jae 0x264d7
movb $0x0, -0x1(%rbp)
jmp 0x26535
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x106d0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x262f0
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x309f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::build_combined_image_samplers()
void Compiler::build_combined_image_samplers()
{
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeFunction)
		{
			auto &func = id.get<SPIRFunction>();
			func.combined_parameters.clear();
			func.shadow_arguments.clear();
			func.do_combined_parameters = true;
		}
	}

	combined_image_samplers.clear();
	CombinedImageSamplerHandler handler(*this);
	traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%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 0x27e33
jmp 0x27e90
leaq -0x18(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x4, %eax
jne 0x27e83
movq -0x28(%rbp), %rdi
callq 0x1c140
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x80, %rdi
callq 0x31570
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x31590
movq -0x30(%rbp), %rax
movb $0x1, 0xca(%rax)
jmp 0x27e85
leaq -0x18(%rbp), %rdi
callq 0xfbd0
jmp 0x27e20
movq -0xf8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x315b0
movq -0xf8(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x315d0
movq -0xf8(%rbp), %rdi
movl 0x108(%rdi), %esi
callq 0x106d0
movq %rax, -0x100(%rbp)
jmp 0x27ed1
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
callq 0x21b20
jmp 0x27eed
leaq -0xe0(%rbp), %rdi
callq 0x31660
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x31660
movq -0xe8(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_specialization_constants() const
vector<SpecializationConstant> Compiler::get_specialization_constants() const
{
	vector<SpecializationConstant> spec_consts;
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeConstant)
		{
			auto &c = id.get<SPIRConstant>();
			if (c.specialization && has_decoration(c.self, DecorationSpecId))
				spec_consts.push_back({ c.self, get_decoration(c.self, DecorationSpecId) });
		}
	}
	return spec_consts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x316b0
movq -0x60(%rbp), %rax
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ef20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ef50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2ef80
testb $0x1, %al
jne 0x27f9f
jmp 0x28092
leaq -0x28(%rbp), %rdi
callq 0x2efc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xfa00
movl %eax, -0x74(%rbp)
jmp 0x27fba
movl -0x74(%rbp), %eax
cmpl $0x3, %eax
jne 0x28082
movq -0x38(%rbp), %rdi
callq 0x316d0
movq %rax, -0x80(%rbp)
jmp 0x27fd5
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
testb $0x1, 0x108(%rax)
je 0x28080
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x1, %edx
callq 0x1f560
movb %al, -0x81(%rbp)
jmp 0x2800b
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x28017
jmp 0x28080
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x58(%rbp)
leaq -0x54(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x50(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x1, %edx
callq 0x23520
movl %eax, -0x88(%rbp)
jmp 0x28049
movq -0x70(%rbp), %rdi
movq -0x90(%rbp), %rax
movl -0x88(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x58(%rbp), %rsi
callq 0x31880
jmp 0x28067
jmp 0x28080
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x318b0
jmp 0x280b2
jmp 0x28082
jmp 0x28084
leaq -0x28(%rbp), %rdi
callq 0x2f1e0
jmp 0x27f89
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x280a5
movq -0x70(%rbp), %rdi
callq 0x318b0
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: exists_unaccessed_path_to_return(spirv_cross::CFG const&, unsigned int, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>> const&)
static bool exists_unaccessed_path_to_return(const CFG &cfg, uint32_t block, const unordered_set<uint32_t> &blocks)
{
	// This block accesses the variable.
	if (blocks.find(block) != end(blocks))
		return false;

	// We are at the end of the CFG.
	if (cfg.get_succeeding_edges(block).empty())
		return true;

	// If any of our successors have a path to the end, there exists a path from block.
	for (auto &succ : cfg.get_succeeding_edges(block))
		if (exists_unaccessed_path_to_return(cfg, succ, blocks))
			return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2eb60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2eb90
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fed0
testb $0x1, %al
jne 0x28324
jmp 0x2832d
movb $0x0, -0x1(%rbp)
jmp 0x283c7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x320b0
movq %rax, %rdi
callq 0x8690
testb $0x1, %al
jne 0x28347
jmp 0x2834d
movb $0x1, -0x1(%rbp)
jmp 0x283c7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x320b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xbaf0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xbb20
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2e710
testb $0x1, %al
jne 0x2838a
jmp 0x283c3
leaq -0x40(%rbp), %rdi
callq 0x2e750
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
callq 0x282e0
testb $0x1, %al
jne 0x283b0
jmp 0x283b6
movb $0x1, -0x1(%rbp)
jmp 0x283c7
jmp 0x283b8
leaq -0x40(%rbp), %rdi
callq 0x2e770
jmp 0x28377
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler::notify_variable_access(unsigned int, unsigned int)
void Compiler::AnalyzeVariableScopeAccessHandler::notify_variable_access(uint32_t id, uint32_t block)
{
	if (id_is_phi_variable(id))
		accessed_variables_to_block[id].insert(block);
	else if (id_is_potential_temporary(id))
		accessed_temporaries_to_block[id].insert(block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x287b0
testb $0x1, %al
jne 0x28628
jmp 0x2864e
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
leaq -0xc(%rbp), %rsi
callq 0x31a50
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x2e890
movq %rax, -0x20(%rbp)
movb %dl, -0x18(%rbp)
jmp 0x28686
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x28830
testb $0x1, %al
jne 0x28660
jmp 0x28684
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
leaq -0xc(%rbp), %rsi
callq 0x31a50
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x2e890
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
jmp 0x28686
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler::id_is_phi_variable(unsigned int) const
bool Compiler::AnalyzeVariableScopeAccessHandler::id_is_phi_variable(uint32_t id) const
{
	if (id >= compiler.get_current_id_bound())
		return false;
	auto *var = compiler.maybe_get<SPIRVariable>(id);
	return var && var->phi_variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x8(%rax), %rdi
callq 0x82e0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jb 0x287e5
movb $0x0, -0x1(%rbp)
jmp 0x28817
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x116b0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
je 0x2880f
movq -0x20(%rbp), %rax
movb 0x5a(%rax), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler::id_is_potential_temporary(unsigned int) const
bool Compiler::AnalyzeVariableScopeAccessHandler::id_is_potential_temporary(uint32_t id) const
{
	if (id >= compiler.get_current_id_bound())
		return false;

	// Temporaries are not created before we start emitting code.
	return compiler.ir.ids[id].empty() || (compiler.ir.ids[id].get_type() == TypeExpression);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x82e0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jb 0x28865
movb $0x0, -0x1(%rbp)
jmp 0x288c6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xbdb0
movq %rax, %rdi
callq 0x31a80
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x288be
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xbdb0
movq %rax, %rdi
callq 0xfa00
cmpl $0x9, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::instruction_to_result_type(unsigned int&, unsigned int&, spv::Op, unsigned int const*, unsigned int)
bool Compiler::instruction_to_result_type(uint32_t &result_type, uint32_t &result_id, spv::Op op, const uint32_t *args,
                                          uint32_t length)
{
	// Most instructions follow the pattern of <result-type> <result-id> <arguments>.
	// There are some exceptions.
	switch (op)
	{
	case OpStore:
	case OpCopyMemory:
	case OpCopyMemorySized:
	case OpImageWrite:
	case OpAtomicStore:
	case OpAtomicFlagClear:
	case OpEmitStreamVertex:
	case OpEndStreamPrimitive:
	case OpControlBarrier:
	case OpMemoryBarrier:
	case OpGroupWaitEvents:
	case OpRetainEvent:
	case OpReleaseEvent:
	case OpSetUserEventStatus:
	case OpCaptureEventProfilingInfo:
	case OpCommitReadPipe:
	case OpCommitWritePipe:
	case OpGroupCommitReadPipe:
	case OpGroupCommitWritePipe:
		return false;

	default:
		if (length > 1)
		{
			result_type = args[0];
			result_id = args[1];
			return true;
		}
		else
			return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
addl $-0x3e, %eax
subl $0x3, %eax
jb 0x2926b
jmp 0x291df
movl -0x38(%rbp), %eax
subl $0x63, %eax
je 0x2926b
jmp 0x291ed
movl -0x38(%rbp), %eax
addl $0xffffff24, %eax       # imm = 0xFFFFFF24
subl $0x2, %eax
jb 0x2926b
jmp 0x291fc
movl -0x38(%rbp), %eax
addl $0xffffff20, %eax       # imm = 0xFFFFFF20
subl $0x2, %eax
jb 0x2926b
jmp 0x2920b
movl -0x38(%rbp), %eax
subl $0xe4, %eax
je 0x2926b
jmp 0x29217
movl -0x38(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x2926b
jmp 0x29223
movl -0x38(%rbp), %eax
addl $0xfffffee8, %eax       # imm = 0xFFFFFEE8
subl $0x2, %eax
jb 0x2926b
jmp 0x29232
movl -0x38(%rbp), %eax
addl $0xfffffee1, %eax       # imm = 0xFFFFFEE1
subl $0x2, %eax
jb 0x2926b
jmp 0x29241
movl -0x38(%rbp), %eax
addl $0xfffffed7, %eax       # imm = 0xFFFFFED7
subl $0x2, %eax
jb 0x2926b
jmp 0x29250
movl -0x38(%rbp), %eax
addl $0xfffffed3, %eax       # imm = 0xFFFFFED3
subl $0x2, %eax
jb 0x2926b
jmp 0x2925f
movl -0x38(%rbp), %eax
subl $0x13f, %eax            # imm = 0x13F
jne 0x29271
jmp 0x2926b
movb $0x0, -0x1(%rbp)
jmp 0x2929a
cmpl $0x1, -0x34(%rbp)
jbe 0x29296
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2929a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::StaticExpressionAccessHandler::handle(spv::Op, unsigned int const*, unsigned int)
bool Compiler::StaticExpressionAccessHandler::handle(spv::Op op, const uint32_t *args, uint32_t length)
{
	switch (op)
	{
	case OpStore:
		if (length < 2)
			return false;
		if (args[0] == variable_id)
		{
			static_expression = args[1];
			write_count++;
		}
		break;

	case OpLoad:
		if (length < 3)
			return false;
		if (args[2] == variable_id && static_expression == 0) // Tried to read from variable before it was initialized.
			return false;
		break;

	case OpAccessChain:
	case OpInBoundsAccessChain:
		if (length < 3)
			return false;
		if (args[2] == variable_id) // If we try to access chain our candidate variable before we store to it, bail.
			return false;
		break;

	default:
		break;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x3d, %eax
je 0x293a8
jmp 0x29357
movl -0x28(%rbp), %eax
subl $0x3e, %eax
je 0x29371
jmp 0x29361
movl -0x28(%rbp), %eax
addl $-0x41, %eax
subl $0x2, %eax
jb 0x293d6
jmp 0x293fa
cmpl $0x2, -0x24(%rbp)
jae 0x29380
movb $0x0, -0x1(%rbp)
jmp 0x29400
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl 0x10(%rcx), %eax
jne 0x293a6
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x14(%rax)
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x293fc
cmpl $0x3, -0x24(%rbp)
jae 0x293b4
movb $0x0, -0x1(%rbp)
jmp 0x29400
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x10(%rcx), %eax
jne 0x293d4
movq -0x30(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x293d4
movb $0x0, -0x1(%rbp)
jmp 0x29400
jmp 0x293fc
cmpl $0x3, -0x24(%rbp)
jae 0x293e2
movb $0x0, -0x1(%rbp)
jmp 0x29400
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x10(%rcx), %eax
jne 0x293f8
movb $0x0, -0x1(%rbp)
jmp 0x29400
jmp 0x293fc
jmp 0x293fc
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cfg.hpp
// Function: void spirv_cross::CFG::walk_from<spirv_cross::Compiler::analyze_variable_scope(spirv_cross::SPIRFunction&, spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler&)::$_0>(std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>>&, unsigned int, spirv_cross::Compiler::analyze_variable_scope(spirv_cross::SPIRFunction&, spirv_cross::Compiler::AnalyzeVariableScopeAccessHandler&)::$_0 const&) const
void walk_from(std::unordered_set<uint32_t> &seen_blocks, uint32_t block, const Op &op) const
	{
		if (seen_blocks.count(block))
			return;
		seen_blocks.insert(block);

		op(block);
		for (auto b : succeeding_edges[block])
			walk_from(seen_blocks, b, op);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x13520
cmpq $0x0, %rax
je 0x2a647
jmp 0x2a6d7
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2e890
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e0c0
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x40a20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xbaf0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xbb20
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2e710
testb $0x1, %al
jne 0x2a6aa
jmp 0x2a6d7
leaq -0x40(%rbp), %rdi
callq 0x2e750
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rsi
movl -0x4c(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x2a610
leaq -0x40(%rbp), %rdi
callq 0x2e770
jmp 0x2a697
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::get_common_basic_type(spirv_cross::SPIRType const&, spirv_cross::SPIRType::BaseType&)
bool Compiler::get_common_basic_type(const SPIRType &type, SPIRType::BaseType &base_type)
{
	if (type.basetype == SPIRType::Struct)
	{
		base_type = SPIRType::Unknown;
		for (auto &member_type : type.member_types)
		{
			SPIRType::BaseType member_base;
			if (!get_common_basic_type(get<SPIRType>(member_type), member_base))
				return false;

			if (base_type == SPIRType::Unknown)
				base_type = member_base;
			else if (base_type != member_base)
				return false;
		}
		return true;
	}
	else
	{
		base_type = type.basetype;
		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xc, 0xc(%rax)
jne 0x2a80d
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbaf0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbb20
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2e710
testb $0x1, %al
jne 0x2a79d
jmp 0x2a807
leaq -0x30(%rbp), %rdi
callq 0x2e750
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %esi
callq 0xea90
movq -0x50(%rbp), %rdi
movq %rax, %rsi
leaq -0x44(%rbp), %rdx
callq 0x2a730
testb $0x1, %al
jne 0x2a7d3
movb $0x0, -0x1(%rbp)
jmp 0x2a81e
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2a7e7
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x2a7fa
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x44(%rbp), %eax
je 0x2a7f8
movb $0x0, -0x1(%rbp)
jmp 0x2a81e
jmp 0x2a7fa
jmp 0x2a7fc
leaq -0x30(%rbp), %rdi
callq 0x2e770
jmp 0x2a78a
movb $0x1, -0x1(%rbp)
jmp 0x2a81e
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
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_cross.cpp
// Function: spirv_cross::Compiler::update_active_builtins()
void Compiler::update_active_builtins()
{
	active_input_builtins.reset();
	active_output_builtins.reset();
	cull_distance_count = 0;
	clip_distance_count = 0;
	ActiveBuiltinHandler handler(*this);
	traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x2d0, %rdi            # imm = 0x2D0
callq 0x30d60
movq -0x38(%rbp), %rdi
addq $0x310, %rdi            # imm = 0x310
callq 0x30d60
movq -0x38(%rbp), %rsi
movl $0x0, 0x354(%rsi)
movl $0x0, 0x350(%rsi)
leaq -0x18(%rbp), %rdi
callq 0x32190
movq -0x38(%rbp), %rdi
movl 0x108(%rdi), %esi
callq 0x106d0
movq %rax, -0x30(%rbp)
jmp 0x2b166
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x21b20
jmp 0x2b179
leaq -0x18(%rbp), %rdi
callq 0x321d0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x321d0
movq -0x20(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::has_active_builtin(spv::BuiltIn, spv::StorageClass)
bool Compiler::has_active_builtin(BuiltIn builtin, StorageClass storage)
{
	const Bitset *flags;
	switch (storage)
	{
	case StorageClassInput:
		flags = &active_input_builtins;
		break;
	case StorageClassOutput:
		flags = &active_output_builtins;
		break;

	default:
		return false;
	}
	return flags->get(builtin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x2b1e1
jmp 0x2b1d7
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x2b1f1
jmp 0x2b201
movq -0x30(%rbp), %rax
addq $0x2d0, %rax            # imm = 0x2D0
movq %rax, -0x20(%rbp)
jmp 0x2b207
movq -0x30(%rbp), %rax
addq $0x310, %rax            # imm = 0x310
movq %rax, -0x20(%rbp)
jmp 0x2b207
movb $0x0, -0x1(%rbp)
jmp 0x2b218
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xef50
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::analyze_image_and_sampler_usage()
void Compiler::analyze_image_and_sampler_usage()
{
	CombinedImageSamplerDrefHandler dref_handler(*this);
	traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), dref_handler);

	CombinedImageSamplerUsageHandler handler(*this, dref_handler.dref_combined_samplers);
	traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler);
	comparison_ids = move(handler.comparison_ids);
	need_subpass_input = handler.need_subpass_input;

	// Forward information from separate images and samplers into combined image samplers.
	for (auto &combined : combined_image_samplers)
		if (comparison_ids.count(combined.sampler_id))
			comparison_ids.insert(combined.combined_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x130(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x321f0
movq -0x130(%rbp), %rdi
movl 0x108(%rdi), %esi
callq 0x106d0
movq %rax, -0x128(%rbp)
jmp 0x2b26e
movq -0x128(%rbp), %rsi
movq -0x130(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x21b20
jmp 0x2b287
movq -0x130(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0x32240
jmp 0x2b2a0
movq -0x130(%rbp), %rdi
movl 0x108(%rdi), %esi
callq 0x106d0
movq %rax, -0x138(%rbp)
jmp 0x2b2bb
movq -0x138(%rbp), %rsi
movq -0x130(%rbp), %rdi
leaq -0xf0(%rbp), %rdx
callq 0x21b20
jmp 0x2b2d7
movq -0x130(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
addq $0x50, %rsi
addq $0x360, %rdi            # imm = 0x360
callq 0x2ee40
movq -0x130(%rbp), %rax
movb -0x68(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x398(%rax)
addq $0x1d8, %rax            # imm = 0x1D8
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x322b0
movq %rax, -0x100(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x322e0
movq %rax, -0x108(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x32310
testb $0x1, %al
jne 0x2b357
jmp 0x2b41e
leaq -0x100(%rbp), %rdi
callq 0x32350
movq -0x130(%rbp), %rdi
movq %rax, -0x110(%rbp)
addq $0x360, %rdi            # imm = 0x360
movq -0x110(%rbp), %rsi
addq $0x8, %rsi
callq 0x13520
movq %rax, -0x140(%rbp)
jmp 0x2b391
movq -0x140(%rbp), %rax
cmpq $0x0, %rax
je 0x2b40b
movq -0x130(%rbp), %rdi
addq $0x360, %rdi            # imm = 0x360
movq -0x110(%rbp), %rsi
callq 0x2e890
movb %dl, -0x149(%rbp)
movq %rax, -0x148(%rbp)
jmp 0x2b3c7
movb -0x149(%rbp), %al
movq -0x148(%rbp), %rcx
movq %rcx, -0x120(%rbp)
movb %al, -0x118(%rbp)
jmp 0x2b40b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2b43c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x32390
jmp 0x2b43c
jmp 0x2b40d
leaq -0x100(%rbp), %rdi
callq 0x32370
jmp 0x2b33b
leaq -0xf0(%rbp), %rdi
callq 0x32390
leaq -0x50(%rbp), %rdi
callq 0x323e0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x323e0
movq -0x58(%rbp), %rdi
callq 0x7640
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::CombinedImageSamplerDrefHandler::handle(spv::Op, unsigned int const*, unsigned int)
bool Compiler::CombinedImageSamplerDrefHandler::handle(spv::Op opcode, const uint32_t *args, uint32_t)
{
	// Mark all sampled images which are used with Dref.
	switch (opcode)
	{
	case OpImageSampleDrefExplicitLod:
	case OpImageSampleDrefImplicitLod:
	case OpImageSampleProjDrefExplicitLod:
	case OpImageSampleProjDrefImplicitLod:
	case OpImageSparseSampleProjDrefImplicitLod:
	case OpImageSparseSampleDrefImplicitLod:
	case OpImageSparseSampleProjDrefExplicitLod:
	case OpImageSparseSampleDrefExplicitLod:
	case OpImageDrefGather:
	case OpImageSparseDrefGather:
		dref_combined_samplers.insert(args[2]);
		return true;

	default:
		break;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
addl $-0x59, %eax
subl $0x2, %eax
jb 0x2b4bf
jmp 0x2b47e
movl -0x3c(%rbp), %eax
addl $-0x5d, %eax
subl $0x2, %eax
jb 0x2b4bf
jmp 0x2b48b
movl -0x3c(%rbp), %eax
subl $0x61, %eax
je 0x2b4bf
jmp 0x2b495
movl -0x3c(%rbp), %eax
addl $0xfffffecd, %eax       # imm = 0xFFFFFECD
subl $0x2, %eax
jb 0x2b4bf
jmp 0x2b4a4
movl -0x3c(%rbp), %eax
addl $0xfffffec9, %eax       # imm = 0xFFFFFEC9
subl $0x2, %eax
jb 0x2b4bf
jmp 0x2b4b3
movl -0x3c(%rbp), %eax
subl $0x13b, %eax            # imm = 0x13B
jne 0x2b4e1
jmp 0x2b4bf
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x2e890
movq %rax, -0x38(%rbp)
movb %dl, -0x30(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x2b4e7
jmp 0x2b4e3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::CFGBuilder::follow_function_call(spirv_cross::SPIRFunction const&)
bool Compiler::CFGBuilder::follow_function_call(const SPIRFunction &func)
{
	if (function_cfgs.find(func.self) == end(function_cfgs))
	{
		function_cfgs[func.self].reset(new CFG(compiler, func));
		return true;
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x31b00
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x326f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x326c0
testb $0x1, %al
jne 0x2bb21
jmp 0x2bb90
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x32420
movq %rax, -0x50(%rbp)
movl $0x90, %edi
callq 0x7360
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x77d0
jmp 0x2bb61
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x32450
movb $0x1, -0x1(%rbp)
jmp 0x2bb94
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x90, %esi
callq 0x7370
jmp 0x2bb9f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::CombinedImageSamplerUsageHandler::begin_function_scope(unsigned int const*, unsigned int)
bool Compiler::CombinedImageSamplerUsageHandler::begin_function_scope(const uint32_t *args, uint32_t length)
{
	if (length < 3)
		return false;

	auto &func = compiler.get<SPIRFunction>(args[2]);
	const auto *arg = &args[3];
	length -= 3;

	for (uint32_t i = 0; i < length; i++)
	{
		auto &argument = func.arguments[i];
		dependency_hierarchy[argument.id].insert(arg[i]);
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x3, -0x1c(%rbp)
jae 0x2bbda
movb $0x0, -0x1(%rbp)
jmp 0x2bc6d
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x106d0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x2bc69
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x32720
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
movq -0x40(%rbp), %rsi
addq $0x4, %rsi
callq 0x31a50
movq %rax, %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x2e890
movq %rax, -0x50(%rbp)
movb %dl, -0x48(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2bc0e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::CombinedImageSamplerUsageHandler::add_hierarchy_to_comparison_ids(unsigned int)
void Compiler::CombinedImageSamplerUsageHandler::add_hierarchy_to_comparison_ids(uint32_t id)
{
	// Traverse the variable dependency hierarchy and tag everything in its path with comparison ids.
	comparison_ids.insert(id);
	for (auto &dep_id : dependency_hierarchy[id])
		add_hierarchy_to_comparison_ids(dep_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x50, %rdi
leaq -0xc(%rbp), %rsi
callq 0x2e890
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb %dl, -0x18(%rbp)
addq $0x18, %rdi
leaq -0xc(%rbp), %rsi
callq 0x31a50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x31e60
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x31e90
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2fed0
testb $0x1, %al
jne 0x2bced
jmp 0x2bd14
leaq -0x30(%rbp), %rdi
callq 0x31ec0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %esi
callq 0x2bc80
leaq -0x30(%rbp), %rdi
callq 0x31ef0
jmp 0x2bcda
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)