LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::SPIRConstant::f16_to_f32(unsigned short)
static inline float f16_to_f32(uint16_t u16_value)
	{
		// Based on the GLM implementation.
		int s = (u16_value >> 15) & 0x1;
		int e = (u16_value >> 10) & 0x1f;
		int m = (u16_value >> 0) & 0x3ff;

		union {
			float f32;
			uint32_t u32;
		} u;

		if (e == 0)
		{
			if (m == 0)
			{
				u.u32 = uint32_t(s) << 31;
				return u.f32;
			}
			else
			{
				while ((m & 0x400) == 0)
				{
					m <<= 1;
					e--;
				}

				e++;
				m &= ~0x400;
			}
		}
		else if (e == 31)
		{
			if (m == 0)
			{
				u.u32 = (uint32_t(s) << 31) | 0x7f800000u;
				return u.f32;
			}
			else
			{
				u.u32 = (uint32_t(s) << 31) | 0x7f800000u | (m << 13);
				return u.f32;
			}
		}

		e += 127 - 15;
		m <<= 13;
		u.u32 = (uint32_t(s) << 31) | (e << 23) | m;
		return u.f32;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %eax
sarl $0xf, %eax
andl $0x1, %eax
movl %eax, -0xc(%rbp)
movzwl -0x6(%rbp), %eax
sarl $0xa, %eax
andl $0x1f, %eax
movl %eax, -0x10(%rbp)
movzwl -0x6(%rbp), %eax
sarl $0x0, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0xa9cd0
cmpl $0x0, -0x14(%rbp)
jne 0xa9c98
movl -0xc(%rbp), %eax
shll $0x1f, %eax
movl %eax, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa9d4a
jmp 0xa9c9a
movl -0x14(%rbp), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0xa9cba
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa9c9a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
andl $0xfffffbff, %eax       # imm = 0xFFFFFBFF
movl %eax, -0x14(%rbp)
jmp 0xa9d1a
cmpl $0x1f, -0x10(%rbp)
jne 0xa9d18
cmpl $0x0, -0x14(%rbp)
jne 0xa9cf6
movl -0xc(%rbp), %eax
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
movl %eax, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa9d4a
movl -0xc(%rbp), %eax
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
movl -0x14(%rbp), %ecx
shll $0xd, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa9d4a
jmp 0xa9d1a
movl -0x10(%rbp), %eax
addl $0x70, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
shll $0xd, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
shll $0x1f, %eax
movl -0x10(%rbp), %ecx
shll $0x17, %ecx
orl %ecx, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_header()
void CompilerHLSL::emit_header()
{
	for (auto &header : header_lines)
		statement(header);

	if (header_lines.size() > 0)
	{
		statement("");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x738, %rax            # imm = 0x738
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10170
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x101a0
testb $0x1, %al
jne 0xbca4b
jmp 0xbca70
leaq -0x18(%rbp), %rdi
callq 0x101e0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x10200
leaq -0x18(%rbp), %rdi
callq 0x10320
jmp 0xbca38
movq -0x30(%rbp), %rdi
addq $0x738, %rdi            # imm = 0x738
callq 0x19aa0
cmpq $0x0, %rax
jbe 0xbca96
movq -0x30(%rbp), %rdi
leaq 0x81e0d(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_interface_block_globally(spirv_cross::SPIRVariable const&)
void CompilerHLSL::emit_interface_block_globally(const SPIRVariable &var)
{
	add_resource_name(var.self);

	// The global copies of I/O variables should not contain interpolation qualifiers.
	// These are emitted inside the interface structs.
	auto &flags = ir.meta[var.self].decoration.decoration_flags;
	auto old_flags = flags;
	flags.reset();
	statement("static ", variable_decl(var), ";");
	flags = old_flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x5c1d0
movq -0x90(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0xead0
addq $0x60, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xef10
movq -0x18(%rbp), %rdi
callq 0x30d60
jmp 0xbcb03
movq -0x90(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x62d60
jmp 0xbcb1c
movq -0x90(%rbp), %rdi
leaq 0x89484(%rip), %rsi     # 0x145fae
leaq 0x8c575(%rip), %rcx     # 0x1490a6
leaq -0x88(%rbp), %rdx
callq 0xa8cb0
jmp 0xbcb3f
leaq -0x88(%rbp), %rdi
callq 0x7708
movq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x38560
jmp 0xbcb5a
leaq -0x58(%rbp), %rdi
callq 0xf250
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xbcb92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x7708
leaq -0x58(%rbp), %rdi
callq 0xf250
movq -0x60(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::to_storage_qualifiers_glsl(spirv_cross::SPIRVariable const&)
const char *CompilerHLSL::to_storage_qualifiers_glsl(const SPIRVariable &var)
{
	// Input and output variables are handled specially in HLSL backend.
	// The variables are declared as global, private variables, and do not need any qualifiers.
	if (var.storage == StorageClassUniformConstant || var.storage == StorageClassUniform ||
	    var.storage == StorageClassPushConstant)
	{
		return "uniform ";
	}

	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xbcbda
movq -0x18(%rbp), %rax
cmpl $0x2, 0x10(%rax)
je 0xbcbda
movq -0x18(%rbp), %rax
cmpl $0x9, 0x10(%rax)
jne 0xbcbe7
leaq 0x8491b(%rip), %rax     # 0x1414fc
movq %rax, -0x8(%rbp)
jmp 0xbcbf2
leaq 0x81cb0(%rip), %rax     # 0x13e89e
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: void spirv_cross::Bitset::for_each_bit<spirv_cross::CompilerHLSL::emit_builtin_outputs_in_struct()::$_0>(spirv_cross::CompilerHLSL::emit_builtin_outputs_in_struct()::$_0 const&) const
void for_each_bit(const Op &op) const
	{
		// TODO: Add ctz-based iteration.
		for (uint32_t i = 0; i < 64; i++)
		{
			if (lower & (1ull << i))
				op(i);
		}

		if (higher.empty())
			return;

		// Need to enforce an order here for reproducible results,
		// but hitting this path should happen extremely rarely, so having this slow path is fine.
		std::vector<uint32_t> bits;
		bits.reserve(higher.size());
		for (auto &v : higher)
			bits.push_back(v);
		std::sort(std::begin(bits), std::end(bits));

		for (auto &v : bits)
			op(v);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jae 0xbccb5
movq -0x98(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0xbcca8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xd3eb0
jmp 0xbccaa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbcc75
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0xa9bf0
testb $0x1, %al
jne 0xbcccb
jmp 0xbccd0
jmp 0xbce3e
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x8210
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x31c80
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0xdf650
jmp 0xbcd01
movq -0x98(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x31ca0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x31cd0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2fed0
testb $0x1, %al
jne 0xbcd3d
jmp 0xbcd80
leaq -0x50(%rbp), %rdi
callq 0x31d00
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x88f0
jmp 0xbcd59
jmp 0xbcd5b
leaq -0x50(%rbp), %rdi
callq 0x31d30
jmp 0xbcd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8430
jmp 0xbce47
leaq -0x30(%rbp), %rdi
callq 0x85d0
movq %rax, -0xa8(%rbp)
jmp 0xbcd92
movq -0xa8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8600
movq %rax, -0xb0(%rbp)
jmp 0xbcdaf
movq -0xb0(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x30280
jmp 0xbcdc9
leaq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x86d0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x8700
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8730
testb $0x1, %al
jne 0xbce04
jmp 0xbce35
leaq -0x80(%rbp), %rdi
callq 0x8770
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rax
movl (%rax), %esi
callq 0xd3eb0
jmp 0xbce28
jmp 0xbce2a
leaq -0x80(%rbp), %rdi
callq 0x8790
jmp 0xbcdee
leaq -0x30(%rbp), %rdi
callq 0x8430
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::type_to_consumed_locations(spirv_cross::SPIRType const&) const
uint32_t CompilerHLSL::type_to_consumed_locations(const SPIRType &type) const
{
	// TODO: Need to verify correctness.
	uint32_t elements = 0;

	if (type.basetype == SPIRType::Struct)
	{
		for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++)
			elements += type_to_consumed_locations(get<SPIRType>(type.member_types[i]));
	}
	else
	{
		uint32_t array_multiplier = 1;
		for (uint32_t i = 0; i < uint32_t(type.array.size()); i++)
		{
			if (type.array_size_literal[i])
				array_multiplier *= type.array[i];
			else
				array_multiplier *= get<SPIRConstant>(type.array[i]).scalar();
		}
		elements += array_multiplier * type.columns;
	}
	return elements;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xc, 0xc(%rax)
jne 0xbd11c
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0xbd117
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x8570
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0x2e6b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xbd090
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbd0c0
jmp 0xbd1cd
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8650
movq %rax, %rcx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jae 0xbd1bc
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x118c0
testb $0x1, %al
jne 0xbd15f
jmp 0xbd17c
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x8570
movl (%rax), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xbd1ac
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x8570
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0x2e950
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2f560
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xbd1ae
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xbd12a
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x18(%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::to_interpolation_qualifiers[abi:cxx11](spirv_cross::Bitset const&)
string CompilerHLSL::to_interpolation_qualifiers(const Bitset &flags)
{
	string res;
	//if (flags & (1ull << DecorationSmooth))
	//    res += "linear ";
	if (flags.get(DecorationFlat))
		res += "nointerpolation ";
	if (flags.get(DecorationNoPerspective))
		res += "noperspective ";
	if (flags.get(DecorationCentroid))
		res += "centroid ";
	if (flags.get(DecorationPatch))
		res += "patch "; // Seems to be different in actual HLSL.
	if (flags.get(DecorationSample))
		res += "sample ";
	if (flags.get(DecorationInvariant))
		res += "invariant "; // Not supported?

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7530
movq -0x18(%rbp), %rdi
movl $0xe, %esi
callq 0xef50
movb %al, -0x2d(%rbp)
jmp 0xbd21b
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0xbd224
jmp 0xbd252
movq -0x40(%rbp), %rdi
leaq 0x88d87(%rip), %rsi     # 0x145fb6
callq 0x7340
jmp 0xbd236
jmp 0xbd252
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7708
jmp 0xbd35f
movq -0x18(%rbp), %rdi
movl $0xd, %esi
callq 0xef50
movb %al, -0x41(%rbp)
jmp 0xbd265
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xbd26e
jmp 0xbd282
movq -0x40(%rbp), %rdi
leaq 0x83ce9(%rip), %rsi     # 0x140f62
callq 0x7340
jmp 0xbd280
jmp 0xbd282
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0xef50
movb %al, -0x42(%rbp)
jmp 0xbd295
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0xbd29e
jmp 0xbd2b2
movq -0x40(%rbp), %rdi
leaq 0x83cc8(%rip), %rsi     # 0x140f71
callq 0x7340
jmp 0xbd2b0
jmp 0xbd2b2
movq -0x18(%rbp), %rdi
movl $0xf, %esi
callq 0xef50
movb %al, -0x43(%rbp)
jmp 0xbd2c5
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0xbd2ce
jmp 0xbd2e2
movq -0x40(%rbp), %rdi
leaq 0x83ca2(%rip), %rsi     # 0x140f7b
callq 0x7340
jmp 0xbd2e0
jmp 0xbd2e2
movq -0x18(%rbp), %rdi
movl $0x11, %esi
callq 0xef50
movb %al, -0x44(%rbp)
jmp 0xbd2f5
movb -0x44(%rbp), %al
testb $0x1, %al
jne 0xbd2fe
jmp 0xbd312
movq -0x40(%rbp), %rdi
leaq 0x83c79(%rip), %rsi     # 0x140f82
callq 0x7340
jmp 0xbd310
jmp 0xbd312
movq -0x18(%rbp), %rdi
movl $0x12, %esi
callq 0xef50
movb %al, -0x45(%rbp)
jmp 0xbd325
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0xbd32e
jmp 0xbd342
movq -0x40(%rbp), %rdi
leaq 0x83c51(%rip), %rsi     # 0x140f8a
callq 0x7340
jmp 0xbd340
jmp 0xbd342
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xbd355
movq -0x40(%rbp), %rdi
callq 0x7708
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::to_semantic[abi:cxx11](unsigned int)
std::string CompilerHLSL::to_semantic(uint32_t vertex_location)
{
	for (auto &attribute : remap_vertex_attributes)
		if (attribute.location == vertex_location)
			return attribute.semantic;

	return join("TEXCOORD", vertex_location);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x7b0, %rax            # imm = 0x7B0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd7420
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd7450
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd7480
testb $0x1, %al
jne 0xbd3c9
jmp 0xbd401
leaq -0x28(%rbp), %rdi
callq 0xd74c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xbd3f4
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x7170
jmp 0xbd415
jmp 0xbd3f6
leaq -0x28(%rbp), %rdi
callq 0xd74e0
jmp 0xbd3b6
movq -0x48(%rbp), %rdi
leaq 0x88bbb(%rip), %rsi     # 0x145fc7
leaq -0x14(%rbp), %rdx
callq 0x9f910
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_composite_constants()
void CompilerHLSL::emit_composite_constants()
{
	// HLSL cannot declare structs or arrays inline, so we must move them out to
	// global constants directly.
	bool emitted = false;

	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeConstant)
		{
			auto &c = id.get<SPIRConstant>();
			if (c.specialization)
				continue;

			auto &type = get<SPIRType>(c.constant_type);
			if (type.basetype == SPIRType::Struct || !type.array.empty())
			{
				auto name = to_name(c.self);
				statement("static const ", variable_decl(type, name), " = ", constant_expression(c), ";");
				emitted = true;
			}
		}
	}

	if (emitted)
		statement("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x9(%rbp)
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf940
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf970
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf9a0
testb $0x1, %al
jne 0xbe96a
jmp 0xbeb03
leaq -0x20(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xfa00
cmpl $0x3, %eax
jne 0xbeaf3
movq -0x30(%rbp), %rdi
callq 0x2f2f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0x108(%rax)
je 0xbe9a8
jmp 0xbeaf5
movq -0xb8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0xc, 0xc(%rax)
je 0xbe9de
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x8690
testb $0x1, %al
jne 0xbeaf1
movq -0xb8(%rbp), %rsi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x1, %ecx
callq *%rax
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq (%rsi), %rax
movq 0xc8(%rax), %rax
leaq -0x80(%rbp), %rdi
xorl %r8d, %r8d
callq *%rax
jmp 0xbea2c
movq -0xb8(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x64bc0
jmp 0xbea45
movq -0xb8(%rbp), %rdi
leaq 0x8767b(%rip), %rsi     # 0x1460ce
leaq 0x8a5b5(%rip), %rcx     # 0x14900f
leaq 0x8a645(%rip), %r9      # 0x1490a6
leaq -0x80(%rbp), %rdx
leaq -0xb0(%rbp), %r8
callq 0xd7ca0
jmp 0xbea73
leaq -0xb0(%rbp), %rdi
callq 0x7708
leaq -0x80(%rbp), %rdi
callq 0x7708
movb $0x1, -0x9(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7708
jmp 0xbeaf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xbeae6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xbeadd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x7708
leaq -0x80(%rbp), %rdi
callq 0x7708
leaq -0x60(%rbp), %rdi
callq 0x7708
jmp 0xbeb25
jmp 0xbeaf3
jmp 0xbeaf5
leaq -0x20(%rbp), %rdi
callq 0xfbd0
jmp 0xbe954
testb $0x1, -0x9(%rbp)
je 0xbeb1c
movq -0xb8(%rbp), %rdi
leaq 0x7fd87(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::layout_for_member[abi:cxx11](spirv_cross::SPIRType const&, unsigned int)
string CompilerHLSL::layout_for_member(const SPIRType &type, uint32_t index)
{
	auto &flags = get_member_decoration_bitset(type.self, index);

	// HLSL can emit row_major or column_major decoration in any struct.
	// Do not try to merge combined decorations for children like in GLSL.

	// Flip the convention. HLSL is a bit odd in that the memory layout is column major ... but the language API is "row-major".
	// The way to deal with this is to multiply everything in inverse order, and reverse the memory layout.
	if (flags.get(DecorationColMajor))
		return "row_major ";
	else if (flags.get(DecorationRowMajor))
		return "column_major ";

	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x1c(%rbp), %edx
callq 0x23220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x5, %esi
callq 0xef50
testb $0x1, %al
jne 0xc1f4d
jmp 0xc1f98
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7650
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x85f06(%rip), %rsi     # 0x147e6f
callq 0x7520
jmp 0xc1f70
leaq -0x29(%rbp), %rdi
callq 0x73d0
jmp 0xc2038
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x73d0
jmp 0xc2042
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0xef50
testb $0x1, %al
jne 0xc1fac
jmp 0xc1ff1
leaq -0x3d(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7650
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x85eb2(%rip), %rsi     # 0x147e7a
callq 0x7520
jmp 0xc1fcf
leaq -0x3d(%rbp), %rdi
callq 0x73d0
jmp 0xc2038
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x73d0
jmp 0xc2042
jmp 0xc1ff3
leaq -0x3e(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7650
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x7c88f(%rip), %rsi     # 0x13e89e
callq 0x7520
jmp 0xc2016
leaq -0x3e(%rbp), %rdi
callq 0x73d0
jmp 0xc2038
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3e(%rbp), %rdi
callq 0x73d0
jmp 0xc2042
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::to_sampler_expression[abi:cxx11](unsigned int)
string CompilerHLSL::to_sampler_expression(uint32_t id)
{
	auto expr = join("_", to_expression(id));
	auto index = expr.find_first_of('[');
	if (index == string::npos)
	{
		return expr + "_sampler";
	}
	else
	{
		// We have an expression like _ident[array], so we cannot tack on _sampler, insert it inside the string instead.
		return expr.insert(index, "_sampler");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x71b50
movq -0x80(%rbp), %rdx
leaq 0x84728(%rip), %rsi     # 0x14851e
leaq -0x38(%rbp), %rdi
callq 0xa6fd0
jmp 0xc3e01
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x38(%rbp), %rdi
movl $0x5b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7230
movq %rax, -0x70(%rbp)
cmpq $-0x1, -0x70(%rbp)
jne 0xc3e77
movq -0x90(%rbp), %rdi
leaq 0x841f1(%rip), %rdx     # 0x148026
leaq -0x38(%rbp), %rsi
callq 0x2f8c0
jmp 0xc3e40
movl $0x1, -0x74(%rbp)
jmp 0xc3eb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7708
jmp 0xc3ec9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7708
jmp 0xc3ec9
movq -0x70(%rbp), %rsi
leaq 0x841a4(%rip), %rdx     # 0x148026
leaq -0x38(%rbp), %rdi
callq 0x70d0
movq %rax, -0x98(%rbp)
jmp 0xc3e94
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x7170
jmp 0xc3ea9
movl $0x1, -0x74(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7708
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::to_func_call_arg[abi:cxx11](unsigned int)
string CompilerHLSL::to_func_call_arg(uint32_t id)
{
	string arg_str = CompilerGLSL::to_func_call_arg(id);

	if (hlsl_options.shader_model <= 30)
		return arg_str;

	// Manufacture automatic sampler arg if the arg is a SampledImage texture and we're in modern HLSL.
	auto &type = expression_type(id);

	// We don't have to consider combined image samplers here via OpSampledImage because
	// those variables cannot be passed as arguments to functions.
	// Only global SampledImage variables may be used as arguments.
	if (type.basetype == SPIRType::SampledImage && type.image.dim != DimBuffer)
		arg_str += ", " + to_sampler_expression(id);

	return arg_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x80(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %edx
callq 0x71ae0
movq -0x80(%rbp), %rax
cmpl $0x1e, 0x788(%rax)
ja 0xc3f78
movb $0x1, -0x15(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0xc404c
movq -0x80(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f760
movq %rax, -0x98(%rbp)
jmp 0xc3f8d
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xe, 0xc(%rax)
jne 0xc4041
movq -0x28(%rbp), %rax
cmpl $0x5, 0x84(%rax)
je 0xc4041
movq -0x80(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x78(%rbp), %rdi
callq 0xc3db0
jmp 0xc3fc9
leaq 0x805bf(%rip), %rsi     # 0x14458f
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xa6db0
jmp 0xc3fdf
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7470
jmp 0xc3ff1
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x78(%rbp), %rdi
callq 0x7708
jmp 0xc4041
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc406e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc4036
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x78(%rbp), %rdi
callq 0x7708
jmp 0xc406e
movb $0x1, -0x15(%rbp)
movl $0x1, -0x1c(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xc405e
movq -0x90(%rbp), %rdi
callq 0x7708
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x7708
movq -0x30(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_fixup()
void CompilerHLSL::emit_fixup()
{
	if (get_entry_point().model == ExecutionModelVertex)
	{
		// Do various mangling on the gl_Position.
		if (hlsl_options.shader_model <= 30)
		{
			statement("gl_Position.x = gl_Position.x - gl_HalfPixel.x * "
			          "gl_Position.w;");
			statement("gl_Position.y = gl_Position.y + gl_HalfPixel.y * "
			          "gl_Position.w;");
		}

		if (options.vertex.flip_vert_y)
			statement("gl_Position.y = -gl_Position.y;");
		if (options.vertex.fixup_clipspace)
			statement("gl_Position.z = (gl_Position.z + gl_Position.w) * 0.5;");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x25150
cmpl $0x0, 0xb8(%rax)
jne 0xc602b
movq -0x10(%rbp), %rax
cmpl $0x1e, 0x788(%rax)
ja 0xc5fef
movq -0x10(%rbp), %rdi
leaq 0x821b1(%rip), %rsi     # 0x14818b
callq 0xdc4c0
movq -0x10(%rbp), %rdi
leaq 0x821e1(%rip), %rsi     # 0x1481cb
callq 0xdc4c0
movq -0x10(%rbp), %rax
testb $0x1, 0x443(%rax)
je 0xc600c
movq -0x10(%rbp), %rdi
leaq 0x7ee45(%rip), %rsi     # 0x144e4c
callq 0xa8090
movq -0x10(%rbp), %rax
testb $0x1, 0x442(%rax)
je 0xc6029
movq -0x10(%rbp), %rdi
leaq 0x821e7(%rip), %rsi     # 0x14820b
callq 0xdc5e0
jmp 0xc602b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::to_resource_binding_sampler[abi:cxx11](spirv_cross::SPIRVariable const&)
string CompilerHLSL::to_resource_binding_sampler(const SPIRVariable &var)
{
	// For combined image samplers.
	if (!has_decoration(var.self, DecorationBinding))
		return "";

	return to_resource_register('s', get_decoration(var.self, DecorationBinding),
	                            get_decoration(var.self, DecorationDescriptorSet));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x21, %edx
callq 0x1f560
testb $0x1, %al
jne 0xc8501
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7650
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x763c6(%rip), %rsi     # 0x13e89e
callq 0x7520
jmp 0xc84df
leaq -0x19(%rbp), %rdi
callq 0x73d0
jmp 0xc8546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x73d0
jmp 0xc8550
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x21, %edx
callq 0x23520
movq -0x38(%rbp), %rdi
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x22, %edx
callq 0x23520
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x54(%rbp), %ecx
movl %eax, %r8d
movl $0x73, %edx
callq 0xc3d20
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_legacy_uniform(spirv_cross::SPIRVariable const&)
void CompilerHLSL::emit_legacy_uniform(const SPIRVariable &var)
{
	auto &type = get<SPIRType>(var.basetype);
	switch (type.basetype)
	{
	case SPIRType::Sampler:
	case SPIRType::Image:
		SPIRV_CROSS_THROW("Separate image and samplers not supported in legacy HLSL.");

	default:
		statement(variable_decl(var), ";");
		break;
	}
}

// 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 -0x18(%rbp), %rax
movl 0xc(%rax), %eax
orl $0x2, %eax
subl $0xf, %eax
je 0xc8c9f
jmp 0xc8d4e
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7650
movq -0x80(%rbp), %rdx
leaq 0x7f86f(%rip), %rsi     # 0x14853b
leaq -0x38(%rbp), %rdi
callq 0x7520
jmp 0xc8cd7
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9c50
jmp 0xc8ce9
movq -0x88(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0xe50dd(%rip), %rsi     # 0x1addd8
leaq -0xbf072(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0xc8db3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xc8d2f
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 0xc8d40
jmp 0xc8d4c
movq -0x88(%rbp), %rdi
callq 0x72c0
jmp 0xc8daa
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x62d60
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
leaq 0x8032e(%rip), %rdx     # 0x1490a6
callq 0xf270
jmp 0xc8d7f
leaq -0x70(%rbp), %rdi
callq 0x7708
jmp 0xc8da1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7708
jmp 0xc8daa
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_uniform(spirv_cross::SPIRVariable const&)
void CompilerHLSL::emit_uniform(const SPIRVariable &var)
{
	add_resource_name(var.self);
	if (hlsl_options.shader_model >= 40)
		emit_modern_uniform(var);
	else
		emit_legacy_uniform(var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x5c1d0
movq -0x18(%rbp), %rax
cmpl $0x28, 0x788(%rax)
jb 0xc8e00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc8560
jmp 0xc8e0d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc8c60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_store(spirv_cross::Instruction const&)
void CompilerHLSL::emit_store(const Instruction &instruction)
{
	auto ops = stream(instruction);
	auto *chain = maybe_get<SPIRAccessChain>(ops[0]);
	if (chain)
		write_access_chain(*chain, ops[1]);
	else
		CompilerGLSL::emit_instruction(instruction);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2e560
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x2e7f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcbb25
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
callq 0xcac60
jmp 0xcbb32
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x89270
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: hlsl_opcode_is_sign_invariant(spv::Op)
static bool hlsl_opcode_is_sign_invariant(Op opcode)
{
	switch (opcode)
	{
	case OpIEqual:
	case OpINotEqual:
	case OpISub:
	case OpIAdd:
	case OpIMul:
	case OpShiftLeftLogical:
	case OpBitwiseOr:
	case OpBitwiseXor:
	case OpBitwiseAnd:
		return true;

	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x80, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x47, %eax
ja 0xd3262
movq -0x10(%rbp), %rax
leaq 0x729b5(%rip), %rcx     # 0x145c08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0xd3266
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: image_format_to_components(spv::ImageFormat)
static unsigned image_format_to_components(ImageFormat fmt)
{
	switch (fmt)
	{
	case ImageFormatR8:
	case ImageFormatR16:
	case ImageFormatR8Snorm:
	case ImageFormatR16Snorm:
	case ImageFormatR16f:
	case ImageFormatR32f:
	case ImageFormatR8i:
	case ImageFormatR16i:
	case ImageFormatR32i:
	case ImageFormatR8ui:
	case ImageFormatR16ui:
	case ImageFormatR32ui:
		return 1;

	case ImageFormatRg8:
	case ImageFormatRg16:
	case ImageFormatRg8Snorm:
	case ImageFormatRg16Snorm:
	case ImageFormatRg16f:
	case ImageFormatRg32f:
	case ImageFormatRg8i:
	case ImageFormatRg16i:
	case ImageFormatRg32i:
	case ImageFormatRg8ui:
	case ImageFormatRg16ui:
	case ImageFormatRg32ui:
		return 2;

	case ImageFormatR11fG11fB10f:
		return 3;

	case ImageFormatRgba8:
	case ImageFormatRgba16:
	case ImageFormatRgb10A2:
	case ImageFormatRgba8Snorm:
	case ImageFormatRgba16Snorm:
	case ImageFormatRgba16f:
	case ImageFormatRgba32f:
	case ImageFormatRgba8i:
	case ImageFormatRgba16i:
	case ImageFormatRgba32i:
	case ImageFormatRgba8ui:
	case ImageFormatRgba16ui:
	case ImageFormatRgba32ui:
	case ImageFormatRgb10a2ui:
		return 4;

	case ImageFormatUnknown:
		return 4; // Assume 4.

	default:
		SPIRV_CROSS_THROW("Unrecognized typed image format.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x48(%rbp)
subq $0x27, %rax
ja 0xd3618
movq -0x48(%rbp), %rax
leaq 0x7276d(%rip), %rcx     # 0x145d40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xd36b8
movl $0x2, -0x4(%rbp)
jmp 0xd36b8
movl $0x3, -0x4(%rbp)
jmp 0xd36b8
movl $0x4, -0x4(%rbp)
jmp 0xd36b8
movl $0x4, -0x4(%rbp)
jmp 0xd36b8
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7650
movq -0x50(%rbp), %rdx
leaq 0x75c09(%rip), %rsi     # 0x14924b
leaq -0x28(%rbp), %rdi
callq 0x7520
jmp 0xd364d
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9c50
jmp 0xd365c
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0xda76d(%rip), %rsi     # 0x1addd8
leaq -0xc99e2(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0xd36ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd369c
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 0xd36ad
jmp 0xd36b6
movq -0x58(%rbp), %rdi
callq 0x72c0
jmp 0xd36c1
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_hlsl.cpp
// Function: spirv_cross::CompilerHLSL::emit_block_hints(spirv_cross::SPIRBlock const&)
void CompilerHLSL::emit_block_hints(const SPIRBlock &block)
{
	switch (block.hint)
	{
	case SPIRBlock::HintFlatten:
		statement("[flatten]");
		break;
	case SPIRBlock::HintDontFlatten:
		statement("[branch]");
		break;
	case SPIRBlock::HintUnroll:
		statement("[unroll]");
		break;
	case SPIRBlock::HintDontUnroll:
		statement("[loop]");
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0xd3ea8
movq -0x18(%rbp), %rax
leaq 0x71f89(%rip), %rcx     # 0x145de0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
leaq 0x75321(%rip), %rsi     # 0x14918c
callq 0xa81b0
jmp 0xd3eaa
movq -0x20(%rbp), %rdi
leaq 0x75319(%rip), %rsi     # 0x149196
callq 0xa8f80
jmp 0xd3eaa
movq -0x20(%rbp), %rdi
leaq 0x75310(%rip), %rsi     # 0x14919f
callq 0xa8f80
jmp 0xd3eaa
movq -0x20(%rbp), %rdi
leaq 0x75307(%rip), %rsi     # 0x1491a8
callq 0x9e710
jmp 0xd3eaa
jmp 0xd3eaa
addq $0x20, %rsp
popq %rbp
retq
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: create_sampler_address[abi:cxx11](char const*, spirv_cross::MSLSamplerAddress)
static string create_sampler_address(const char *prefix, MSLSamplerAddress addr)
{
	switch (addr)
	{
	case MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE:
		return join(prefix, "address::clamp_to_edge");
	case MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO:
		return join(prefix, "address::clamp_to_zero");
	case MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER:
		return join(prefix, "address::clamp_to_border");
	case MSL_SAMPLER_ADDRESS_REPEAT:
		return join(prefix, "address::repeat");
	case MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT:
		return join(prefix, "address::mirrored_repeat");
	default:
		SPIRV_CROSS_THROW("Invalid sampler addressing mode.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x58(%rbp)
subq $0x4, %rax
ja 0xf3193
movq -0x58(%rbp), %rax
leaq 0x56cd7(%rip), %rcx     # 0x149de4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq 0x5aa6f(%rip), %rdx     # 0x14db94
callq 0x11a590
jmp 0xf3233
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq 0x5aa6d(%rip), %rdx     # 0x14dbab
callq 0x11a590
jmp 0xf3233
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq 0x5aa6b(%rip), %rdx     # 0x14dbc2
callq 0x11a640
jmp 0xf3233
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq 0x5aa6b(%rip), %rdx     # 0x14dbdb
callq 0x11a6f0
jmp 0xf3233
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq 0x5aa62(%rip), %rdx     # 0x14dbeb
callq 0x11a640
jmp 0xf3233
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x78(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7650
movq -0x70(%rbp), %rdx
leaq 0x5aa47(%rip), %rsi     # 0x14dc04
leaq -0x38(%rbp), %rdi
callq 0x7520
jmp 0xf31c8
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9c50
jmp 0xf31d7
movq -0x78(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0xbabf2(%rip), %rsi     # 0x1addd8
leaq -0xe955d(%rip), %rdx    # 0x9c90
callq 0x7610
jmp 0xf3249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xf3217
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 0xf3228
jmp 0xf3231
movq -0x78(%rbp), %rdi
callq 0x72c0
jmp 0xf3240
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::localize_global_variables()
void CompilerMSL::localize_global_variables()
{
	auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
	auto iter = global_variables.begin();
	while (iter != global_variables.end())
	{
		uint32_t v_id = *iter;
		auto &var = get<SPIRVariable>(v_id);
		if (var.storage == StorageClassPrivate || var.storage == StorageClassWorkgroup)
		{
			entry_func.add_local_variable(v_id);
			iter = global_variables.erase(iter);
		}
		else
			iter++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl 0x108(%rdi), %esi
callq 0x106d0
movq -0x50(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x86d0
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x8700
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8730
testb $0x1, %al
jne 0xf6601
jmp 0xf6689
leaq -0x18(%rbp), %rdi
callq 0x8770
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0xfec0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x6, 0x10(%rax)
je 0xf6633
movq -0x30(%rbp), %rax
cmpl $0x4, 0x10(%rax)
jne 0xf6675
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x113b50
movq -0x50(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x30240
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x113b80
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xf6684
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x113bf0
movq %rax, -0x48(%rbp)
jmp 0xf65d7
addq $0x60, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::mark_packable_structs()
void CompilerMSL::mark_packable_structs()
{
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeVariable)
		{
			auto &var = id.get<SPIRVariable>();
			if (var.storage != StorageClassFunction && !is_hidden_variable(var))
			{
				auto &type = get<SPIRType>(var.basetype);
				if (type.pointer &&
				    (type.storage == StorageClassUniform || type.storage == StorageClassUniformConstant ||
				     type.storage == StorageClassPushConstant || type.storage == StorageClassStorageBuffer) &&
				    (has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock)))
					mark_as_packable(type);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf940
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf970
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf9a0
testb $0x1, %al
jne 0xf69e0
jmp 0xf6acc
leaq -0x18(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x2, %eax
jne 0xf6abc
movq -0x28(%rbp), %rdi
callq 0xfd10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x7, 0x10(%rax)
je 0xf6aba
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x20460
testb $0x1, %al
jne 0xf6aba
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0xf6ab8
movq -0x38(%rbp), %rax
cmpl $0x2, 0x64(%rax)
je 0xf6a77
movq -0x38(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0xf6a77
movq -0x38(%rbp), %rax
cmpl $0x9, 0x64(%rax)
je 0xf6a77
movq -0x38(%rbp), %rax
cmpl $0xc, 0x64(%rax)
jne 0xf6ab8
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x2, %edx
callq 0x1f560
testb $0x1, %al
jne 0xf6aab
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x3, %edx
callq 0x1f560
testb $0x1, %al
jne 0xf6aab
jmp 0xf6ab8
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xf9e60
jmp 0xf6aba
jmp 0xf6abc
jmp 0xf6abe
leaq -0x18(%rbp), %rdi
callq 0xfbd0
jmp 0xf69ca
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::resolve_specialized_array_lengths()
void CompilerMSL::resolve_specialized_array_lengths()
{
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeConstant)
		{
			auto &c = id.get<SPIRConstant>();
			if (c.is_used_as_array_length)
				c.specialization = false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf940
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf970
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf9a0
testb $0x1, %al
jne 0xf6b29
jmp 0xf6b78
leaq -0x18(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfa00
cmpl $0x3, %eax
jne 0xf6b6b
movq -0x28(%rbp), %rdi
callq 0x2f2f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x109(%rax)
je 0xf6b69
movq -0x30(%rbp), %rax
movb $0x0, 0x108(%rax)
jmp 0xf6b6b
jmp 0xf6b6d
leaq -0x18(%rbp), %rdi
callq 0xfbd0
jmp 0xf6b16
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::compile[abi:cxx11](std::vector<spirv_cross::MSLVertexAttr, std::allocator<spirv_cross::MSLVertexAttr>>*, std::vector<spirv_cross::MSLResourceBinding, std::allocator<spirv_cross::MSLResourceBinding>>*)
string CompilerMSL::compile(vector<MSLVertexAttr> *p_vtx_attrs, vector<MSLResourceBinding> *p_res_bindings)
{
	if (p_vtx_attrs)
	{
		vtx_attrs_by_location.clear();
		for (auto &va : *p_vtx_attrs)
			vtx_attrs_by_location[va.location] = &va;
	}

	if (p_res_bindings)
	{
		resource_bindings.clear();
		for (auto &rb : *p_res_bindings)
			resource_bindings.push_back(&rb);
	}

	return compile();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf9151
movq -0x70(%rbp), %rdi
addq $0x810, %rdi            # imm = 0x810
callq 0x113a70
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x112a90
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x112ac0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x112af0
testb $0x1, %al
jne 0xf910e
jmp 0xf914f
leaq -0x30(%rbp), %rdi
callq 0x112b30
movq -0x70(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x810, %rdi            # imm = 0x810
movq -0x40(%rbp), %rsi
callq 0x112b50
movq -0x88(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x112b80
jmp 0xf90fb
jmp 0xf9151
cmpq $0x0, -0x20(%rbp)
je 0xf91d3
movq -0x70(%rbp), %rdi
addq $0x8f8, %rdi            # imm = 0x8F8
callq 0x113a90
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x112ba0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x112bd0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x112c00
testb $0x1, %al
jne 0xf919d
jmp 0xf91d1
leaq -0x50(%rbp), %rdi
callq 0x112c40
movq -0x70(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x8f8, %rdi            # imm = 0x8F8
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x112c60
leaq -0x50(%rbp), %rdi
callq 0x112c90
jmp 0xf918a
jmp 0xf91d3
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop