LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: void stringtok<std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
void stringtok (Container &container,
                std::string const &in,
                const char * const delimiters = " \t\n")
{
    const std::string::size_type len = in.length();
    std::string::size_type i = 0;

    while ( i < len )
    {
        // eat leading whitespace
        i = in.find_first_not_of (delimiters, i);

        if (i == std::string::npos)
        {
            return;    // nothing left but white space
        }

        // find the end of the token
        const std::string::size_type j = in.find_first_of (delimiters, i);

        // push token
        if (j == std::string::npos)
        {
            container.push_back (in.substr(i));
            return;
        }
        container.push_back (in.substr(i, j - i));

        // set up for next loop
        i = j + 1;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3440
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xc04b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x31b0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xbf5b
jmp 0xc04d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3180
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0xbfdb
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq $-0x1, %rcx
callq 0x32c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0xe800
jmp 0xbfb6
leaq -0x50(%rbp), %rdi
callq 0x35c8
jmp 0xc04d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35c8
jmp 0xc056
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x32c0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0xe800
jmp 0xc01a
leaq -0x80(%rbp), %rdi
callq 0x35c8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xbf2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x35c8
jmp 0xc056
jmp 0xc04d
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3500
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::CFG(spirv_cross::Compiler&, spirv_cross::SPIRFunction const&)
CFG::CFG(Compiler &compiler_, const SPIRFunction &func_)
    : compiler(compiler_)
    , func(func_)
{
	preceding_edges.resize(compiler.get_current_id_bound());
	succeeding_edges.resize(compiler.get_current_id_bound());
	visit_order.resize(compiler.get_current_id_bound());
	immediate_dominators.resize(compiler.get_current_id_bound());

	build_post_order_visit_order();
	build_immediate_dominators();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x81f0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x81f0
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x48(%rbp)
callq 0x8210
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x40(%rbp)
callq 0x8230
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x38(%rbp)
callq 0x8210
movq -0x30(%rbp), %rax
movl $0x0, 0x88(%rax)
movq (%rax), %rdi
callq 0x82e0
movl %eax, -0x28(%rbp)
jmp 0x7871
movq -0x60(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x8250
jmp 0x7883
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rdi
callq 0x82e0
movl %eax, -0x64(%rbp)
jmp 0x789f
movq -0x70(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x8250
jmp 0x78b1
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x58, %rcx
movq %rcx, -0x80(%rbp)
movq (%rax), %rdi
callq 0x82e0
movl %eax, -0x74(%rbp)
jmp 0x78cd
movq -0x80(%rbp), %rdi
movl -0x74(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x8310
jmp 0x78df
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x90(%rbp)
movq (%rax), %rdi
callq 0x82e0
movl %eax, -0x84(%rbp)
jmp 0x7901
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x83a0
jmp 0x7919
movq -0x30(%rbp), %rdi
callq 0x7980
jmp 0x7924
movq -0x30(%rbp), %rdi
callq 0x7a00
jmp 0x792f
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8430
movq -0x40(%rbp), %rdi
callq 0x8490
movq -0x48(%rbp), %rdi
callq 0x8430
movq -0x50(%rbp), %rdi
callq 0x84f0
movq -0x58(%rbp), %rdi
callq 0x84f0
movq -0x20(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::build_post_order_visit_order()
void CFG::build_post_order_visit_order()
{
	uint32_t block = func.entry_block;
	visit_count = 0;
	fill(begin(visit_order), end(visit_order), -1);
	post_order.clear();
	post_order_visit(block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq 0x8(%rdi), %rax
movl 0x60(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, 0x88(%rdi)
addq $0x58, %rdi
callq 0x89a0
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x58, %rdi
callq 0x89d0
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x8960
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
callq 0x8a00
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7ca0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::find_common_dominator(unsigned int, unsigned int) const
uint32_t CFG::find_common_dominator(uint32_t a, uint32_t b) const
{
	while (a != b)
	{
		if (visit_order[a] < visit_order[b])
			a = immediate_dominators[a];
		else
			b = immediate_dominators[b];
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x7c67
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x8550
movq -0x18(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x58, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x8550
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7c4e
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x8570
movl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x7c65
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x8570
movl (%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x7bfa
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::DominatorBuilder::add_block(unsigned int)
void DominatorBuilder::add_block(uint32_t block)
{
	if (!cfg.get_immediate_dominator(block))
	{
		// Unreachable block via the CFG, we will never emit this code anyways.
		return;
	}

	if (!dominator)
	{
		dominator = block;
		return;
	}

	if (block != dominator)
		dominator = cfg.find_common_dominator(block, dominator);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x8a20
cmpl $0x0, %eax
jne 0x8009
jmp 0x8046
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x801f
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x8046
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x8046
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl 0x8(%rax), %edx
callq 0x7be0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::SPIRBlock const& spirv_cross::Variant::get<spirv_cross::SPIRBlock>() const
const T &get() const
	{
		if (!holder)
			SPIRV_CROSS_THROW("nullptr");
		if (T::type != type)
			SPIRV_CROSS_THROW("Bad cast");
		return *static_cast<const T *>(holder.get());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9c20
testb $0x1, %al
jne 0x9b3a
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x80(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7650
movq -0x78(%rbp), %rdx
leaq 0x134630(%rip), %rsi    # 0x13e0ee
leaq -0x28(%rbp), %rdi
callq 0x7520
jmp 0x9ac9
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9c50
jmp 0x9ad8
movq -0x80(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x1a42f1(%rip), %rsi    # 0x1addd8
leaq 0x1a2(%rip), %rdx       # 0x9c90
callq 0x7610
jmp 0x9c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9b1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7708
leaq -0x29(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x3d(%rbp)
jne 0x9b2c
jmp 0x9b35
movq -0x80(%rbp), %rdi
callq 0x72c0
jmp 0x9c10
movq -0x70(%rbp), %rcx
movl $0x7, %eax
cmpl 0x8(%rcx), %eax
je 0x9bfe
movb $0x1, -0x62(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x7650
movq -0x88(%rbp), %rdx
leaq 0x134577(%rip), %rsi    # 0x13e0f6
leaq -0x60(%rbp), %rdi
callq 0x7520
jmp 0x9b8a
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9c50
jmp 0x9b9c
movq -0x90(%rbp), %rdi
movb $0x0, -0x62(%rbp)
leaq 0x1a422a(%rip), %rsi    # 0x1addd8
leaq 0xdb(%rip), %rdx        # 0x9c90
callq 0x7610
jmp 0x9c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9bdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7708
leaq -0x61(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x62(%rbp)
jne 0x9bf0
jmp 0x9bfc
movq -0x90(%rbp), %rdi
callq 0x72c0
jmp 0x9c10
movq -0x70(%rbp), %rdi
callq 0x9cb0
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::SPIRBlock& spirv_cross::Variant::get<spirv_cross::SPIRBlock>()
T &get()
	{
		if (!holder)
			SPIRV_CROSS_THROW("nullptr");
		if (T::type != type)
			SPIRV_CROSS_THROW("Bad cast");
		return *static_cast<T *>(holder.get());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9c20
testb $0x1, %al
jne 0xbcca
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x80(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7650
movq -0x78(%rbp), %rdx
leaq 0x1324a0(%rip), %rsi    # 0x13e0ee
leaq -0x28(%rbp), %rdi
callq 0x7520
jmp 0xbc59
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9c50
jmp 0xbc68
movq -0x80(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x1a2161(%rip), %rsi    # 0x1addd8
leaq -0x1fee(%rip), %rdx     # 0x9c90
callq 0x7610
jmp 0xbda9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xbcab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7708
leaq -0x29(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x3d(%rbp)
jne 0xbcbc
jmp 0xbcc5
movq -0x80(%rbp), %rdi
callq 0x72c0
jmp 0xbda0
movq -0x70(%rbp), %rcx
movl $0x7, %eax
cmpl 0x8(%rcx), %eax
je 0xbd8e
movb $0x1, -0x62(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x7650
movq -0x88(%rbp), %rdx
leaq 0x1323e7(%rip), %rsi    # 0x13e0f6
leaq -0x60(%rbp), %rdi
callq 0x7520
jmp 0xbd1a
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9c50
jmp 0xbd2c
movq -0x90(%rbp), %rdi
movb $0x0, -0x62(%rbp)
leaq 0x1a209a(%rip), %rsi    # 0x1addd8
leaq -0x20b5(%rip), %rdx     # 0x9c90
callq 0x7610
jmp 0xbda9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xbd6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7708
leaq -0x61(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x62(%rbp)
jne 0xbd80
jmp 0xbd8c
movq -0x90(%rbp), %rdi
callq 0x72c0
jmp 0xbda0
movq -0x70(%rbp), %rdi
callq 0x9cb0
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cpp.cpp
// Function: spirv_cross::CompilerCPP::emit_shared(spirv_cross::SPIRVariable const&)
void CompilerCPP::emit_shared(const SPIRVariable &var)
{
	add_resource_name(var.self);

	auto instance_name = to_name(var.self);
	statement(CompilerGLSL::variable_decl(var), ";");
	statement_no_indent("#define ", instance_name, " __res->", instance_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x5c1d0
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq -0x30(%rbp), %rdi
movl $0x1, %ecx
callq *%rax
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x62d60
jmp 0xc624
movq -0x68(%rbp), %rdi
leaq 0x13ca77(%rip), %rdx    # 0x1490a6
leaq -0x50(%rbp), %rsi
callq 0xf270
jmp 0xc63a
leaq -0x50(%rbp), %rdi
callq 0x7708
movq -0x68(%rbp), %rdi
leaq 0x131b8d(%rip), %rsi    # 0x13e1db
leaq 0x131b8f(%rip), %rcx    # 0x13e1e4
leaq -0x30(%rbp), %r8
movq %r8, %rdx
callq 0xf390
jmp 0xc663
leaq -0x30(%rbp), %rdi
callq 0x7708
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xc695
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7708
leaq -0x30(%rbp), %rdi
callq 0x7708
movq -0x58(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.hpp
// Function: void spirv_cross::CompilerGLSL::statement<char const (&) [20], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [4]>(char const (&) [20], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [4])
inline void statement(Ts &&... ts)
	{
		if (force_recompile)
		{
			// Do not bother emitting code while force_recompile is active.
			// We will compile again.
			statement_count++;
			return;
		}

		if (redirect_statement)
			redirect_statement->push_back(join(std::forward<Ts>(ts)...));
		else
		{
			for (uint32_t i = 0; i < indent; i++)
				(*buffer) << "    ";
			statement_inner(std::forward<Ts>(ts)...);
			(*buffer) << '\n';
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, 0x1d0(%rax)
je 0xeb40
movq -0x68(%rbp), %rax
movl 0x750(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x750(%rax)
jmp 0xec41
movq -0x68(%rbp), %rax
cmpq $0x0, 0x428(%rax)
je 0xebbf
movq -0x68(%rbp), %rax
movq 0x428(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rdi
movq %rsp, %rax
movq %rdi, (%rax)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x18890
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xecd0
jmp 0xeb97
leaq -0x50(%rbp), %rdi
callq 0x7708
jmp 0xec41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7708
jmp 0xec4a
movl $0x0, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movl -0x60(%rbp), %eax
cmpl 0x638(%rcx), %eax
jae 0xebff
movq -0x68(%rbp), %rdi
addq $0x420, %rdi            # imm = 0x420
callq 0x18970
movq %rax, %rdi
leaq 0x12fcab(%rip), %rsi    # 0x13e89a
callq 0x7350
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xebc6
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x189a0
movq -0x68(%rbp), %rdi
addq $0x420, %rdi            # imm = 0x420
callq 0x18970
movq %rax, %rdi
movl $0xa, %esi
callq 0x7420
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_glsl.hpp
// Function: void spirv_cross::CompilerGLSL::statement_no_indent<char const (&) [9], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [9], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [9]>(char const (&) [9], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [9], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [9])
inline void statement_no_indent(Ts &&... ts)
	{
		auto old_indent = indent;
		indent = 0;
		statement(std::forward<Ts>(ts)...);
		indent = old_indent;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl 0x638(%rdi), %eax
movl %eax, -0x34(%rbp)
movl $0x0, 0x638(%rdi)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x18e80
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, 0x638(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::variable_storage_is_aliased(spirv_cross::SPIRVariable const&)
bool Compiler::variable_storage_is_aliased(const SPIRVariable &v)
{
	auto &type = get<SPIRType>(v.basetype);
	bool ssbo = v.storage == StorageClassStorageBuffer ||
	            ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
	bool image = type.basetype == SPIRType::Image;
	bool counter = type.basetype == SPIRType::AtomicCounter;

	bool is_restrict;
	if (ssbo)
		is_restrict = ir.get_buffer_block_flags(v).get(DecorationRestrict);
	else
		is_restrict = has_decoration(v.self, DecorationRestrict);

	return !is_restrict && (ssbo || image || counter);
}

// 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)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0xc, 0x10(%rcx)
movb %al, -0x6d(%rbp)
je 0x1f458
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0x60, %rdi
movl $0x3, %esi
callq 0xef50
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xd, 0xc(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, 0xc(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1b(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1f4e2
movq -0x78(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x54c20
movq -0x88(%rbp), %rdi
movl $0x13, %esi
callq 0xef50
movb %al, -0x79(%rbp)
jmp 0x1f4b8
movb -0x79(%rbp), %al
andb $0x1, %al
movb %al, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf250
jmp 0x1f4fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf250
jmp 0x1f54c
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x13, %edx
callq 0x1f560
andb $0x1, %al
movb %al, -0x1c(%rbp)
xorl %eax, %eax
testb $0x1, -0x1c(%rbp)
movb %al, -0x89(%rbp)
jne 0x1f53b
movb $0x1, %al
testb $0x1, -0x19(%rbp)
movb %al, -0x8a(%rbp)
jne 0x1f52f
movb $0x1, %al
testb $0x1, -0x1a(%rbp)
movb %al, -0x8a(%rbp)
jne 0x1f52f
movb -0x1b(%rbp), %al
movb %al, -0x8a(%rbp)
movb -0x8a(%rbp), %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::block_is_pure(spirv_cross::SPIRBlock const&)
bool Compiler::block_is_pure(const SPIRBlock &block)
{
	for (auto &i : block.ops)
	{
		auto ops = stream(i);
		auto op = static_cast<Op>(i.op);

		switch (op)
		{
		case OpFunctionCall:
		{
			uint32_t func = ops[2];
			if (!function_is_pure(get<SPIRFunction>(func)))
				return false;
			break;
		}

		case OpCopyMemory:
		case OpStore:
		{
			auto &type = expression_type(ops[0]);
			if (type.storage != StorageClassFunction)
				return false;
			break;
		}

		case OpImageWrite:
			return false;

		// Atomics are impure.
		case OpAtomicLoad:
		case OpAtomicStore:
		case OpAtomicExchange:
		case OpAtomicCompareExchange:
		case OpAtomicCompareExchangeWeak:
		case OpAtomicIIncrement:
		case OpAtomicIDecrement:
		case OpAtomicIAdd:
		case OpAtomicISub:
		case OpAtomicSMin:
		case OpAtomicUMin:
		case OpAtomicSMax:
		case OpAtomicUMax:
		case OpAtomicAnd:
		case OpAtomicOr:
		case OpAtomicXor:
			return false;

		// Geometry shader builtins modify global state.
		case OpEndPrimitive:
		case OpEmitStreamVertex:
		case OpEndStreamPrimitive:
		case OpEmitVertex:
			return false;

		// Barriers disallow any reordering, so we should treat blocks with barrier as writing.
		case OpControlBarrier:
		case OpMemoryBarrier:
			return false;

			// OpExtInst is potentially impure depending on extension, but GLSL builtins are at least pure.

		default:
			break;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2e4d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e500
testb $0x1, %al
jne 0x1f5e4
jmp 0x1f6b0
leaq -0x28(%rbp), %rdi
callq 0x2e540
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x2e560
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addl $-0x39, %eax
movl %eax, %ecx
movq %rcx, -0x60(%rbp)
subl $0xb9, %eax
ja 0x1f69e
movq -0x60(%rbp), %rax
leaq 0x11f276(%rip), %rcx    # 0x13e8a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %esi
callq 0x106d0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x1f6c0
testb $0x1, %al
jne 0x1f65f
movb $0x0, -0x1(%rbp)
jmp 0x1f6b4
jmp 0x1f6a0
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rax
movl (%rax), %esi
callq 0x1f760
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x7, 0x64(%rax)
je 0x1f684
movb $0x0, -0x1(%rbp)
jmp 0x1f6b4
jmp 0x1f6a0
movb $0x0, -0x1(%rbp)
jmp 0x1f6b4
movb $0x0, -0x1(%rbp)
jmp 0x1f6b4
movb $0x0, -0x1(%rbp)
jmp 0x1f6b4
movb $0x0, -0x1(%rbp)
jmp 0x1f6b4
jmp 0x1f6a0
jmp 0x1f6a2
leaq -0x28(%rbp), %rdi
callq 0x2e690
jmp 0x1f5ce
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::function_is_pure(spirv_cross::SPIRFunction const&)
bool Compiler::function_is_pure(const SPIRFunction &func)
{
	for (auto block : func.blocks)
	{
		if (!block_is_pure(get<SPIRBlock>(block)))
		{
			//fprintf(stderr, "Function %s is impure!\n", to_name(func.self).c_str());
			return false;
		}
	}

	//fprintf(stderr, "Function %s is pure!\n", to_name(func.self).c_str());
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbaf0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbb20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e710
testb $0x1, %al
jne 0x1f711
jmp 0x1f74e
leaq -0x28(%rbp), %rdi
callq 0x2e750
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
callq 0x87d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1f590
testb $0x1, %al
jne 0x1f741
movb $0x0, -0x1(%rbp)
jmp 0x1f752
jmp 0x1f743
leaq -0x28(%rbp), %rdi
callq 0x2e770
jmp 0x1f6fe
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::to_name[abi:cxx11](unsigned int, bool) const
string Compiler::to_name(uint32_t id, bool allow_alias) const
{
	if (allow_alias && ir.ids.at(id).get_type() == TypeType)
	{
		// If this type is a simple alias, emit the
		// name of the original type instead.
		// We don't want to override the meta alias
		// as that can be overridden by the reflection APIs after parse.
		auto &type = get<SPIRType>(id);
		if (type.type_alias)
		{
			// If the alias master has been specially packed, we will have emitted a clean variant as well,
			// so skip the name aliasing here.
			if (!has_decoration(type.type_alias, DecorationCPacked))
				return to_name(type.type_alias);
		}
	}

	if (ir.meta[id].decoration.alias.empty())
		return join("_", id);
	else
		return ir.meta[id].decoration.alias;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x15(%rbp)
je 0x1f842
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9a30
movq %rax, %rdi
callq 0xfa00
cmpl $0x1, %eax
jne 0x1f842
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e6b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x98(%rax)
je 0x1f840
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x98(%rax), %esi
movl $0xa, %edx
callq 0x1f560
testb $0x1, %al
jne 0x1f83e
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x98(%rax), %edx
movq (%rsi), %rax
movl $0x1, %ecx
callq *0x38(%rax)
jmp 0x1f89e
jmp 0x1f840
jmp 0x1f842
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, %rdi
callq 0x75f0
testb $0x1, %al
jne 0x1f866
jmp 0x1f87c
movq -0x38(%rbp), %rdi
leaq 0x128cad(%rip), %rsi    # 0x14851e
leaq -0x14(%rbp), %rdx
callq 0x18730
jmp 0x1f89e
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e6f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7170
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::register_global_read_dependencies(spirv_cross::SPIRBlock const&, unsigned int)
void Compiler::register_global_read_dependencies(const SPIRBlock &block, uint32_t id)
{
	for (auto &i : block.ops)
	{
		auto ops = stream(i);
		auto op = static_cast<Op>(i.op);

		switch (op)
		{
		case OpFunctionCall:
		{
			uint32_t func = ops[2];
			register_global_read_dependencies(get<SPIRFunction>(func), id);
			break;
		}

		case OpLoad:
		case OpImageRead:
		{
			// If we're in a storage class which does not get invalidated, adding dependencies here is no big deal.
			auto *var = maybe_get_backing_variable(ops[2]);
			if (var && var->storage != StorageClassFunction)
			{
				auto &type = get<SPIRType>(var->basetype);

				// InputTargets are immutable.
				if (type.basetype != SPIRType::Image && type.image.dim != DimSubpassData)
					var->dependees.push_back(id);
			}
			break;
		}

		default:
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2e4d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e500
testb $0x1, %al
jne 0x1f907
jmp 0x1f9f1
leaq -0x28(%rbp), %rdi
callq 0x2e540
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x2e560
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x64(%rbp)
subl $0x39, %eax
je 0x1f953
jmp 0x1f93c
movl -0x64(%rbp), %eax
subl $0x3d, %eax
je 0x1f97a
jmp 0x1f946
movl -0x64(%rbp), %eax
subl $0x62, %eax
je 0x1f97a
jmp 0x1f9df
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %esi
callq 0x106d0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x1fa00
jmp 0x1f9e1
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1fa90
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x1f9dd
movq -0x50(%rbp), %rax
cmpl $0x7, 0x10(%rax)
je 0x1f9dd
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpl $0xd, 0xc(%rax)
je 0x1f9db
movq -0x58(%rbp), %rax
cmpl $0x6, 0x84(%rax)
je 0x1f9db
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
leaq -0x14(%rbp), %rsi
callq 0x88f0
jmp 0x1f9dd
jmp 0x1f9e1
jmp 0x1f9e1
jmp 0x1f9e3
leaq -0x28(%rbp), %rdi
callq 0x2e690
jmp 0x1f8f1
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::maybe_get_backing_variable(unsigned int)
SPIRVariable *Compiler::maybe_get_backing_variable(uint32_t chain)
{
	auto *var = maybe_get<SPIRVariable>(chain);
	if (!var)
	{
		auto *cexpr = maybe_get<SPIRExpression>(chain);
		if (cexpr)
			var = maybe_get<SPIRVariable>(cexpr->loaded_from);

		auto *access_chain = maybe_get<SPIRAccessChain>(chain);
		if (access_chain)
			var = maybe_get<SPIRVariable>(access_chain->loaded_from);
	}

	return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1fb12
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2e790
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1fae5
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2e7f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1fb10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
jmp 0x1fb12
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::register_read(unsigned int, unsigned int, bool)
void Compiler::register_read(uint32_t expr, uint32_t chain, bool forwarded)
{
	auto &e = get<SPIRExpression>(expr);
	auto *var = maybe_get_backing_variable(chain);

	if (var)
	{
		e.loaded_from = var->self;

		// If the backing variable is immutable, we do not need to depend on the variable.
		if (forwarded && !is_immutable(var->self))
			var->dependees.push_back(e.self);

		// If we load from a parameter, make sure we create "inout" if we also write to the parameter.
		// The default is "in" however, so we never invalidate our compilation by reading.
		if (var && var->parameter)
			var->parameter->read_count++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x2e850
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %esi
callq 0x1fa90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1fbc6
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x34(%rax)
testb $0x1, -0x11(%rbp)
je 0x1fba1
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1fbd0
testb $0x1, %al
jne 0x1fba1
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x88f0
cmpq $0x0, -0x28(%rbp)
je 0x1fbc4
movq -0x28(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1fbc4
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x1fbc6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::is_immutable(unsigned int) const
bool Compiler::is_immutable(uint32_t id) const
{
	if (ir.ids[id].get_type() == TypeVariable)
	{
		auto &var = get<SPIRVariable>(id);

		// Anything we load from the UniformConstant address space is guaranteed to be immutable.
		bool pointer_to_const = var.storage == StorageClassUniformConstant;
		return pointer_to_const || var.phi_variable || !expression_is_lvalue(id);
	}
	else if (ir.ids[id].get_type() == TypeAccessChain)
		return get<SPIRAccessChain>(id).immutable;
	else if (ir.ids[id].get_type() == TypeExpression)
		return get<SPIRExpression>(id).immutable;
	else if (ir.ids[id].get_type() == TypeConstant || ir.ids[id].get_type() == TypeConstantOp ||
	         ir.ids[id].get_type() == TypeUndef)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9e00
movq %rax, %rdi
callq 0xfa00
cmpl $0x2, %eax
jne 0x1fc5e
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e8d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
sete %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movb $0x1, %al
testb $0x1, -0x21(%rbp)
movb %al, -0x31(%rbp)
jne 0x1fc51
movq -0x20(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x5a(%rcx)
movb %al, -0x31(%rbp)
jne 0x1fc51
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x20410
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1fd46
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9e00
movq %rax, %rdi
callq 0xfa00
cmpl $0xc, %eax
jne 0x1fc9a
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2ea50
movb 0x65(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1fd46
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9e00
movq %rax, %rdi
callq 0xfa00
cmpl $0x9, %eax
jne 0x1fcd3
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e910
movb 0x38(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1fd46
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9e00
movq %rax, %rdi
callq 0xfa00
cmpl $0x3, %eax
je 0x1fd3c
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9e00
movq %rax, %rdi
callq 0xfa00
cmpl $0xa, %eax
je 0x1fd3c
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9e00
movq %rax, %rdi
callq 0xfa00
cmpl $0xd, %eax
jne 0x1fd42
movb $0x1, -0x1(%rbp)
jmp 0x1fd46
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::register_write(unsigned int)
void Compiler::register_write(uint32_t chain)
{
	auto *var = maybe_get<SPIRVariable>(chain);
	if (!var)
	{
		// If we're storing through an access chain, invalidate the backing variable instead.
		auto *expr = maybe_get<SPIRExpression>(chain);
		if (expr && expr->loaded_from)
			var = maybe_get<SPIRVariable>(expr->loaded_from);

		auto *access_chain = maybe_get<SPIRAccessChain>(chain);
		if (access_chain && access_chain->loaded_from)
			var = maybe_get<SPIRVariable>(access_chain->loaded_from);
	}

	if (var)
	{
		// If our variable is in a storage class which can alias with other buffers,
		// invalidate all variables which depend on aliased variables.
		if (variable_storage_is_aliased(*var))
			flush_all_aliased_variables();
		else if (var)
			flush_dependees(*var);

		// We tried to write to a parameter which is not marked with out qualifier, force a recompile.
		if (var->parameter && var->parameter->write_count == 0)
		{
			var->parameter->write_count++;
			force_recompile = true;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1fdf6
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2e790
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1fdbf
movq -0x20(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x1fdbf
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2e7f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1fdf4
movq -0x28(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
je 0x1fdf4
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x116b0
movq %rax, -0x18(%rbp)
jmp 0x1fdf6
cmpq $0x0, -0x18(%rbp)
je 0x1fe68
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f3f0
testb $0x1, %al
jne 0x1fe10
jmp 0x1fe1b
movq -0x30(%rbp), %rdi
callq 0x1fe70
jmp 0x1fe31
cmpq $0x0, -0x18(%rbp)
je 0x1fe2f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ff00
jmp 0x1fe31
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1fe66
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1fe66
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x68(%rcx), %rcx
movl 0xc(%rcx), %edx
addl $0x1, %edx
movl %edx, 0xc(%rcx)
movb $0x1, 0x1d0(%rax)
jmp 0x1fe68
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::flush_control_dependent_expressions(unsigned int)
void Compiler::flush_control_dependent_expressions(uint32_t block_id)
{
	auto &block = get<SPIRBlock>(block_id);
	for (auto &expr : block.invalidate_expressions)
		invalid_expressions.insert(expr);
	block.invalidate_expressions.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %esi
callq 0x87d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0xe8, %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 0x2008e
jmp 0x200c1
leaq -0x28(%rbp), %rdi
callq 0x8770
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x198, %rdi            # imm = 0x198
movq -0x38(%rbp), %rsi
callq 0x2e890
movq %rax, -0x48(%rbp)
movb %dl, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8790
jmp 0x2007b
movq -0x18(%rbp), %rdi
addq $0xe8, %rdi
callq 0x8a00
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::flush_all_active_variables()
void Compiler::flush_all_active_variables()
{
	// Invalidate all temporaries we read from variables in this block since they were forwarded.
	// Invalidate all temporaries we read from globals.
	for (auto &v : current_function->local_variables)
		flush_dependees(get<SPIRVariable>(v));
	for (auto &arg : current_function->arguments)
		flush_dependees(get<SPIRVariable>(arg.id));
	for (auto global : global_variables)
		flush_dependees(get<SPIRVariable>(global));

	flush_all_aliased_variables();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x148(%rax), %rax
addq $0x48, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x86d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8700
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8730
testb $0x1, %al
jne 0x20130
jmp 0x20163
leaq -0x18(%rbp), %rdi
callq 0x8770
movq -0x70(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xfec0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x1ff00
leaq -0x18(%rbp), %rdi
callq 0x8790
jmp 0x2011d
movq -0x70(%rbp), %rax
movq 0x148(%rax), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x115b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x115e0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11610
testb $0x1, %al
jne 0x201a3
jmp 0x201d7
leaq -0x38(%rbp), %rdi
callq 0x11650
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xfec0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x1ff00
leaq -0x38(%rbp), %rdi
callq 0x11710
jmp 0x20190
movq -0x70(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x86d0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x8700
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8730
testb $0x1, %al
jne 0x20212
jmp 0x20243
leaq -0x58(%rbp), %rdi
callq 0x8770
movq -0x70(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %esi
callq 0xfec0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x1ff00
leaq -0x58(%rbp), %rdi
callq 0x8790
jmp 0x201ff
movq -0x70(%rbp), %rdi
callq 0x1fe70
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::expression_type_id(unsigned int) const
uint32_t Compiler::expression_type_id(uint32_t id) const
{
	switch (ir.ids[id].get_type())
	{
	case TypeVariable:
		return get<SPIRVariable>(id).basetype;

	case TypeExpression:
		return get<SPIRExpression>(id).expression_type;

	case TypeConstant:
		return get<SPIRConstant>(id).constant_type;

	case TypeConstantOp:
		return get<SPIRConstantOp>(id).basetype;

	case TypeUndef:
		return get<SPIRUndef>(id).basetype;

	case TypeCombinedImageSampler:
		return get<SPIRCombinedImageSampler>(id).combined_type;

	case TypeAccessChain:
		return get<SPIRAccessChain>(id).basetype;

	default:
		SPIRV_CROSS_THROW("Cannot resolve expression type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9e00
movq %rax, %rdi
callq 0xfa00
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x58(%rbp)
subl $0xb, %eax
ja 0x20354
movq -0x58(%rbp), %rax
leaq 0x11e8de(%rip), %rcx    # 0x13eb88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e8d0
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x203f4
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e910
movl 0x30(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x203f4
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e950
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x203f4
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e990
movl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x203f4
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e9d0
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x203f4
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2ea10
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x203f4
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2ea50
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x203f4
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7650
movq -0x68(%rbp), %rdx
leaq 0x11f0b2(%rip), %rsi    # 0x13f430
leaq -0x38(%rbp), %rdi
callq 0x7520
jmp 0x20389
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9c50
jmp 0x20398
movq -0x70(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x18da31(%rip), %rsi    # 0x1addd8
leaq -0x1671e(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0x20406
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x203d8
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 0x203e9
jmp 0x203f2
movq -0x70(%rbp), %rdi
callq 0x72c0
jmp 0x203fd
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::expression_is_lvalue(unsigned int) const
bool Compiler::expression_is_lvalue(uint32_t id) const
{
	auto &type = expression_type(id);
	switch (type.basetype)
	{
	case SPIRType::SampledImage:
	case SPIRType::Image:
	case SPIRType::Sampler:
		return false;

	default:
		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f760
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
addl $-0xd, %eax
subl $0x2, %eax
ja 0x20446
jmp 0x20440
movb $0x0, -0x1(%rbp)
jmp 0x2044a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)