LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::mark_as_packable(spirv_cross::SPIRType&)
void CompilerMSL::mark_as_packable(SPIRType &type)
{
	// If this is not the base type (eg. it's a pointer or array), tunnel down
	if (type.parent_type)
	{
		mark_as_packable(get<SPIRType>(type.parent_type));
		return;
	}

	if (type.basetype == SPIRType::Struct)
	{
		set_decoration(type.self, DecorationCPacked);

		// Recurse
		size_t mbr_cnt = type.member_types.size();
		for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++)
		{
			uint32_t mbr_type_id = type.member_types[mbr_idx];
			auto &mbr_type = get<SPIRType>(mbr_type_id);
			mark_as_packable(mbr_type);
			if (mbr_type.type_alias)
			{
				auto &mbr_type_alias = get<SPIRType>(mbr_type.type_alias);
				mark_as_packable(mbr_type_alias);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0xf9ea9
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x9c(%rax), %esi
callq 0xea90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xf9e60
jmp 0xf9f63
movq -0x10(%rbp), %rax
cmpl $0xc, 0xc(%rax)
jne 0xf9f63
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x232d0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x8650
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0xf9f61
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8630
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0xea90
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0xf9e60
movq -0x28(%rbp), %rax
cmpl $0x0, 0x98(%rax)
je 0xf9f54
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x98(%rax), %esi
callq 0xea90
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0xf9e60
jmp 0xf9f56
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf9ee6
jmp 0xf9f63
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::mark_location_as_used_by_shader(unsigned int, spv::StorageClass)
void CompilerMSL::mark_location_as_used_by_shader(uint32_t location, StorageClass storage)
{
	MSLVertexAttr *p_va;
	if ((get_entry_point().model == ExecutionModelVertex) && (storage == StorageClassInput) &&
	    (p_va = vtx_attrs_by_location[location]))
		p_va->used_by_shader = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x25150
cmpl $0x0, 0xb8(%rax)
jne 0xf9fc7
cmpl $0x1, -0x10(%rbp)
jne 0xf9fc7
movq -0x20(%rbp), %rdi
addq $0x810, %rdi            # imm = 0x810
leaq -0xc(%rbp), %rsi
callq 0x112b50
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xf9fc7
movq -0x18(%rbp), %rax
movb $0x1, 0x11(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::ensure_correct_builtin_type(unsigned int, spv::BuiltIn)
uint32_t CompilerMSL::ensure_correct_builtin_type(uint32_t type_id, BuiltIn builtin)
{
	auto &type = get<SPIRType>(type_id);

	if ((builtin == BuiltInSampleMask && is_array(type)) ||
	    ((builtin == BuiltInLayer || builtin == BuiltInViewportIndex) && type.basetype != SPIRType::UInt))
	{
		uint32_t next_id = ir.increase_bound_by(type.pointer ? 2 : 1);
		uint32_t base_type_id = next_id++;
		auto &base_type = set<SPIRType>(base_type_id);
		base_type.basetype = SPIRType::UInt;
		base_type.width = 32;

		if (!type.pointer)
			return base_type_id;

		uint32_t ptr_type_id = next_id++;
		auto &ptr_type = set<SPIRType>(ptr_type_id);
		ptr_type = base_type;
		ptr_type.pointer = true;
		ptr_type.storage = type.storage;
		ptr_type.parent_type = base_type_id;
		return ptr_type_id;
	}

	return type_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %esi
callq 0xea90
movq %rax, -0x20(%rbp)
cmpl $0x14, -0x18(%rbp)
jne 0xfa00d
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0xfa02b
cmpl $0x9, -0x18(%rbp)
je 0xfa01d
cmpl $0xa, -0x18(%rbp)
jne 0xfa0ee
movq -0x20(%rbp), %rax
cmpl $0x5, 0xc(%rax)
je 0xfa0ee
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rax
movb 0x60(%rax), %cl
movl $0x1, %esi
movl $0x2, %eax
testb $0x1, %cl
cmovnel %eax, %esi
callq 0x55780
movq -0x48(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0x30cb0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x5, 0xc(%rax)
movq -0x30(%rbp), %rax
movl $0x20, 0x10(%rax)
movq -0x20(%rbp), %rax
testb $0x1, 0x60(%rax)
jne 0xfa098
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfa0f4
movq -0x48(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
callq 0x30cb0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x2f600
movq -0x40(%rbp), %rax
movb $0x1, 0x60(%rax)
movq -0x20(%rbp), %rax
movl 0x64(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x64(%rax)
movl -0x28(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x9c(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfa0f4
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::to_qualified_member_name[abi:cxx11](spirv_cross::SPIRType const&, unsigned int)
string CompilerMSL::to_qualified_member_name(const SPIRType &type, uint32_t index)
{
	// Don't qualify Builtin names because they are unique and are treated as such when building expressions
	BuiltIn builtin;
	if (is_member_builtin(type, index, &builtin))
		return builtin_to_glsl(builtin, type.storage);

	// Strip any underscore prefix from member name
	string mbr_name = to_member_name(type, index);
	size_t startPos = mbr_name.find_first_not_of("_");
	mbr_name = (startPos != string::npos) ? mbr_name.substr(startPos) : "";
	return join(to_name(type.self), "_", mbr_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x20(%rbp), %rcx
callq 0x20760
testb $0x1, %al
jne 0xfa14c
jmp 0xfa172
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rdi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x64(%rax), %ecx
movq (%rsi), %rax
callq *0xa0(%rax)
jmp 0xfa2cd
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x40(%rbp), %rdi
callq 0x62230
leaq -0x40(%rbp), %rdi
leaq 0x4e38a(%rip), %rsi     # 0x14851e
xorl %eax, %eax
movl %eax, %edx
callq 0x71f0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, -0x76(%rbp)
cmpq $-0x1, %rax
je 0xfa1cb
movq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq $-0x1, %rcx
callq 0x73a0
jmp 0xfa1c9
jmp 0xfa1fa
leaq -0x75(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x7650
movq -0xb8(%rbp), %rdx
movb $0x1, -0x76(%rbp)
leaq 0x446b1(%rip), %rsi     # 0x13e89e
leaq -0x68(%rbp), %rdi
callq 0x7520
jmp 0xfa1f8
jmp 0xfa1fa
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7430
leaq -0x68(%rbp), %rdi
callq 0x7708
testb $0x1, -0x76(%rbp)
jne 0xfa218
jmp 0xfa221
leaq -0x75(%rbp), %rdi
callq 0x73d0
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq -0x98(%rbp), %rdi
movl $0x1, %ecx
callq *%rax
jmp 0xfa246
movq -0xb0(%rbp), %rdi
leaq 0x4e2ca(%rip), %rdx     # 0x14851e
leaq -0x98(%rbp), %rsi
leaq -0x40(%rbp), %rcx
callq 0x9ff30
jmp 0xfa266
leaq -0x98(%rbp), %rdi
callq 0x7708
leaq -0x40(%rbp), %rdi
callq 0x7708
jmp 0xfa2cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xfa2c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
testb $0x1, -0x76(%rbp)
jne 0xfa29f
jmp 0xfa2a8
leaq -0x75(%rbp), %rdi
callq 0x73d0
jmp 0xfa2c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x7708
leaq -0x40(%rbp), %rdi
callq 0x7708
jmp 0xfa2dd
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::get_struct_member_key(unsigned int, unsigned int)
MSLStructMemberKey CompilerMSL::get_struct_member_key(uint32_t type_id, uint32_t index)
{
	MSLStructMemberKey k = type_id;
	k <<= 32;
	k += index;
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::emit_header()
void CompilerMSL::emit_header()
{
	for (auto &pragma : pragma_lines)
		statement(pragma);

	if (!pragma_lines.empty())
		statement("");

	statement("#include <metal_stdlib>");
	statement("#include <simd/simd.h>");

	for (auto &header : header_lines)
		statement(header);

	statement("");
	statement("using namespace metal;");
	statement("");

	for (auto &td : typedef_lines)
		statement(td);

	if (!typedef_lines.empty())
		statement("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x880, %rax            # imm = 0x880
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x114100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x114130
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x114160
testb $0x1, %al
jne 0xfafdb
jmp 0xfb000
leaq -0x18(%rbp), %rdi
callq 0x114190
movq -0x70(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x1141c0
leaq -0x18(%rbp), %rdi
callq 0x1142e0
jmp 0xfafc8
movq -0x70(%rbp), %rdi
addq $0x880, %rdi            # imm = 0x880
callq 0x114310
testb $0x1, %al
jne 0xfb024
movq -0x70(%rbp), %rdi
leaq 0x4387f(%rip), %rsi     # 0x13e89e
callq 0xedf0
movq -0x70(%rbp), %rdi
leaq 0x4fbdd(%rip), %rsi     # 0x14ac0c
callq 0x114330
movq -0x70(%rbp), %rdi
leaq 0x4fbe5(%rip), %rsi     # 0x14ac24
callq 0x10fd0
movq -0x70(%rbp), %rax
addq $0x738, %rax            # imm = 0x738
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10140
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10170
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x101a0
testb $0x1, %al
jne 0xfb07f
jmp 0xfb0a4
leaq -0x38(%rbp), %rdi
callq 0x101e0
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x10200
leaq -0x38(%rbp), %rdi
callq 0x10320
jmp 0xfb06c
movq -0x70(%rbp), %rdi
leaq 0x437ef(%rip), %rsi     # 0x13e89e
callq 0xedf0
movq -0x70(%rbp), %rdi
leaq 0x4fb7c(%rip), %rsi     # 0x14ac3b
callq 0x10fd0
movq -0x70(%rbp), %rdi
leaq 0x437cf(%rip), %rsi     # 0x13e89e
callq 0xedf0
movq -0x70(%rbp), %rax
addq $0x8b0, %rax            # imm = 0x8B0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x114100
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x114130
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x114160
testb $0x1, %al
jne 0xfb10f
jmp 0xfb134
leaq -0x58(%rbp), %rdi
callq 0x114190
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
callq 0x1141c0
leaq -0x58(%rbp), %rdi
callq 0x1142e0
jmp 0xfb0fc
movq -0x70(%rbp), %rdi
addq $0x8b0, %rdi            # imm = 0x8B0
callq 0x114310
testb $0x1, %al
jne 0xfb158
movq -0x70(%rbp), %rdi
leaq 0x4374b(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::declare_undefined_values()
void CompilerMSL::declare_undefined_values()
{
	bool emitted = false;
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeUndef)
		{
			auto &undef = id.get<SPIRUndef>();
			auto &type = get<SPIRType>(undef.basetype);
			statement("constant ", variable_decl(type, to_name(undef.self), undef.self), " = {};");
			emitted = true;
		}
	}

	if (emitted)
		statement("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%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 0xfb21a
jmp 0xfb340
leaq -0x20(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xfa00
cmpl $0xd, %eax
jne 0xfb330
movq -0x30(%rbp), %rdi
callq 0xa0db0
movq -0x98(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq -0x98(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %edx
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x1, %ecx
callq *%rax
movq -0x98(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
movq -0x38(%rbp), %rax
movl 0x8(%rax), %r8d
movq (%rsi), %rax
movq 0xc8(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0xfb2be
movq -0x98(%rbp), %rdi
leaq 0x5161d(%rip), %rsi     # 0x14c8e9
leaq 0x51620(%rip), %rcx     # 0x14c8f3
leaq -0x60(%rbp), %rdx
callq 0x115e50
jmp 0xfb2de
leaq -0x60(%rbp), %rdi
callq 0x7708
leaq -0x80(%rbp), %rdi
callq 0x7708
movb $0x1, -0x9(%rbp)
jmp 0xfb330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xfb325
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7708
leaq -0x80(%rbp), %rdi
callq 0x7708
jmp 0xfb362
jmp 0xfb332
leaq -0x20(%rbp), %rdi
callq 0xfbd0
jmp 0xfb204
testb $0x1, -0x9(%rbp)
je 0xfb359
movq -0x98(%rbp), %rdi
leaq 0x4354a(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x7640
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::declare_constant_arrays()
void CompilerMSL::declare_constant_arrays()
{
	// MSL cannot declare arrays inline (except when declaring a variable), so we must move them out to
	// global constants directly, so we are able to use constants as variable expressions.
	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.array.empty())
			{
				auto name = to_name(c.self);
				statement("constant ", 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 0xfb3ca
jmp 0xfb559
leaq -0x20(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xfa00
cmpl $0x3, %eax
jne 0xfb549
movq -0x30(%rbp), %rdi
callq 0x2f2f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0x108(%rax)
je 0xfb408
jmp 0xfb54b
movq -0xb8(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x8690
testb $0x1, %al
jne 0xfb547
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 0xfb482
movq -0xb8(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x64bc0
jmp 0xfb49b
movq -0xb8(%rbp), %rdi
leaq 0x51440(%rip), %rsi     # 0x14c8e9
leaq 0x4db5f(%rip), %rcx     # 0x14900f
leaq 0x4dbef(%rip), %r9      # 0x1490a6
leaq -0x80(%rbp), %rdx
leaq -0xb0(%rbp), %r8
callq 0x115f80
jmp 0xfb4c9
leaq -0xb0(%rbp), %rdi
callq 0x7708
leaq -0x80(%rbp), %rdi
callq 0x7708
movb $0x1, -0x9(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7708
jmp 0xfb547
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xfb53c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xfb533
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 0xfb57b
jmp 0xfb549
jmp 0xfb54b
leaq -0x20(%rbp), %rdi
callq 0xfbd0
jmp 0xfb3b4
testb $0x1, -0x9(%rbp)
je 0xfb572
movq -0xb8(%rbp), %rdi
leaq 0x43331(%rip), %rsi     # 0x13e89e
callq 0xedf0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::emit_interface_block(unsigned int)
void CompilerMSL::emit_interface_block(uint32_t ib_var_id)
{
	if (ib_var_id)
	{
		auto &ib_var = get<SPIRVariable>(ib_var_id);
		auto &ib_type = get<SPIRType>(ib_var.basetype);
		assert(ib_type.basetype == SPIRType::Struct && !ib_type.member_types.empty());
		emit_struct(ib_type);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xfb629
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xfec0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0xc, 0xc(%rcx)
movb %al, -0x29(%rbp)
jne 0xfb5f2
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x8690
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xfb5fb
jmp 0xfb5fd
jmp 0xfb61c
leaq 0x519e4(%rip), %rdi     # 0x14cfe8
leaq 0x4f4b4(%rip), %rsi     # 0x14aabf
movl $0xb16, %edx            # imm = 0xB16
leaq 0x51a17(%rip), %rcx     # 0x14d02e
callq 0x7260
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5bf00
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::emit_array_copy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
void CompilerMSL::emit_array_copy(const string &lhs, uint32_t rhs_id)
{
	// Assignment from an array initializer is fine.
	auto &type = expression_type(rhs_id);
	auto *var = maybe_get_backing_variable(rhs_id);

	// Unfortunately, we cannot template on address space in MSL,
	// so explicit address space redirection it is ...
	bool is_constant = false;
	if (ir.ids[rhs_id].get_type() == TypeConstant)
	{
		is_constant = true;
	}
	else if (var && var->remapped_variable && var->statically_assigned &&
	         ir.ids[var->static_expression].get_type() == TypeConstant)
	{
		is_constant = true;
	}

	const char *tag = is_constant ? "FromConstant" : "FromStack";
	statement("spvArrayCopy", tag, type.array.size(), "(", lhs, ", ", to_expression(rhs_id), ");");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl -0x14(%rbp), %esi
callq 0x1f760
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %esi
callq 0x1fa90
movq -0x78(%rbp), %rdi
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
addq $0x8, %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xbdb0
movq %rax, %rdi
callq 0xfa00
cmpl $0x3, %eax
jne 0xff487
movb $0x1, -0x29(%rbp)
jmp 0xff4cf
cmpq $0x0, -0x28(%rbp)
je 0xff4cd
movq -0x28(%rbp), %rax
testb $0x1, 0x5b(%rax)
je 0xff4cd
movq -0x28(%rbp), %rax
testb $0x1, 0x39(%rax)
je 0xff4cd
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, %esi
callq 0xbdb0
movq %rax, %rdi
callq 0xfa00
cmpl $0x3, %eax
jne 0xff4cd
movb $0x1, -0x29(%rbp)
jmp 0xff4cf
movb -0x29(%rbp), %dl
leaq 0x4bbc5(%rip), %rcx     # 0x14b09e
leaq 0x4bbb4(%rip), %rax     # 0x14b094
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x8650
movq -0x78(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x14(%rbp), %edx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x71b50
movq -0x88(%rbp), %rcx
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %r9
leaq 0x49b74(%rip), %rdx     # 0x1490a5
movq %rsp, %rax
movq %rdx, 0x10(%rax)
movq %rcx, 0x8(%rax)
leaq 0x4504c(%rip), %rcx     # 0x14458f
movq %rcx, (%rax)
leaq 0x4bb8c(%rip), %rsi     # 0x14b0d9
leaq 0x4ddd9(%rip), %r8      # 0x14d32d
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x116b20
jmp 0xff563
leaq -0x60(%rbp), %rdi
callq 0x7708
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7708
movq -0x68(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::to_func_call_arg[abi:cxx11](unsigned int)
string CompilerMSL::to_func_call_arg(uint32_t id)
{
	string arg_str = CompilerGLSL::to_func_call_arg(id);

	// Manufacture automatic sampler arg if the arg is a SampledImage texture.
	auto &type = expression_type(id);
	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 $0x90, %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), %rdi
movl -0x14(%rbp), %esi
callq 0x1f760
movq %rax, -0x78(%rbp)
jmp 0x1065bd
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xe, 0xc(%rax)
jne 0x10666e
movq -0x20(%rbp), %rax
cmpl $0x5, 0x84(%rax)
je 0x10666e
movq -0x80(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x70(%rbp), %rdi
callq 0xf3250
jmp 0x1065f6
leaq 0x3df92(%rip), %rsi     # 0x14458f
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0xa6db0
jmp 0x10660c
movq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7470
jmp 0x10661e
leaq -0x50(%rbp), %rdi
callq 0x7708
leaq -0x70(%rbp), %rdi
callq 0x7708
jmp 0x10666e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x106694
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x106663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7708
leaq -0x70(%rbp), %rdi
callq 0x7708
jmp 0x106694
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x106684
movq -0x90(%rbp), %rdi
callq 0x7708
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x7708
movq -0x28(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::is_non_native_row_major_matrix(unsigned int)
bool CompilerMSL::is_non_native_row_major_matrix(uint32_t id)
{
	// Natively supported row-major matrices do not need to be converted.
	if (backend.native_row_major_matrix)
		return false;

	// Non-matrix or column-major matrix types do not need to be converted.
	if (!ir.meta[id].decoration.decoration_flags.get(DecorationRowMajor))
		return false;

	// Generate a function that will swap matrix elements from row-major to column-major.
	// Packed row-matrix should just use transpose() function.
	if (!has_decoration(id, DecorationCPacked))
	{
		const auto type = expression_type(id);
		add_convert_row_major_matrix_function(type.columns, type.vecsize);
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
testb $0x1, 0x628(%rax)
je 0x1066df
movb $0x0, -0x1(%rbp)
jmp 0x106798
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xead0
movq %rax, %rdi
addq $0x60, %rdi
movl $0x4, %esi
callq 0xef50
testb $0x1, %al
jne 0x106716
movb $0x0, -0x1(%rbp)
jmp 0x106798
movq -0x108(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0xa, %edx
callq 0x1f560
testb $0x1, %al
jne 0x106794
movq -0x108(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f760
movq %rax, %rsi
leaq -0xf0(%rbp), %rdi
callq 0x3d730
movq -0x108(%rbp), %rdi
movl -0xdc(%rbp), %edx
movl -0xd8(%rbp), %esi
callq 0x1067c0
jmp 0x106766
leaq -0xf0(%rbp), %rdi
callq 0x314e0
jmp 0x106794
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x314e0
jmp 0x1067a6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::member_is_non_native_row_major_matrix(spirv_cross::SPIRType const&, unsigned int)
bool CompilerMSL::member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index)
{
	// Natively supported row-major matrices do not need to be converted.
	if (backend.native_row_major_matrix)
		return false;

	// Non-matrix or column-major matrix types do not need to be converted.
	if (!combined_decoration_for_member(type, index).get(DecorationRowMajor))
		return false;

	// Generate a function that will swap matrix elements from row-major to column-major.
	// Packed row-matrix should just use transpose() function.
	if (!has_member_decoration(type.self, index, DecorationCPacked))
	{
		const auto mbr_type = get<SPIRType>(type.member_types[index]);
		add_convert_row_major_matrix_function(mbr_type.columns, mbr_type.vecsize);
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
testb $0x1, 0x628(%rax)
je 0x106a63
movb $0x0, -0x1(%rbp)
jmp 0x106b74
movq -0x150(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x2c660
movq -0x160(%rbp), %rdi
movl $0x4, %esi
callq 0xef50
movb %al, -0x151(%rbp)
jmp 0x106a9a
movb -0x151(%rbp), %al
xorb $-0x1, %al
movb %al, -0x161(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf250
movb -0x161(%rbp), %al
testb $0x1, %al
jne 0x106abd
jmp 0x106ae0
movb $0x0, -0x1(%rbp)
jmp 0x106b74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf250
jmp 0x106b82
movq -0x150(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x1c(%rbp), %edx
movl $0xa, %ecx
callq 0x21f90
testb $0x1, %al
jne 0x106b70
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8570
movq -0x150(%rbp), %rdi
movl (%rax), %esi
callq 0xea90
movq %rax, %rsi
leaq -0x148(%rbp), %rdi
callq 0x3d730
movq -0x150(%rbp), %rdi
movl -0x134(%rbp), %edx
movl -0x130(%rbp), %esi
callq 0x1067c0
jmp 0x106b48
leaq -0x148(%rbp), %rdi
callq 0x314e0
jmp 0x106b70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x314e0
jmp 0x106b82
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7640
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::emit_fixup()
void CompilerMSL::emit_fixup()
{
	if ((get_entry_point().model == ExecutionModelVertex) && stage_out_var_id && !qual_pos_var_name.empty())
	{
		if (options.vertex.fixup_clipspace)
			statement(qual_pos_var_name, ".z = (", qual_pos_var_name, ".z + ", qual_pos_var_name,
			          ".w) * 0.5;       // Adjust clip-space for Metal");

		if (options.vertex.flip_vert_y)
			statement(qual_pos_var_name, ".y = -(", qual_pos_var_name, ".y);", "    // Invert Y-axis for Metal");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x25150
cmpl $0x0, 0xb8(%rax)
jne 0x106f0d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x930(%rax)
je 0x106f0d
movq -0x10(%rbp), %rdi
addq $0x940, %rdi            # imm = 0x940
callq 0x75f0
testb $0x1, %al
jne 0x106f0d
movq -0x10(%rbp), %rax
testb $0x1, 0x442(%rax)
je 0x106ecc
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x940, %rsi            # imm = 0x940
movq %rdi, %rcx
addq $0x940, %rcx            # imm = 0x940
movq %rdi, %r9
addq $0x940, %r9             # imm = 0x940
leaq 0x46473(%rip), %rdx     # 0x14d328
leaq 0x46473(%rip), %r8      # 0x14d32f
leaq 0x46472(%rip), %rax     # 0x14d335
movq %rax, (%rsp)
callq 0x117120
movq -0x10(%rbp), %rax
testb $0x1, 0x443(%rax)
je 0x106f0b
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x940, %rsi            # imm = 0x940
movq %rdi, %rcx
addq $0x940, %rcx            # imm = 0x940
leaq 0x4646d(%rip), %rdx     # 0x14d365
leaq 0x3f41b(%rip), %r8      # 0x14631a
leaq 0x46467(%rip), %r9      # 0x14d36d
callq 0x117290
jmp 0x106f0d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::get_ordered_member_location(unsigned int, unsigned int, unsigned int*)
uint32_t CompilerMSL::get_ordered_member_location(uint32_t type_id, uint32_t index, uint32_t *comp)
{
	auto &m = ir.meta.at(type_id);
	if (index < m.members.size())
	{
		auto &dec = m.members[index];
		if (comp)
		{
			if (dec.decoration_flags.get(DecorationComponent))
				*comp = dec.component;
			else
				*comp = k_unknown_component;
		}
		if (dec.decoration_flags.get(DecorationLocation))
			return dec.location;
	}

	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2f5c0
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2eca0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x10a162
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10a139
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movl $0x1f, %esi
callq 0xef50
testb $0x1, %al
jne 0x10a11b
jmp 0x10a12d
movq -0x30(%rbp), %rax
movl 0xa8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x10a137
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x10a139
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movl $0x1e, %esi
callq 0xef50
testb $0x1, %al
jne 0x10a151
jmp 0x10a160
movq -0x30(%rbp), %rax
movl 0xa4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x10a168
jmp 0x10a162
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::built_in_func_arg[abi:cxx11](spv::BuiltIn, bool)
string CompilerMSL::built_in_func_arg(BuiltIn builtin, bool prefix_comma)
{
	string bi_arg;
	if (prefix_comma)
		bi_arg += ", ";

	bi_arg += builtin_type_decl(builtin);
	bi_arg += " " + builtin_to_glsl(builtin, StorageClassInput);
	bi_arg += " [[" + builtin_qualifier(builtin) + "]]";

	return bi_arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x100(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xf8(%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, -0xf0(%rbp)
movb $0x0, -0x16(%rbp)
callq 0x7530
testb $0x1, -0x15(%rbp)
je 0x10aed0
movq -0x100(%rbp), %rdi
leaq 0x396d9(%rip), %rsi     # 0x14458f
callq 0x7340
jmp 0x10aebd
jmp 0x10aed0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10b0b5
movq -0xf0(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x10a360
jmp 0x10aee5
movq -0x100(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7470
jmp 0x10aef7
leaq -0x48(%rbp), %rdi
callq 0x7708
movq -0xf0(%rbp), %rsi
movl -0x14(%rbp), %edx
movq (%rsi), %rax
movq 0xa0(%rax), %rax
leaq -0x88(%rbp), %rdi
movl $0x1, %ecx
callq *%rax
jmp 0x10af24
leaq 0x33972(%rip), %rsi     # 0x13e89d
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0xa6db0
jmp 0x10af3d
movq -0x100(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7470
jmp 0x10af4f
leaq -0x68(%rbp), %rdi
callq 0x7708
leaq -0x88(%rbp), %rdi
callq 0x7708
movq -0xf0(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0xe8(%rbp), %rdi
callq 0x109330
jmp 0x10af7c
leaq 0x42423(%rip), %rsi     # 0x14d3a6
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rdx
callq 0xa6db0
jmp 0x10af98
leaq 0x4251a(%rip), %rdx     # 0x14d4b9
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x11910
jmp 0x10afb4
movq -0x100(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x7470
jmp 0x10afc9
leaq -0xa8(%rbp), %rdi
callq 0x7708
leaq -0xc8(%rbp), %rdi
callq 0x7708
leaq -0xe8(%rbp), %rdi
callq 0x7708
movb $0x1, -0x16(%rbp)
testb $0x1, -0x16(%rbp)
jne 0x10b0a5
jmp 0x10b099
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x10b0b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10b03d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7708
leaq -0x88(%rbp), %rdi
callq 0x7708
jmp 0x10b0b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10b08b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10b07f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x7708
leaq -0xc8(%rbp), %rdi
callq 0x7708
leaq -0xe8(%rbp), %rdi
callq 0x7708
jmp 0x10b0b5
movq -0x100(%rbp), %rdi
callq 0x7708
movq -0xf8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x100(%rbp), %rdi
callq 0x7708
movq -0x20(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::to_name[abi:cxx11](unsigned int, bool) const
string CompilerMSL::to_name(uint32_t id, bool allow_alias) const
{
	if (current_function && (current_function->self == ir.default_entry_point))
	{
		string qual_name = ir.meta.at(id).decoration.qualified_alias;
		if (!qual_name.empty())
			return qual_name;
	}
	return Compiler::to_name(id, allow_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)
cmpq $0x0, 0x148(%rax)
je 0x10b1e4
movq -0x28(%rbp), %rcx
movq 0x148(%rcx), %rax
movl 0x8(%rax), %eax
cmpl 0x108(%rcx), %eax
jne 0x10b1e4
movq -0x28(%rbp), %rdi
movb $0x0, -0x16(%rbp)
addq $0x8, %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa50
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x7170
movq -0x38(%rbp), %rdi
callq 0x75f0
testb $0x1, %al
jne 0x10b1c1
movb $0x1, -0x16(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x10b1c8
movl $0x0, -0x1c(%rbp)
testb $0x1, -0x16(%rbp)
jne 0x10b1d7
movq -0x38(%rbp), %rdi
callq 0x7708
movl -0x1c(%rbp), %eax
testl %eax, %eax
je 0x10b1e2
jmp 0x10b1e0
jmp 0x10b1fc
jmp 0x10b1e4
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %edx
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x1f790
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::to_member_reference[abi:cxx11](spirv_cross::SPIRVariable const*, spirv_cross::SPIRType const&, unsigned int)
string CompilerMSL::to_member_reference(const SPIRVariable *var, const SPIRType &type, uint32_t index)
{
	// If this is a buffer array, we have to dereference the buffer pointers.
	if (var && (var->storage == StorageClassUniform || var->storage == StorageClassStorageBuffer) &&
	    !get<SPIRType>(var->basetype).array.empty())
		return join("->", to_member_name(type, index));
	else
		return join(".", to_member_name(type, index));
}

// 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)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10be10
movq -0x18(%rbp), %rax
cmpl $0x2, 0x10(%rax)
je 0x10bd97
movq -0x18(%rbp), %rax
cmpl $0xc, 0x10(%rax)
jne 0x10be10
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, %rdi
addq $0x20, %rdi
callq 0x8690
testb $0x1, %al
jne 0x10be10
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x62230
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0x32403(%rip), %rsi     # 0x13e1ea
callq 0x117ae0
jmp 0x10bdee
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x10be69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7708
jmp 0x10be79
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x62230
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rdx
leaq 0x38eed(%rip), %rsi     # 0x144d2d
callq 0xa6fd0
jmp 0x10be47
leaq -0x78(%rbp), %rdi
callq 0x7708
jmp 0x10be69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x7708
jmp 0x10be79
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::to_qualifiers_glsl[abi:cxx11](unsigned int)
string CompilerMSL::to_qualifiers_glsl(uint32_t id)
{
	string quals;

	auto &type = expression_type(id);
	if (type.storage == StorageClassWorkgroup)
		quals += "threadgroup ";

	return quals;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x7530
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f760
movq %rax, -0x38(%rbp)
jmp 0x10bed1
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, 0x64(%rax)
jne 0x10bf0e
movq -0x50(%rbp), %rdi
leaq 0x416bf(%rip), %rsi     # 0x14d5ad
callq 0x7340
jmp 0x10bef5
jmp 0x10bf0e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7708
jmp 0x10bf2b
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x10bf21
movq -0x50(%rbp), %rdi
callq 0x7708
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::SampledImageScanner::handle(spv::Op, unsigned int const*, unsigned int)
bool CompilerMSL::SampledImageScanner::handle(spv::Op opcode, const uint32_t *args, uint32_t length)
{
	switch (opcode)
	{
	case OpLoad:
	case OpImage:
	case OpSampledImage:
	{
		if (length < 3)
			return false;

		uint32_t result_type = args[0];
		auto &type = compiler.get<SPIRType>(result_type);
		if ((type.basetype != SPIRType::Image && type.basetype != SPIRType::SampledImage) || type.image.sampled != 1)
			return true;

		uint32_t id = args[1];
		compiler.set<SPIRExpression>(id, "", result_type, true);
		break;
	}
	case OpImageSampleExplicitLod:
	case OpImageSampleProjExplicitLod:
	case OpImageSampleDrefExplicitLod:
	case OpImageSampleProjDrefExplicitLod:
	case OpImageSampleImplicitLod:
	case OpImageSampleProjImplicitLod:
	case OpImageSampleDrefImplicitLod:
	case OpImageSampleProjDrefImplicitLod:
	case OpImageFetch:
	case OpImageGather:
	case OpImageDrefGather:
		compiler.has_sampled_images =
		    compiler.has_sampled_images || compiler.is_sampled_image_type(compiler.expression_type(args[2]));
		break;
	default:
		break;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x3d, %eax
je 0x10dc04
jmp 0x10dbdb
movl -0x3c(%rbp), %eax
subl $0x56, %eax
je 0x10dc04
jmp 0x10dbe5
movl -0x3c(%rbp), %eax
addl $-0x57, %eax
subl $0xb, %eax
jb 0x10dc89
jmp 0x10dbf6
movl -0x3c(%rbp), %eax
subl $0x64, %eax
jne 0x10dce0
jmp 0x10dc04
cmpl $0x3, -0x24(%rbp)
jae 0x10dc13
movb $0x0, -0x1(%rbp)
jmp 0x10dce6
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movl -0x28(%rbp), %esi
callq 0xea90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0xd, 0xc(%rax)
je 0x10dc44
movq -0x30(%rbp), %rax
cmpl $0xe, 0xc(%rax)
jne 0x10dc51
movq -0x30(%rbp), %rax
cmpl $0x1, 0x8c(%rax)
je 0x10dc5a
movb $0x1, -0x1(%rbp)
jmp 0x10dce6
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, -0x34(%rbp)
movq 0x8(%rax), %rdi
movl -0x34(%rbp), %esi
movb $0x1, -0x35(%rbp)
leaq 0x30c24(%rip), %rdx     # 0x13e89e
leaq -0x28(%rbp), %rcx
leaq -0x35(%rbp), %r8
callq 0x30ef0
jmp 0x10dce2
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movb $0x1, %al
testb $0x1, 0x934(%rcx)
movb %al, -0x49(%rbp)
jne 0x10dcca
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1f760
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x22ec0
movb %al, -0x49(%rbp)
movq -0x48(%rbp), %rax
movb -0x49(%rbp), %cl
movq 0x8(%rax), %rax
andb $0x1, %cl
movb %cl, 0x934(%rax)
jmp 0x10dce2
jmp 0x10dce2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::OpCodePreprocessor::check_resource_write(unsigned int)
void CompilerMSL::OpCodePreprocessor::check_resource_write(uint32_t var_id)
{
	auto *p_var = compiler.maybe_get_backing_variable(var_id);
	StorageClass sc = p_var ? p_var->storage : StorageClassMax;
	if (sc == StorageClassUniform || sc == StorageClassStorageBuffer)
		uses_resource_write = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x1fa90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10e4da
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x10e4e4
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x10e4e4
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x10e4f6
cmpl $0xc, -0x1c(%rbp)
jne 0x10e4fe
movq -0x28(%rbp), %rax
movb $0x1, 0x4a(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::MemberSorter::operator()(unsigned int, unsigned int)
bool CompilerMSL::MemberSorter::operator()(uint32_t mbr_idx1, uint32_t mbr_idx2)
{
	auto &mbr_meta1 = meta.members[mbr_idx1];
	auto &mbr_meta2 = meta.members[mbr_idx2];
	if (mbr_meta1.builtin != mbr_meta2.builtin)
		return mbr_meta2.builtin;
	else
		switch (sort_aspect)
		{
		case Location:
			return mbr_meta1.location < mbr_meta2.location;
		case LocationReverse:
			return mbr_meta1.location > mbr_meta2.location;
		case Offset:
			return mbr_meta1.offset < mbr_meta2.offset;
		case OffsetThenLocationReverse:
			return (mbr_meta1.offset < mbr_meta2.offset) ||
			       ((mbr_meta1.offset == mbr_meta2.offset) && (mbr_meta1.location > mbr_meta2.location));
		case Alphabetical:
			return mbr_meta1.alias < mbr_meta2.alias;
		default:
			return false;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rdi
addq $0xd0, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
addq $0xd0, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2fa30
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb 0xcc(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
movb 0xcc(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x10e59a
movq -0x28(%rbp), %rax
movb 0xcc(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10e69b
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x10e697
movq -0x38(%rbp), %rax
leaq 0x3bfe6(%rip), %rcx     # 0x14a5a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl 0xa4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10e69b
movq -0x20(%rbp), %rax
movl 0xa4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10e69b
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xb4(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10e69b
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %ecx
movq -0x28(%rbp), %rdx
movb $0x1, %al
cmpl 0xb4(%rdx), %ecx
movb %al, -0x39(%rbp)
jb 0x10e679
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %ecx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpl 0xb4(%rdx), %ecx
movb %al, -0x3a(%rbp)
jne 0x10e673
movq -0x20(%rbp), %rax
movl 0xa4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xa4(%rcx), %eax
seta %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10e69b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x117dc0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10e69b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)