LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
callq 0x12aba
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x12cda
movl %ebp, %ecx
movq 0x20(%r14), %rdx
shlq $0x4, %rcx
cmpl $0x3, 0x8(%rdx,%rcx)
jne 0x9362c
leaq 0x2e3e8(%rip), %rcx     # 0xc1a12
jmp 0x93662
leaq 0x2e3d5(%rip), %rcx     # 0xc1a08
testq %rax, %rax
je 0x93662
cmpb $0x1, 0x5b(%rax)
jne 0x93662
cmpb $0x1, 0x39(%rax)
jne 0x93662
movl 0x3c(%rax), %eax
shlq $0x4, %rax
cmpl $0x3, 0x8(%rdx,%rax)
leaq 0x2e3bb(%rip), %rax     # 0xc1a12
leaq 0x2e3aa(%rip), %rcx     # 0xc1a08
cmoveq %rax, %rcx
leaq 0x30(%rsp), %r12
movq %rcx, (%r12)
movq 0x28(%r15), %rax
subq 0x20(%r15), %rax
sarq $0x2, %rax
leaq 0x28(%rsp), %r15
movq %rax, (%r15)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x345e6
subq $0x8, %rsp
leaq 0x2c44c(%rip), %rax     # 0xbfae8
leaq 0x27a18(%rip), %r10     # 0xbb0bb
leaq 0x2e3a3(%rip), %rsi     # 0xc1a4d
leaq 0x305f0(%rip), %r8      # 0xc3ca1
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r9
pushq %rax
pushq %r13
pushq %r10
callq 0xa69e6
addq $0x20, %rsp
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x936e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93713
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x345ae
movq %r14, %rdi
movl %ebp, %esi
callq 0x12aba
cmpl $0xe, 0xc(%rax)
jne 0x9b2c0
cmpl $0x5, 0x84(%rax)
je 0x9b2c0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x89ff8
leaq 0x1fe99(%rip), %rcx     # 0xbb0bb
leaq 0x28(%rsp), %rdi
movl $0x2, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x62c0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9b25d
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x9b264
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9b2a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b2c0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9b2ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x9b2ed
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b30f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x9b30f
jmp 0x9b30c
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x9b326
movq (%rbx), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
cmpb $0x0, 0x628(%rdi)
jne 0x9b35d
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
movq 0x38(%rdi), %rcx
imulq $0x148, %rax, %rax      # imm = 0x148
testb $0x10, 0x60(%rcx,%rax)
jne 0x9b36f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movl $0xa, %edx
callq 0x1299a
movb $0x1, %bl
testb %al, %al
jne 0x9b35f
movq %r14, %rdi
movl %ebp, %esi
callq 0x12aba
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f216
movl 0x14(%r15), %edx
movl 0x18(%r15), %esi
movq %r14, %rdi
callq 0x9b448
leaq 0x61ffd(%rip), %rax     # 0xfd3b0
addq $0x10, %rax
leaq 0xa0(%rsp), %r14
movq %rax, -0xa0(%r14)
movq %r14, %rdi
callq 0xdeb6
movq -0x38(%r14), %rdi
testq %rdi, %rdi
je 0x9b3e4
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x9b414
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movl %eax, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x9b35f
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
jmp 0x9b35f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1c438
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::add_convert_row_major_matrix_function(unsigned int, unsigned int)
void CompilerMSL::add_convert_row_major_matrix_function(uint32_t cols, uint32_t rows)
{
	SPVFuncImpl spv_func;
	if (cols == rows) // Square matrix...just use transpose() function
		return;
	else if (cols == 2 && rows == 3)
		spv_func = SPVFuncImplRowMajor2x3;
	else if (cols == 2 && rows == 4)
		spv_func = SPVFuncImplRowMajor2x4;
	else if (cols == 3 && rows == 2)
		spv_func = SPVFuncImplRowMajor3x2;
	else if (cols == 3 && rows == 4)
		spv_func = SPVFuncImplRowMajor3x4;
	else if (cols == 4 && rows == 2)
		spv_func = SPVFuncImplRowMajor4x2;
	else if (cols == 4 && rows == 3)
		spv_func = SPVFuncImplRowMajor4x3;
	else
		SPIRV_CROSS_THROW("Could not convert row-major matrix.");

	auto rslt = spv_function_implementations.insert(spv_func);
	if (rslt.second)
	{
		add_pragma_line("#pragma clang diagnostic ignored \"-Wmissing-prototypes\"");
		force_recompile = true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl %edx, %esi
je 0x9b551
movq %rdi, %rbx
movl %esi, %ecx
xorl $0x2, %ecx
movl %edx, %eax
xorl $0x3, %eax
orl %ecx, %eax
jne 0x9b475
movl $0x12, 0x4(%rsp)
jmp 0x9b4df
movl %edx, %eax
xorl $0x4, %eax
orl %eax, %ecx
jne 0x9b488
movl $0x13, 0x4(%rsp)
jmp 0x9b4df
movl %esi, %edi
xorl $0x3, %edi
movl %edx, %ecx
xorl $0x2, %ecx
movl %edi, %r8d
orl %ecx, %r8d
jne 0x9b4a4
movl $0x14, 0x4(%rsp)
jmp 0x9b4df
orl %eax, %edi
jne 0x9b4b2
movl $0x15, 0x4(%rsp)
jmp 0x9b4df
movl %esi, %eax
xorl $0x4, %eax
orl %ecx, %eax
jne 0x9b4c5
movl $0x16, 0x4(%rsp)
jmp 0x9b4df
cmpl $0x4, %esi
jne 0x9b55c
cmpl $0x3, %edx
jne 0x9b55c
movl $0x17, 0x4(%rsp)
leaq 0x7e0(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0xad3ce
testb $0x1, %dl
je 0x9b551
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x25e8e(%rip), %rsi     # 0xc1393
leaq 0x25ebe(%rip), %rdx     # 0xc13ca
leaq 0x8(%rsp), %rdi
callq 0x7c64
leaq 0x880(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xaa960
testb $0x1, %dl
je 0x9b533
movb $0x1, 0x1d0(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9b54a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movb $0x1, 0x1d0(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x286e8(%rip), %rsi     # 0xc3c61
leaq 0x28704(%rip), %rdx     # 0xc3c84
leaq 0x8(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0x617f7(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x617cf(%rip), %rsi     # 0xfcd80
movq 0x62a20(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9b5e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x9b5e2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9b610
movq %rbx, %rdi
callq 0x6200
jmp 0x9b610
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9b610
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x9b610
movq %rax, %r14
movq %r14, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
cmpb $0x0, 0x628(%rdi)
jne 0x9b65a
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x1b67c
movb (%rbx), %bl
leaq 0x8(%rsp), %rdi
callq 0xd5b0
testb $0x10, %bl
jne 0x9b66c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%r15), %esi
movq %r14, %rdi
movl %ebp, %edx
movl $0xa, %ecx
callq 0x14222
movb $0x1, %bl
testb %al, %al
jne 0x9b65c
movl %ebp, %eax
movq 0x68(%r15), %rcx
movl (%rcx,%rax,4), %esi
movq %r14, %rdi
callq 0xa426
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f216
movl 0x14(%r15), %edx
movl 0x18(%r15), %esi
movq %r14, %rdi
callq 0x9b448
leaq 0x61cf5(%rip), %rax     # 0xfd3b0
addq $0x10, %rax
leaq 0xa0(%rsp), %r14
movq %rax, -0xa0(%r14)
movq %r14, %rdi
callq 0xdeb6
movq -0x38(%r14), %rdi
testq %rdi, %rdi
je 0x9b6ec
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x9b71c
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movl %eax, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x9b65c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
jmp 0x9b65c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1c438
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x16254
cmpl $0x0, 0xb8(%rax)
jne 0x9bd27
cmpl $0x0, 0x930(%rbx)
je 0x9bd27
cmpq $0x0, 0x948(%rbx)
je 0x9bd27
leaq 0x940(%rbx), %r14
cmpb $0x1, 0x442(%rbx)
jne 0x9bcf4
leaq 0x27fd8(%rip), %rax     # 0xc3ca9
movq %rax, (%rsp)
leaq 0x27fc0(%rip), %rdx     # 0xc3c9c
leaq 0x27fc0(%rip), %r8      # 0xc3ca3
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rcx
movq %r14, %r9
callq 0xa6f28
cmpb $0x1, 0x443(%rbx)
jne 0x9bd27
leaq 0x27fd5(%rip), %rdx     # 0xc3cd9
leaq 0x210a0(%rip), %r8      # 0xbcdab
leaq 0x27fcf(%rip), %r9      # 0xc3ce1
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa7100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %esi, %esi
movq 0x38(%rdi), %r8
movq 0x40(%rdi), %rdi
subq %r8, %rdi
sarq $0x3, %rdi
movabsq $-0x7063e7063e7063e7, %rax # imm = 0x8F9C18F9C18F9C19
imulq %rdi, %rax
cmpq %rsi, %rax
jbe 0x9ef5a
movl %edx, %edi
imulq $0x148, %rsi, %rsi      # imm = 0x148
movq 0xd0(%r8,%rsi), %rax
movq 0xd8(%r8,%rsi), %rsi
subq %rax, %rsi
sarq $0x4, %rsi
movabsq $0x4ec4ec4ec4ec4ec5, %r8 # imm = 0x4EC4EC4EC4EC4EC5
imulq %rsi, %r8
cmpq %rdi, %r8
jbe 0x9ef57
imulq $0xd0, %rdi, %rsi
addq %rsi, %rax
testq %rcx, %rcx
je 0x9ef4b
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testb $-0x80, 0x63(%rax)
je 0x9ef49
movl 0xa8(%rax), %esi
movl %esi, (%rcx)
testb $0x40, 0x63(%rax)
je 0x9ef57
movl 0xa4(%rax), %edx
movl %edx, %eax
retq
pushq %rax
leaq 0x161b7(%rip), %rdi     # 0xb5119
movq %rax, %rdx
xorl %eax, %eax
callq 0x63d0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x148(%rsi), %rax
testq %rax, %rax
je 0x9f7cb
movl 0x8(%rax), %eax
cmpl 0x108(%r14), %eax
jne 0x9f7cb
movl %ebp, %esi
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x7063e7063e7063e7, %rdx # imm = 0x8F9C18F9C18F9C19
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x9f7ee
imulq $0x148, %rsi, %rcx      # imm = 0x148
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq 0x20(%rax,%rcx), %rsi
movq 0x28(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe480
movq 0x8(%rbx), %r13
testq %r13, %r13
jne 0x9f7dc
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x9f7c6
movq (%r12), %rsi
incq %rsi
callq 0x6260
testq %r13, %r13
jne 0x9f7dc
movzbl %r15b, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x12ace
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15924(%rip), %rdi     # 0xb5119
xorl %eax, %eax
callq 0x63d0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x9fd26
movl 0x10(%rdx), %eax
cmpl $0xc, %eax
je 0x9fcea
cmpl $0x2, %eax
jne 0x9fd26
movl 0xc(%rdx), %esi
movq %r15, %rdi
callq 0xa426
movq 0x20(%rax), %rcx
cmpq 0x28(%rax), %rcx
je 0x9fd26
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2c69c
leaq 0x154e2(%rip), %rsi     # 0xb51fb
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa77d1
jmp 0x9fd4b
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2c69c
leaq 0x1bb19(%rip), %rsi     # 0xbb859
movq %rbx, %rdi
movq %r12, %rdx
callq 0x585b8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fd66
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9fd78
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fd96
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movl %edx, %esi
callq 0x12aba
cmpl $0x4, 0x64(%rax)
jne 0x9fdd8
leaq 0x24151(%rip), %rsi     # 0xc3f21
movq %rbx, %rdi
callq 0x64e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9fdf7
movq (%r15), %rsi
incq %rsi
callq 0x6260
movq %r14, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
leal -0x57(%rsi), %eax
cmpl $0xb, %eax
jae 0xa11e6
movq 0x8(%r14), %r12
movb $0x1, %bl
cmpb $0x0, 0x934(%r12)
movb $0x1, %al
jne 0xa11ce
movl 0x8(%r15), %esi
movq %r12, %rdi
callq 0x12aba
movq %r12, %rdi
movq %rax, %rsi
callq 0x14caa
movq 0x8(%r14), %rcx
movb %al, 0x934(%rcx)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %bl
addl $-0x3d, %esi
cmpl $0x27, %esi
ja 0xa11d8
movabsq $0x8002000001, %rax     # imm = 0x8002000001
btq %rsi, %rax
jae 0xa11d8
cmpl $0x3, %ecx
jae 0xa1209
xorl %ebx, %ebx
jmp 0xa11d8
movl (%r15), %esi
movl %esi, 0x4(%rsp)
movq 0x8(%r14), %rdi
callq 0xa426
movl 0xc(%rax), %ecx
addl $-0xd, %ecx
cmpl $0x1, %ecx
ja 0xa11d8
cmpl $0x1, 0x8c(%rax)
jne 0xa11d8
movl 0x4(%r15), %esi
movq 0x8(%r14), %rdi
leaq 0x3(%rsp), %r8
movb $0x1, (%r8)
leaq 0x1466a(%rip), %rdx     # 0xb58af
leaq 0x4(%rsp), %rcx
callq 0x1c27a
jmp 0xa11d8
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::OpCodePreprocessor::handle(spv::Op, unsigned int const*, unsigned int)
bool CompilerMSL::OpCodePreprocessor::handle(Op opcode, const uint32_t *args, uint32_t length)
{
	// Since MSL exists in a single execution scope, function prototype declarations are not
	// needed, and clutter the output. If secondary functions are output (either as a SPIR-V
	// function implementation or as indicated by the presence of OpFunctionCall), then set
	// suppress_missing_prototypes to suppress compiler warnings of missing function prototypes.

	// Mark if the input requires the implementation of an SPIR-V function that does not exist in Metal.
	SPVFuncImpl spv_func = get_spv_func_impl(opcode, args);
	if (spv_func != SPVFuncImplNone)
	{
		compiler.spv_function_implementations.insert(spv_func);
		suppress_missing_prototypes = true;
	}

	switch (opcode)
	{

	case OpFunctionCall:
		suppress_missing_prototypes = true;
		break;

	case OpImageWrite:
		uses_resource_write = true;
		break;

	case OpStore:
		check_resource_write(args[0]);
		break;

	case OpAtomicExchange:
	case OpAtomicCompareExchange:
	case OpAtomicCompareExchangeWeak:
	case OpAtomicIIncrement:
	case OpAtomicIDecrement:
	case OpAtomicIAdd:
	case OpAtomicISub:
	case OpAtomicSMin:
	case OpAtomicUMin:
	case OpAtomicSMax:
	case OpAtomicUMax:
	case OpAtomicAnd:
	case OpAtomicOr:
	case OpAtomicXor:
		uses_atomics = true;
		check_resource_write(args[2]);
		break;

	case OpAtomicLoad:
		uses_atomics = true;
		break;

	default:
		break;
	}

	// If it has one, keep track of the instruction's result type, mapped by ID
	uint32_t result_type, result_id;
	if (compiler.instruction_to_result_type(result_type, result_id, opcode, args, length))
		result_types[result_id] = result_type;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0xa1324
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0xa128b
movl $0x7e0, %edi            # imm = 0x7E0
addq 0x8(%rbx), %rdi
leaq 0x14(%rsp), %rsi
callq 0xad3ce
movb $0x1, 0x48(%rbx)
leal -0xe5(%r15), %eax
cmpl $0xe, %eax
jae 0xa12eb
movb $0x1, 0x49(%rbx)
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0xa1736
movq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movl %r15d, %ecx
movq %r14, %r8
movl %ebp, %r9d
callq 0x193bc
testb %al, %al
je 0xa12de
movl 0x10(%rsp), %ebp
addq $0x10, %rbx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x22474
movl %ebp, (%rax)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x62, %r15d
jg 0xa1302
cmpl $0x39, %r15d
je 0xa1317
cmpl $0x3e, %r15d
jne 0xa12a7
movl (%r14), %esi
jmp 0xa129f
cmpl $0x63, %r15d
je 0xa131d
cmpl $0xe3, %r15d
jne 0xa12a7
movb $0x1, 0x49(%rbx)
jmp 0xa12a7
movb $0x1, 0x48(%rbx)
jmp 0xa12a7
movb $0x1, 0x4a(%rbx)
jmp 0xa12a7
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x12cda
testq %rax, %rax
je 0xa174d
movl 0x10(%rax), %eax
jmp 0xa1752
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0xc, %eax
je 0xa175c
cmpl $0x2, %eax
jne 0xa1760
movb $0x1, 0x4a(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rcx
movq 0x8(%rdi), %rax
movl %esi, %esi
movq 0xd0(%rax), %r8
imulq $0xd0, %rsi, %rdi
movl %edx, %eax
imulq $0xd0, %rax, %rsi
movb 0xcc(%r8,%rsi), %al
cmpb %al, 0xcc(%r8,%rdi)
jne 0xa17ce
movl 0x10(%rcx), %eax
cmpq $0x4, %rax
ja 0xa1803
addq %r8, %rdi
addq %r8, %rsi
leaq 0x1f73a(%rip), %rcx     # 0xc0ee4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xa4(%rdi), %eax
cmpl 0xa4(%rsi), %eax
jmp 0xa17db
pushq %rax
callq 0x6030
shrl $0x1f, %eax
addq $0x8, %rsp
retq
movl 0xb4(%rdi), %eax
cmpl 0xb4(%rsi), %eax
setb %al
retq
movl 0xb4(%rdi), %ecx
movl 0xb4(%rsi), %edx
movb $0x1, %al
cmpl %edx, %ecx
jb 0xa17ce
jne 0xa1803
movl 0xa4(%rdi), %eax
cmpl 0xa4(%rsi), %eax
seta %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::remap_constexpr_sampler(unsigned int, spirv_cross::MSLConstexprSampler const&)
void CompilerMSL::remap_constexpr_sampler(uint32_t id, const MSLConstexprSampler &sampler)
{
	auto &type = get<SPIRType>(get<SPIRVariable>(id).basetype);
	if (type.basetype != SPIRType::SampledImage && type.basetype != SPIRType::Sampler)
		SPIRV_CROSS_THROW("Can only remap SampledImage and Sampler type.");
	if (!type.array.empty())
		SPIRV_CROSS_THROW("Can not remap array of samplers.");
	constexpr_samplers[id] = sampler;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, 0x4(%rsp)
callq 0xb40a
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0xa426
movl 0xc(%rax), %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
jne 0xa18c8
movq 0x20(%rax), %rcx
cmpq 0x28(%rax), %rcx
jne 0xa192e
addq $0x9c8, %r14            # imm = 0x9C8
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xae660
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movl 0x2f(%rbx), %ecx
movl %ecx, 0x2f(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x22bd1(%rip), %rsi     # 0xc44b6
leaq 0x22bf7(%rip), %rdx     # 0xc44e3
leaq 0x8(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0x5b48b(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x5b463(%rip), %rsi     # 0xfcd80
movq 0x5c6b4(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0xa1992
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x22b99(%rip), %rsi     # 0xc44e4
leaq 0x22bb2(%rip), %rdx     # 0xc4504
leaq 0x8(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0x5b425(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x5b3fd(%rip), %rsi     # 0xfcd80
movq 0x5c64e(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
jmp 0xa1996
jmp 0xa19b2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa19b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0xa19b8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa19c5
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::bitcast_from_builtin_load(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, spirv_cross::SPIRType const&)
void CompilerMSL::bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type)
{
	auto *var = maybe_get_backing_variable(source_id);
	if (var)
		source_id = var->self;

	// Only interested in standalone builtin variables.
	if (!has_decoration(source_id, DecorationBuiltIn))
		return;

	auto builtin = static_cast<BuiltIn>(get_decoration(source_id, DecorationBuiltIn));
	auto expected_type = expr_type.basetype;
	switch (builtin)
	{
	case BuiltInGlobalInvocationId:
	case BuiltInLocalInvocationId:
	case BuiltInWorkgroupId:
	case BuiltInLocalInvocationIndex:
	case BuiltInWorkgroupSize:
	case BuiltInNumWorkgroups:
	case BuiltInLayer:
	case BuiltInViewportIndex:
		expected_type = SPIRType::UInt;
		break;

	default:
		break;
	}

	if (expected_type != expr_type.basetype)
		expr = bitcast_expression(expr_type, expected_type, expr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x12cda
testq %rax, %rax
je 0xa19f2
movl 0x8(%rax), %ebp
movq %r15, %rdi
movl %ebp, %esi
movl $0xb, %edx
callq 0x1299a
testb %al, %al
je 0xa1a6d
movq %r15, %rdi
movl %ebp, %esi
movl $0xb, %edx
callq 0x14ff6
movl 0xc(%r14), %edx
leal -0x18(%rax), %ecx
cmpl $0x6, %ecx
jb 0xa1a2a
addl $-0x9, %eax
movl %edx, %ecx
cmpl $0x1, %eax
ja 0xa1a2f
movl $0x5, %ecx
cmpl %edx, %ecx
je 0xa1a6d
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x3e3d8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6310
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xa1a6d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::bitcast_to_builtin_store(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, spirv_cross::SPIRType const&)
void CompilerMSL::bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type)
{
	// Only interested in standalone builtin variables.
	if (!has_decoration(target_id, DecorationBuiltIn))
		return;

	auto builtin = static_cast<BuiltIn>(get_decoration(target_id, DecorationBuiltIn));
	auto expected_type = expr_type.basetype;
	switch (builtin)
	{
	case BuiltInLayer:
	case BuiltInViewportIndex:
		expected_type = SPIRType::UInt;
		break;

	default:
		break;
	}

	if (expected_type != expr_type.basetype)
	{
		auto type = expr_type;
		type.basetype = expected_type;
		expr = bitcast_expression(type, expr_type.basetype, expr);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0xb, %edx
callq 0x1299a
testb %al, %al
je 0xa1bae
movq %r14, %rdi
movl %ebp, %esi
movl $0xb, %edx
callq 0x14ff6
addl $-0xb, %eax
cmpl $-0x2, %eax
jb 0xa1bae
cmpl $0x5, 0xc(%r15)
je 0xa1bae
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f216
movl $0x5, 0xc(%r12)
movl 0xc(%r15), %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x3e3d8
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa1b26
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
leaq 0x5b883(%rip), %rax     # 0xfd3b0
addq $0x10, %rax
leaq 0xc8(%rsp), %rbx
movq %rax, -0xa0(%rbx)
movq %rbx, %rdi
callq 0xdeb6
movq -0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xa1b61
movq 0xa0(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xa1b97
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
xorl %eax, %eax
movq %rax, 0x60(%rsp)
movl %eax, 0x68(%rsp)
movq %rax, 0x70(%rsp)
movl %eax, 0x78(%rsp)
movq %rax, 0x80(%rsp)
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xa1bae
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x6260
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1c438
movq %rbx, %rdi
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::to_initializer_expression[abi:cxx11](spirv_cross::SPIRVariable const&)
std::string CompilerMSL::to_initializer_expression(const SPIRVariable &var)
{
	// We risk getting an array initializer here with MSL. If we have an array.
	// FIXME: We cannot handle non-constant arrays being initialized.
	// We will need to inject spvArrayCopy here somehow ...
	auto &type = get<SPIRType>(var.basetype);
	if (ir.ids[var.initializer].get_type() == TypeConstant &&
	    (!type.array.empty() || type.basetype == SPIRType::Struct))
		return constant_expression(get<SPIRConstant>(var.initializer));
	else
		return CompilerGLSL::to_initializer_expression(var);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdx), %esi
movq %r14, %rdi
callq 0xa426
movl 0x18(%r15), %esi
movq 0x20(%r14), %rcx
movq %rsi, %rdx
shlq $0x4, %rdx
cmpl $0x3, 0x8(%rcx,%rdx)
jne 0xa1c13
movq 0x20(%rax), %rcx
cmpq 0x28(%rax), %rcx
jne 0xa1c23
cmpl $0xc, 0xc(%rax)
je 0xa1c23
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4c854
jmp 0xa1c39
movq %r14, %rdi
callq 0x1c66e
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2e53a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_parser.cpp
// Function: spirv_cross::Parser::stream(spirv_cross::Instruction const&) const
const uint32_t *Parser::stream(const Instruction &instr) const
{
	// If we're not going to use any arguments, just return nullptr.
	// We want to avoid case where we return an out of range pointer
	// that trips debug assertions on some platforms.
	if (!instr.length)
		return nullptr;

	if (instr.offset + instr.length > ir.spirv.size())
		SPIRV_CROSS_THROW("Compiler::stream() out of range.");
	return &ir.spirv[instr.offset];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x8(%rsi), %ecx
testl %ecx, %ecx
je 0xb1065
movl 0x4(%rsi), %eax
addl %eax, %ecx
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rcx, %rsi
jb 0xb1072
leaq (%rdx,%rax,4), %rax
jmp 0xb1067
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5199(%rip), %rsi      # 0xb6228
leaq 0x51b2(%rip), %rdx      # 0xb6248
leaq 0x8(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6320
leaq 0x4bce1(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x4bcb9(%rip), %rsi     # 0xfcd80
movq 0x4cf0a(%rip), %rdx     # 0xfdfd8
movq %rbx, %rdi
callq 0x6470
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xb10f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0xb10f8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xb1105
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_parser.cpp
// Function: spirv_cross::extract_string[abi:cxx11](std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int)
static string extract_string(const vector<uint32_t> &spirv, uint32_t offset)
{
	string ret;
	for (uint32_t i = offset; i < spirv.size(); i++)
	{
		uint32_t w = spirv[i];

		for (uint32_t j = 0; j < 4; j++, w >>= 8)
		{
			char c = w & 0xff;
			if (c == '\0')
				return ret;
			ret += c;
		}
	}

	SPIRV_CROSS_THROW("String was not terminated before EOF");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl %edx, %ecx
movq (%rsi), %rax
movq %rsi, 0x10(%rsp)
movq 0x8(%rsi), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rcx, %rdx
seta %dl
jbe 0xb11c2
xorl %ebp, %ebp
movb %dl, 0x7(%rsp)
movl (%rax,%rcx,4), %r12d
xorl %r15d, %r15d
xorl %r13d, %r13d
testb %r12b, %r12b
je 0xb1179
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x6230
jmp 0xb117c
movb $0x1, %bpl
testb %r12b, %r12b
je 0xb1199
shrl $0x8, %r12d
cmpl $0x3, %r13d
leal 0x1(%r13), %eax
setae %r15b
movl %eax, %r13d
cmpl $0x4, %eax
jne 0xb1166
testb $0x1, %r15b
je 0xb11c6
incl %r14d
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq %r14, %rcx
cmpq %r14, %rdx
seta %dl
ja 0xb1158
jmp 0xb11ca
xorl %ebp, %ebp
jmp 0xb11ca
movb 0x7(%rsp), %dl
testb $0x1, %dl
je 0xb1201
testb $0x1, %bpl
jne 0xb11ef
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0xb11ef
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6140
movq %rax, %r14
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x139f4(%rip), %rsi     # 0xc4c13
leaq 0x13a11(%rip), %rdx     # 0xc4c37
leaq 0x18(%rsp), %rdi
callq 0x7c64
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x6320
leaq 0x4bb51(%rip), %rax     # 0xfcd98
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x4bb29(%rip), %rsi     # 0xfcd80
movq 0x4cd7a(%rip), %rdx     # 0xfdfd8
movq %r14, %rdi
callq 0x6470
movq %rax, %r15
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xb1288
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0xb1288
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0xb129a
movq %r14, %rdi
callq 0x6200
jmp 0xb129a
movq %rax, %r15
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0xb12b4
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6260
movq %r15, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_parser.cpp
// Function: spirv_cross::Parser::variable_storage_is_aliased(spirv_cross::SPIRVariable const&) const
bool Parser::variable_storage_is_aliased(const SPIRVariable &v) const
{
	auto &type = get<SPIRType>(v.basetype);
	bool ssbo = v.storage == StorageClassStorageBuffer ||
	            ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
	bool image = type.basetype == SPIRType::Image;
	bool counter = type.basetype == SPIRType::AtomicCounter;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rsi), %esi
callq 0xb1f4a
movb $0x1, %bpl
cmpl $0xc, 0x10(%r14)
je 0xb178d
movl 0x8(%rax), %ecx
movq 0x30(%rbx), %rdx
imulq $0x148, %rcx, %rcx      # imm = 0x148
movb 0x60(%rdx,%rcx), %bpl
andb $0x8, %bpl
shrb $0x3, %bpl
movl 0xc(%rax), %r12d
testb %bpl, %bpl
je 0xb17bc
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x24ca0
movl (%r15), %ebx
shrl $0x13, %ebx
andl $0x1, %ebx
leaq 0x8(%rsp), %rdi
callq 0xd5b0
jmp 0xb17cf
movl 0x8(%r14), %esi
movq %rbx, %rdi
movl $0x13, %edx
callq 0x24fbc
movl %eax, %ebx
cmpl $0x8, %r12d
sete %al
cmpl $0xd, %r12d
sete %cl
movl %ebx, %edx
xorb $0x1, %dl
orb %al, %cl
movzbl %cl, %eax
movzbl %dl, %ecx
testb %bl, %bl
cmovnel %ecx, %eax
testb %bpl, %bpl
cmovnel %ecx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::Bitset::set(unsigned int)
inline void set(uint32_t bit)
	{
		if (bit < 64)
			lower |= 1ull << bit;
		else
			higher.insert(bit);
	}

// Assembly:
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
cmpl $0x3f, %esi
ja 0xb1a5a
movl $0x1, %eax
movl %esi, %ecx
shlq %cl, %rax
orq %rax, (%rdi)
jmp 0xb1a70
addq $0x8, %rdi
leaq 0x10(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0xc(%rsp), %rsi
callq 0x1fc02
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/crossc-glsl.cc
// Function: crossc_glsl_create
crossc_compiler *crossc_glsl_create(const uint32_t *words, size_t word_count)
{
	crossc_compiler *comp = new crossc_compiler;
	try {
		comp->c = std::make_unique<spirv_cross::CompilerGLSL>(words, word_count);
	} catch (const std::exception &e) {
		comp->error = std::string { e.what() };
	}
	return comp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x48, %edi
callq 0x6250
movq %rax, %rbx
xorl %eax, %eax
movq %rax, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movl $0x788, %edi            # imm = 0x788
callq 0x6250
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa353a
movq (%rbx), %rdi
movq %r12, (%rbx)
testq %rdi, %rdi
je 0xb452d
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
movl $0x788, %esi            # imm = 0x788
movq %r12, %rdi
callq 0x6260
jmp 0xb4557
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xb45c0
movq %r14, %rdi
callq 0x6110
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x6100
movq %rbx, %rdi
addq $0x28, %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x6310
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb45ae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
callq 0x6440
jmp 0xb452d
movq %rax, %r14
callq 0x6440
movq %r14, %rdi
callq 0x64a0
movq %rax, %rdi
callq 0xd589
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/crossc-hlsl.cc
// Function: crossc_hlsl_create
crossc_compiler *crossc_hlsl_create(const uint32_t *words, size_t word_count)
{
	crossc_compiler *comp = new crossc_compiler;
	try {
		comp->c = std::make_unique<spirv_cross::CompilerHLSL>(words, word_count);
	} catch (const std::exception &e) {
		comp->error = std::string { e.what() };
	}
	return comp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r12
movl $0x48, %edi
callq 0x6250
movq %rax, %rbx
xorl %eax, %eax
movq %rax, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movl $0x7e8, %edi            # imm = 0x7E8
callq 0x6250
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xa353a
leaq 0x490e1(%rip), %rax     # 0xfd730
addq $0x10, %rax
movq %rax, (%r14)
movl $0x1e, 0x788(%r14)
xorl %eax, %eax
movw %ax, 0x78c(%r14)
movq %rax, 0x7a0(%r14)
movw %ax, 0x7a8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x7d0(%r14)
movq %rax, 0x7e0(%r14)
movq %rax, 0x790(%r14)
movq %rax, 0x795(%r14)
movups %xmm0, 0x7b0(%r14)
movups %xmm0, 0x7bc(%r14)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0xb46bb
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r15
movl $0x7e8, %esi            # imm = 0x7E8
movq %r14, %rdi
callq 0x6260
jmp 0xb46e5
movq %rdx, %r12
movq %rax, %r15
cmpl $0x1, %r12d
jne 0xb474e
movq %r15, %rdi
callq 0x6110
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x6100
movq %rbx, %rdi
addq $0x28, %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x6310
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb473c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
callq 0x6440
jmp 0xb46bb
movq %rax, %r15
callq 0x6440
movq %r15, %rdi
callq 0x64a0
movq %rax, %rdi
callq 0xd589
// File: /workspace/github_cpp_makefile_star2_O1/rossy[P]crossc/crossc.cc
// Function: crossc_compile
const char *crossc_compile(crossc_compiler *comp)
{
	if (!comp->c)
		return nullptr;
	try {
		comp->output = comp->c->compile();
		return comp->output.c_str();
	} catch (const std::exception &e) {
		comp->error = std::string { e.what() };
		return nullptr;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xb4840
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb47dd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
movq (%rbx), %rax
jmp 0xb4842
movq %rax, %r14
cmpl $0x1, %edx
jne 0xb4852
movq %r14, %rdi
callq 0x6110
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x6100
addq $0x28, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb483b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6260
callq 0x6440
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
callq 0x6440
movq %r14, %rdi
callq 0x64a0
movq %rax, %rdi
callq 0xd589
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::default_parser<int>::operator()(char const*) const
maybe<V> operator()(const char* text) const {
        if (!text) return nothing;
        V v;
        std::istringstream stream(text);
        if (!(stream >> v)) return nothing;
        if (!stream.eof()) stream >> std::ws;
        return stream.eof()? maybe<V>(v): nothing;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3ef5
movq %rdx, %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rdx, %rdi
callq 0x20a0
leaq (%rax,%r14), %rdx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x3c82
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0x2240
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3e8a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x20f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3ed1
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x50(%rsp,%rax)
jne 0x3ec1
leaq 0x30(%rsp), %rdi
callq 0x2140
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x50(%rsp,%rax)
jne 0x3f08
xorl %eax, %eax
movb %al, (%rbx)
movq 0x70ec(%rip), %rsi      # 0xafc8
leaq 0x30(%rsp), %rdi
callq 0x21e0
leaq 0xa8(%rsp), %rdi
callq 0x2060
jmp 0x3ef8
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, (%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rbx)
movb $0x1, %al
jmp 0x3ed3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3f58
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x3f58
movq %rax, %rbx
jmp 0x3f58
movq %rax, %rbx
movq 0x7087(%rip), %rsi      # 0xafc8
leaq 0x30(%rsp), %rdi
callq 0x21e0
leaq 0xa8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280