LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xe0, %rsp
cmpb $0x0, 0x628(%rdi)
jne 0x7a653
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x16ba6
movb (%r12), %bpl
leaq 0x10(%rsp), %rdi
callq 0xb51c
testb $0x10, %bpl
jne 0x7a667
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%r14), %esi
pushq $0xa
popq %rcx
movq %rbx, %rdi
movl %r15d, %edx
callq 0x117ba
movb $0x1, %bpl
testb %al, %al
jne 0x7a655
movl %r15d, %eax
movq 0x68(%r14), %rcx
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x90a4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1a29c
movl 0x14(%r14), %edx
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x7a4a4
leaq 0x8(%rsp), %rdi
callq 0x17a3e
jmp 0x7a655
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17a3e
movq %rbx, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::convert_row_major_matrix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spirv_cross::SPIRType const&, bool)
string CompilerMSL::convert_row_major_matrix(string exp_str, const SPIRType &exp_type, bool is_packed)
{
	strip_enclosed_expression(exp_str);

	string func_name;

	// Square and packed matrices can just use transpose
	if (exp_type.columns == exp_type.vecsize || is_packed)
		func_name = "transpose";
	else
		func_name = string("spvConvertFromRowMajor") + to_string(exp_type.columns) + "x" + to_string(exp_type.vecsize);

	return join(func_name, "(", exp_str, ")");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
xorb $0x1, %bpl
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2be62
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x18(%r15), %eax
cmpl 0x14(%r15), %eax
setne %al
testb %bpl, %al
jne 0x7a733
leaq 0x17ff2(%rip), %rsi     # 0x92716
leaq 0x8(%rsp), %rdi
callq 0x64e0
jmp 0x7a807
leaq 0x234d3(%rip), %rsi     # 0x9dc0d
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6100
movl 0x18(%r15), %esi
leaq 0x48(%rsp), %rdi
callq 0x1c182
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1743e
leaq 0x1a5e8(%rip), %rdx     # 0x94d5d
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xab3f
movl 0x14(%r15), %esi
leaq 0x28(%rsp), %rdi
callq 0x1c182
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1743e
leaq 0x8(%rsp), %rdi
leaq 0xc8(%rsp), %r15
movq %r15, %rsi
callq 0x6320
movq %r15, %rdi
callq 0x6548
leaq 0x28(%rsp), %rdi
callq 0x6548
leaq 0xa8(%rsp), %rdi
callq 0x6548
leaq 0x88(%rsp), %rdi
callq 0x6548
leaq 0x48(%rsp), %rdi
callq 0x6548
leaq 0x68(%rsp), %rdi
callq 0x6548
leaq 0x2341b(%rip), %rdx     # 0x9dc29
leaq 0x1b1e0(%rip), %r8      # 0x959f5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x62e67
leaq 0x8(%rsp), %rdi
callq 0x6548
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6548
jmp 0x7a852
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x6548
jmp 0x7a864
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x6548
jmp 0x7a876
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6548
jmp 0x7a885
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6548
jmp 0x7a896
jmp 0x7a893
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12fa4
cmpl $0x0, 0xb8(%rax)
jne 0x7a941
cmpl $0x0, 0x930(%rbx)
je 0x7a941
cmpq $0x0, 0x948(%rbx)
je 0x7a941
leaq 0x940(%rbx), %r14
cmpb $0x1, 0x442(%rbx)
jne 0x7a90e
leaq 0x23346(%rip), %rax     # 0x9dc31
movq %rax, (%rsp)
leaq 0x2332e(%rip), %rdx     # 0x9dc24
leaq 0x2332e(%rip), %r8      # 0x9dc2b
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rcx
movq %r14, %r9
callq 0x81b1c
cmpb $0x1, 0x443(%rbx)
jne 0x7a941
leaq 0x23343(%rip), %rdx     # 0x9dc61
leaq 0x1c41e(%rip), %r8      # 0x96d43
leaq 0x2333d(%rip), %r9      # 0x9dc69
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x81c26
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebx
addq $0x38, %rdi
movl %esi, %esi
callq 0x1738e
movl %ebx, %esi
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rax
subq %rcx, %rax
movl $0xd0, %edi
cqto
idivq %rdi
cmpq %rsi, %rax
jbe 0x7be81
imulq $0xd0, %rsi, %rdx
leaq (%rcx,%rdx), %rax
movq 0x60(%rcx,%rdx), %rcx
testq %r14, %r14
je 0x7be75
testl %ecx, %ecx
js 0x7be6c
pushq $-0x1
popq %rdx
jmp 0x7be72
movl 0xa8(%rax), %edx
movl %edx, (%r14)
btl $0x1e, %ecx
jae 0x7be81
movl 0xa4(%rax), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %ebp
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
testl %ecx, %ecx
je 0x7c139
leaq 0x18f5a(%rip), %rsi     # 0x9508b
movq %rbx, %rdi
callq 0x64d0
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7bf9e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x64f0
movq %rsp, %rdi
callq 0x6548
movq (%r14), %rax
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
movl %ebp, %edx
callq *0xa0(%rax)
leaq 0x13710(%rip), %rsi     # 0x8f886
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x463dd
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x64f0
movq %rsp, %rdi
callq 0x6548
leaq 0x20(%rsp), %rdi
callq 0x6548
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7bb9c
leaq 0x21aec(%rip), %rsi     # 0x9dca2
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x463dd
leaq 0x21be9(%rip), %rdx     # 0x9ddb5
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xab3f
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x64f0
movq %rsp, %rdi
callq 0x6548
leaq 0x20(%rsp), %rdi
callq 0x6548
leaq 0x40(%rsp), %rdi
callq 0x6548
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x7c25c
movq %rax, %r14
movq %rsp, %rdi
callq 0x6548
jmp 0x7c21e
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x6548
jmp 0x7c22d
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x7c255
jmp 0x7c25c
movq %rax, %r14
movq %rsp, %rdi
callq 0x6548
jmp 0x7c246
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x7c255
jmp 0x7c25c
movq %rax, %r14
movq %rsp, %rdi
callq 0x6548
jmp 0x7c25f
movq %rax, %r14
movq %rbx, %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x148(%rsi), %rax
testq %rax, %rax
je 0x7c302
movl 0x8(%rax), %eax
cmpl 0x108(%r14), %eax
jne 0x7c302
leaq 0x38(%r14), %rdi
movl %ebp, %esi
callq 0x17518
leaq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x63c0
cmpq $0x0, 0x8(%rbx)
jne 0x7c313
movq %rbx, %rdi
callq 0x6548
movzbl %r15b, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x104c4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7c782
movl 0x10(%rdx), %eax
cmpl $0xc, %eax
je 0x7c746
cmpl $0x2, %eax
jne 0x7c782
movl 0xc(%rdx), %esi
movq %r15, %rdi
callq 0x90a4
movq 0x20(%rax), %rcx
cmpq 0x28(%rax), %rcx
je 0x7c782
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x25cca
leaq 0x12a5e(%rip), %rsi     # 0x8f1d3
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8210b
jmp 0x7c7a7
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x25cca
leaq 0x1908d(%rip), %rsi     # 0x95829
movq %rbx, %rdi
movq %r12, %rdx
callq 0x46531
movq %rsp, %rdi
callq 0x6548
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7c7c1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6548
movq %rbx, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movl %edx, %esi
callq 0x104b0
cmpl $0x4, 0x64(%rax)
jne 0x7c80a
leaq 0x216a7(%rip), %rsi     # 0x9dea9
movq %rbx, %rdi
callq 0x64d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6548
movq %r14, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x1, %bl
addl $-0x3d, %esi
cmpl $0x27, %esi
ja 0x7d5f8
movq %rdx, %r15
movq %rdi, %r14
movabsq $0x1ffc000000, %rax     # imm = 0x1FFC000000
btq %rsi, %rax
jae 0x7d606
movq 0x8(%r14), %r12
movb $0x1, %bl
cmpb $0x0, 0x934(%r12)
je 0x7d5d5
movb $0x1, %al
jmp 0x7d5f0
movl 0x8(%r15), %esi
movq %r12, %rdi
callq 0x104b0
movq %r12, %rdi
movq %rax, %rsi
callq 0x11ea2
movq 0x8(%r14), %r12
movb %al, 0x934(%r12)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movabsq $0x8002000001, %rax     # imm = 0x8002000001
btq %rsi, %rax
jae 0x7d5f8
cmpl $0x3, %ecx
jae 0x7d61f
xorl %ebx, %ebx
jmp 0x7d5f8
movl (%r15), %esi
movl %esi, 0x4(%rsp)
movq 0x8(%r14), %rdi
callq 0x90a4
movl 0xc(%rax), %ecx
addl $-0xd, %ecx
cmpl $0x1, %ecx
ja 0x7d5f8
cmpl $0x1, 0x8c(%rax)
jne 0x7d5f8
movl 0x4(%r15), %esi
movq 0x8(%r14), %rdi
leaq 0x3(%rsp), %r8
movb $0x1, (%r8)
leaq 0x1222c(%rip), %rdx     # 0x8f887
leaq 0x4(%rsp), %rcx
callq 0x17816
jmp 0x7d5f8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7d734
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x7d6a1
movl $0x7e0, %edi            # imm = 0x7E0
addq 0x8(%rbx), %rdi
leaq 0x14(%rsp), %rsi
callq 0x8815a
movb $0x1, 0x48(%rbx)
leal -0xe5(%r15), %eax
cmpl $0xe, %eax
jae 0x7d701
movb $0x1, 0x49(%rbx)
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x7da62
movq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movl %r15d, %ecx
movq %r14, %r8
movl %ebp, %r9d
callq 0x15226
testb %al, %al
je 0x7d6f4
movl 0x10(%rsp), %ebp
addq $0x10, %rbx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d40e
movl %ebp, (%rax)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0xe3, %r15d
je 0x7d722
cmpl $0x3e, %r15d
je 0x7d72e
cmpl $0x63, %r15d
je 0x7d728
cmpl $0x39, %r15d
jne 0x7d6bd
movb $0x1, 0x48(%rbx)
jmp 0x7d6bd
movb $0x1, 0x49(%rbx)
jmp 0x7d6bd
movb $0x1, 0x4a(%rbx)
jmp 0x7d6bd
movl (%r14), %esi
jmp 0x7d6b5
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1067e
testq %rax, %rax
je 0x7da85
movl 0x10(%rax), %eax
cmpl $0xc, %eax
je 0x7da81
cmpl $0x2, %eax
jne 0x7da85
movb $0x1, 0x4a(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7dafb
movl 0x10(%rcx), %eax
cmpq $0x4, %rax
ja 0x7db20
addq %r8, %rdi
addq %r8, %rsi
leaq 0x1d3b4(%rip), %rcx     # 0x9ae84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xa4(%rdi), %eax
cmpl 0xa4(%rsi), %eax
jmp 0x7daf8
jmp 0x82201
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 0x7dafb
jne 0x7db20
movl 0xa4(%rdi), %eax
cmpl 0xa4(%rsi), %eax
seta %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, 0xc(%rsp)
callq 0x9c0e
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0x90a4
movl 0xc(%rax), %ecx
andl $-0x2, %ecx
cmpl $0xe, %ecx
jne 0x7dbdc
movq 0x20(%rax), %rcx
cmpq 0x28(%rax), %rcx
jne 0x7dc27
addq $0x9c8, %r14            # imm = 0x9C8
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x8980a
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 $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x20850(%rip), %rsi     # 0x9e43e
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0x691aa(%rip), %rsi     # 0xe6dc0
movq 0x6a3c3(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x7dc70
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x20833(%rip), %rsi     # 0x9e46c
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0x6915f(%rip), %rsi     # 0xe6dc0
movq 0x6a378(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
jmp 0x7dc74
jmp 0x7dc88
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x7dc8b
jmp 0x7dc93
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1067e
testq %rax, %rax
je 0x7dcc0
movl 0x8(%rax), %ebp
pushq $0xb
popq %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x103d2
testb %al, %al
je 0x7dd1e
pushq $0xb
popq %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x12174
cmpl $0x1d, %eax
ja 0x7dd1e
movl $0x3f000600, %ecx       # imm = 0x3F000600
btl %eax, %ecx
jae 0x7dd1e
cmpl $0x5, 0xc(%r14)
je 0x7dd1e
movq %rsp, %r12
pushq $0x5
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x32752
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6320
movq %r12, %rdi
callq 0x6548
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xb
popq %rdx
callq 0x103d2
testb %al, %al
je 0x7ddc0
pushq $0xb
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x12174
addl $-0xb, %eax
cmpl $-0x2, %eax
jb 0x7ddc0
cmpl $0x5, 0xc(%r15)
je 0x7ddc0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a29c
movl $0x5, 0xc(%r12)
movl 0xc(%r15), %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %r8
callq 0x32752
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6320
movq %r14, %rdi
callq 0x6548
leaq 0x28(%rsp), %rdi
callq 0x17a3e
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x17a3e
movq %rbx, %rdi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x90a4
movl 0x18(%r15), %esi
movq 0x20(%r14), %rcx
movq %rsi, %rdx
shlq $0x4, %rdx
cmpl $0x3, 0x8(%rcx,%rdx)
jne 0x7de25
movq 0x20(%rax), %rcx
cmpq 0x28(%rax), %rcx
jne 0x7de35
cmpl $0xc, 0xc(%rax)
je 0x7de35
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3dbfc
jmp 0x7de4b
movq %r14, %rdi
callq 0x17bce
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x271d4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movl 0x8(%rsi), %ecx
testl %ecx, %ecx
je 0x8bba5
movl 0x4(%rsi), %eax
addl %eax, %ecx
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rcx, %rsi
jb 0x8bbb0
leaq (%rdx,%rax,4), %rax
jmp 0x8bba7
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %rbx
leaq 0x4636(%rip), %rsi      # 0x901f8
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0x5b1d6(%rip), %rsi     # 0xe6dc0
movq 0x5c3ef(%rip), %rdx     # 0xe7fe0
movq %rbx, %rdi
callq 0x6490
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x8bc10
jmp 0x8bc18
movq %rax, %r14
movq %rbx, %rdi
callq 0x6200
movq %r14, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %r14d
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
pushq $0x4
popq %rbp
movl %r14d, %r14d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x8bc9b
movl (%rax,%r14,4), %r12d
movl %ebp, %r13d
subl $0x1, %r13d
jb 0x8bc84
testb %r12b, %r12b
je 0x8bc89
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x6230
shrl $0x8, %r12d
jmp 0x8bc67
incl %r14d
jmp 0x8bc4a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6140
movq %rax, %r14
leaq 0x12eef(%rip), %rsi     # 0x9eb9c
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6100
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6f6e
xorl %ebp, %ebp
leaq 0x5b0eb(%rip), %rsi     # 0xe6dc0
movq 0x5c304(%rip), %rdx     # 0xe7fe0
movq %r14, %rdi
callq 0x6490
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6548
testb %bpl, %bpl
jne 0x8bcfb
jmp 0x8bd08
movq %rax, %r15
movq %r14, %rdi
callq 0x6200
jmp 0x8bd08
movq %rax, %r15
movq %rbx, %rdi
callq 0x6548
movq %r15, %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8c5da
cmpl $0xc, 0x10(%r14)
jne 0x8c0c2
movl 0xc(%rax), %eax
cmpl $0xd, %eax
sete %bpl
cmpl $0x8, %eax
sete %r12b
jmp 0x8c0fd
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
movq 0x30(%rbx), %rdx
imulq $0x148, %rcx, %rcx      # imm = 0x148
cmpl $0xd, %eax
sete %bpl
cmpl $0x8, %eax
sete %r12b
testb $0x8, 0x60(%rdx,%rcx)
jne 0x8c0fd
movl 0x8(%r14), %esi
pushq $0x13
popq %rdx
movq %rbx, %rdi
callq 0x1fcfa
movl %eax, %ebx
xorl %ecx, %ecx
jmp 0x8c123
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1fb0a
movl (%r15), %ebx
shrl $0x13, %ebx
andl $0x1, %ebx
leaq 0x8(%rsp), %rdi
callq 0xb51c
movb $0x1, %cl
orb %bpl, %r12b
movl %ebx, %edx
xorb $0x1, %dl
movzbl %r12b, %eax
movzbl %dl, %edx
testb %bl, %bl
cmovnel %edx, %eax
testb %cl, %cl
cmovnel %edx, %eax
andb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rossy[P]crossc/SPIRV-Cross/spirv_common.hpp
// Function: spirv_cross::SPIRConstant::SPIRConstant(unsigned int, spirv_cross::SPIRConstant const* const*, unsigned int, bool)
SPIRConstant(uint32_t constant_type_, const SPIRConstant *const *vector_elements, uint32_t num_elements,
	             bool specialized)
	    : constant_type(constant_type_)
	    , specialization(specialized)
	{
		bool matrix = vector_elements[0]->m.c[0].vecsize > 1;

		if (matrix)
		{
			m.columns = num_elements;

			for (uint32_t i = 0; i < num_elements; i++)
			{
				m.c[i] = vector_elements[i]->m.c[0];
				if (vector_elements[i]->specialization)
					m.id[i] = vector_elements[i]->self;
			}
		}
		else
		{
			m.c[0].vecsize = num_elements;
			m.columns = 1;

			for (uint32_t i = 0; i < num_elements; i++)
			{
				m.c[0].r[i] = vector_elements[i]->m.c[0].r[0];
				if (vector_elements[i]->specialization)
					m.c[0].id[i] = vector_elements[i]->self;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
andl $0x0, 0x8(%rdi)
leaq 0x59cf6(%rip), %rax     # 0xe74c0
addq $0x10, %rax
movq %rax, (%rdi)
movl %esi, 0xc(%rdi)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
callq 0x1ae7e
movb %r12b, 0x108(%r14)
andw $0x0, 0x109(%r14)
xorps %xmm0, %xmm0
andq $0x0, 0x120(%r14)
movups %xmm0, 0x110(%r14)
movq (%rbx), %rax
cmpl $0x2, 0x40(%rax)
jb 0x8d866
movl %ebp, 0x100(%r14)
movl %ebp, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x8d8a5
movq (%rbx,%rcx,8), %rdx
movl 0x40(%rdx), %esi
movl %esi, 0x30(%r15)
movups 0x10(%rdx), %xmm0
movups 0x20(%rdx), %xmm1
movups 0x30(%rdx), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq (%rbx,%rcx,8), %rdx
cmpb $0x1, 0x108(%rdx)
jne 0x8d85d
movl 0x8(%rdx), %edx
movl %edx, 0xf0(%r14,%rcx,4)
incq %rcx
addq $0x38, %r15
jmp 0x8d817
movl %ebp, 0x40(%r14)
movl $0x1, 0x100(%r14)
movl %ebp, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x8d8a5
movq (%rbx,%rcx,8), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%r14,%rcx,8)
movq (%rbx,%rcx,8), %rdx
cmpb $0x1, 0x108(%rdx)
jne 0x8d8a0
movl 0x8(%rdx), %edx
movl %edx, 0x30(%r14,%rcx,4)
incq %rcx
jmp 0x8d879
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
leaq 0x30(%rsp), %r15
movq %rdi, (%r15)
leaq 0x28(%rsp), %r12
movq %rsi, (%r12)
pushq $0x48
popq %rdi
callq 0x6270
movq %rax, %rbx
andq $0x0, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8e79f
movq 0x8(%rsp), %rax
andq $0x0, 0x8(%rsp)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x8e715
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8e715
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x8e776
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
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6320
movq %r15, %rdi
callq 0x6548
callq 0x6470
jmp 0x8e715
movq %rax, %r15
callq 0x6470
movq %r15, %rdi
callq 0x64b0
movq %rax, %rdi
callq 0x6ced
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8ea6e
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x6320
movq %r14, %rdi
callq 0x6548
movq 0x8(%rbx), %rax
jmp 0x8ea70
movq %rax, %r14
cmpl $0x1, %edx
jne 0x8ea80
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 0x6320
movq %r14, %rdi
callq 0x6548
callq 0x6470
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
callq 0x6470
movq %r14, %rdi
callq 0x64b0
movq %rax, %rdi
callq 0x6ced
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
testq %rdx, %rdx
je 0x37f2
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2e1a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x2240
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x20f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x37e2
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x50(%rsp,%rax), %eax
testb $0x2, %al
jne 0x37de
leaq 0x30(%rsp), %rdi
callq 0x2140
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x50(%rsp,%rax), %eax
testb $0x2, %al
jne 0x3801
xorl %eax, %eax
movb %al, (%rbx)
leaq 0x30(%rsp), %rdi
callq 0x20a0
jmp 0x37f5
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rbx)
movb $0x1, %al
jmp 0x37e4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
jmp 0x382d
movq %rax, %rbx
jmp 0x382d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::keyword_parser<int>::operator()(char const*) const
maybe<V> operator()(const char* text) const {
        if (!text) return nothing;
        for (const auto& p: map_) {
            if (text==p.first) return p.second;
        }
        return nothing;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3da8
movq %rdx, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x3da8
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dc6
testb %al, %al
jne 0x3dac
addq $0x28, %r15
jmp 0x3d8e
xorl %eax, %eax
jmp 0x3db5
movl 0x20(%r15), %eax
movl %eax, 0x4(%rbx)
movb $0x1, %al
movb %al, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heather.cpp
// Function: atohex(char*)
u32 atohex(char *s)
{
u32 val;

   // return 32-bit integer value of a hex ascii string (can have leading 0x)

   if(s == 0) return 0;
   if((s[0] == '0') && (s[1] == 'x')) s += 2;
   else if((s[0] == '0') && (s[1] == 'X')) s += 2;

   val = 0;
   sscanf(s, "%x", &val);
   return val;
}

// Assembly:
testq %rdi, %rdi
je 0x98c9
cmpb $0x30, (%rdi)
jne 0x98d7
movb 0x1(%rdi), %al
cmpb $0x78, %al
jne 0x98cc
addq $0x2, %rdi
jmp 0x98d7
xorl %eax, %eax
retq
xorl %ecx, %ecx
cmpb $0x58, %al
sete %cl
leaq (%rdi,%rcx,2), %rdi
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0xc(%rbp), %rbx
andl $0x0, (%rbx)
leaq 0x1019d6(%rip), %rsi    # 0x10b2c1
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9350
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heather.cpp
// Function: atosecs(char*)
double atosecs(char *s)
{
double val;

   // return integer value of a hex ascii string
   if(s == 0) return 0;

   val = 0;
   val = atof(s);

   if(strchr(s, 'm') || strchr(s, 'M')) val *= 60.0;
   else if(strchr(s, 'h') || strchr(s, 'H')) val *= 60.0*60.0;
   else if(strchr(s, 'd') || strchr(s, 'D')) val *= 24.0*60.0*60.0;

   return val;
}

// Assembly:
testq %rdi, %rdi
je 0x994a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9470
movsd %xmm0, -0x10(%rbp)
pushq $0x6d
popq %rsi
movq %rbx, %rdi
callq 0x9100
testq %rax, %rax
jne 0x9936
pushq $0x4d
popq %rsi
movq %rbx, %rdi
callq 0x9100
testq %rax, %rax
je 0x994e
movsd -0x10(%rbp), %xmm0
mulsd 0xe96c5(%rip), %xmm0    # 0xf3008
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorps %xmm0, %xmm0
retq
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x9100
testq %rax, %rax
jne 0x996e
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x9100
testq %rax, %rax
je 0x997d
movsd -0x10(%rbp), %xmm0
mulsd 0xe9695(%rip), %xmm0    # 0xf3010
jmp 0x9943
pushq $0x64
popq %rsi
movq %rbx, %rdi
callq 0x9100
testq %rax, %rax
jne 0x999d
pushq $0x44
popq %rsi
movq %rbx, %rdi
callq 0x9100
testq %rax, %rax
je 0x99ac
movsd -0x10(%rbp), %xmm0
mulsd 0xe966e(%rip), %xmm0    # 0xf3018
jmp 0x9943
movsd -0x10(%rbp), %xmm0
jmp 0x9943
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heather.cpp
// Function: tune_exists(char*, int)
int tune_exists(char *file, int add_path)
{
char tune[MAX_PATH+1];
FILE *f;

   // This routine sees if a sound file exists

   if(add_path) sprintf(tune, "%s%s", heather_path, file);
   else         sprintf(tune, "%s", file);

   f = topen(tune, "r");
   if(f) {
      fclose(f);
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rcx
testl %esi, %esi
je 0x99e3
leaq 0xebc49(%rip), %rsi     # 0xf5615
leaq 0x1512bd(%rip), %rdx    # 0x15ac90
leaq -0x110(%rbp), %rdi
xorl %eax, %eax
callq 0x9060
jmp 0x99f2
leaq -0x110(%rbp), %rdi
movq %rcx, %rsi
callq 0x9330
leaq 0x1012dc(%rip), %rsi    # 0x10acd5
leaq -0x110(%rbp), %rdi
callq 0x9a22
testq %rax, %rax
je 0x9a17
movq %rax, %rdi
callq 0x9360
pushq $0x1
popq %rax
jmp 0x9a19
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heather.cpp
// Function: topen(char*, char*)
FILE *topen(char *fn, char *m)
{
char *f;

   // open a file,  trim leading whitespace from the name
   if(m == 0) return 0;
   f = trim_whitespace(fn);
   if(f == 0) return 0;

if(show_debug_info) printf("topen(%s, %s)\n", f,m);  //zorky
   return path_open(f, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x9a6a
movq %rsi, %rbx
callq 0x9f43
testq %rax, %rax
je 0x9a6a
movq %rax, %r14
cmpb $0x0, 0x1f8e7f(%rip)    # 0x2028c4
je 0x9a5b
leaq 0xe9ed2(%rip), %rdi     # 0xf3920
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9030
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xa1cd
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heather.cpp
// Function: alarm_clock()
void alarm_clock()
{
   if(alarm_file)           play_tune(ALARM_FILE, 1);
   else if(chord_file == 2) play_tune(USER_CHORD_FILE, 1);
   else if(chord_file)      play_tune(CHORD_FILE, 0);
   else                     BEEP(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x2ee53a(%rip)    # 0x2f82c3
je 0x9d9d
leaq 0xe9917(%rip), %rdi     # 0xf36a9
movl $0x1, %esi
popq %rbp
jmp 0x9c78
movzbl 0x2ee319(%rip), %eax    # 0x2f80bd
testl %eax, %eax
je 0x9db6
cmpl $0x2, %eax
jne 0x9dc1
leaq 0xe9989(%rip), %rdi     # 0xf373d
jmp 0x9d92
movl $0x1, %edi
popq %rbp
jmp 0x9d23
leaq 0xe9987(%rip), %rdi     # 0xf374f
xorl %esi, %esi
jmp 0x9d97
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heather.cpp
// Function: cuckoo_clock()
void cuckoo_clock()
{
char fn[MAX_PATH+1];

   if(singing_clock) {  // sing a song file
      get_alarm_time();
      if((singing_clock == 2) && (g_minutes == 0)) {  // Big Ben mode - play a different file each hour on the hour
         sprintf(fn, HOUR_NAME, g_hours%12);
      }
      else {
         sprintf(fn, SONG_NAME, g_minutes);
      }
      play_tune(fn, 1);
      cuckoo_beeps = 0;
   }
   else if(ships_clock && (ring_bell >= 0) && (bell_number >= 0) && (bell_number < MAX_BELLS)) {
      if(bell_file && (bells[ring_bell][bell_number])) play_tune(BELL_FILE, 1);
      if(++bell_number >= MAX_BELLS) bell_number = (-1);
   }
   else if(chime_file) play_tune(CHIME_FILE, 1);
   else if(notify_file == 2) play_tune(USER_NOTIFY_FILE, 1);
   else if(notify_file) play_tune(NOTIFY_FILE, 0);
   else BEEP(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
cmpb $0x0, 0x2ee0ff(%rip)    # 0x2f7edd
je 0x9e1a
callq 0xcf9e6
cmpb $0x2, 0x2ee0f1(%rip)    # 0x2f7edd
sete %al
movl 0x2ed8b7(%rip), %edx    # 0x2f76ac
testl %edx, %edx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9e91
movl 0x2ed89d(%rip), %eax    # 0x2f76a8
pushq $0xc
popq %rcx
cltd
idivl %ecx
leaq 0xe9a54(%rip), %rsi     # 0xf386c
jmp 0x9e98
cmpb $0x0, 0x2ee0c0(%rip)    # 0x2f7ee1
setne %al
movl 0x2ee0ba(%rip), %ecx    # 0x2f7ee4
testl %ecx, %ecx
setns %dl
andb %al, %dl
movl 0x2ee0b1(%rip), %eax    # 0x2f7ee8
cmpl $0xc, %eax
setb %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x9ec5
cmpb $0x0, 0x2ee479(%rip)    # 0x2f82c7
je 0x9e7d
movl %ecx, %ecx
movl %eax, %edx
imulq $0x30, %rcx, %rcx
leaq 0x13f0f1(%rip), %rsi    # 0x148f50
addq %rcx, %rsi
cmpl $0x0, (%rsi,%rdx,4)
je 0x9e7d
leaq 0xe9885(%rip), %rdi     # 0xf36f4
pushq $0x1
popq %rsi
callq 0x9c78
movl 0x2ee06b(%rip), %eax    # 0x2f7ee8
leal 0x1(%rax), %ecx
cmpl $0xb, %eax
pushq $-0x1
popq %rax
cmovll %ecx, %eax
movl %eax, 0x2ee059(%rip)    # 0x2f7ee8
jmp 0x9ebc
leaq 0xe99e9(%rip), %rsi     # 0xf3881
leaq -0x110(%rbp), %rdi
xorl %eax, %eax
callq 0x9060
leaq -0x110(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x9c78
movb $0x0, 0x2ee023(%rip)    # 0x2f7edf
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
cmpb $0x0, 0x2ee3f4(%rip)    # 0x2f82c0
je 0x9ee5
leaq 0xe97c2(%rip), %rdi     # 0xf3697
pushq $0x1
popq %rsi
addq $0x110, %rsp            # imm = 0x110
popq %rbp
jmp 0x9c78
movzbl 0x2ee1d2(%rip), %eax    # 0x2f80be
testl %eax, %eax
je 0x9efe
cmpl $0x2, %eax
jne 0x9f0e
leaq 0xe986e(%rip), %rdi     # 0xf376a
jmp 0x9ed5
pushq $0x2
popq %rdi
addq $0x110, %rsp            # imm = 0x110
popq %rbp
jmp 0x9d23
leaq 0xe9868(%rip), %rdi     # 0xf377d
xorl %esi, %esi
jmp 0x9ed8
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heather.cpp
// Function: text_editor()
void text_editor()
{
char *e;

   // run a text editor program
   if(no_exec) return;

   e = getenv("HEATHER_EDITOR");
   if(!e || !*e) {
      e = getenv("EDITOR");
   }
   if(!e || !*e) {
      e = editor;
   }

   run_program(e, 0);
}

// Assembly:
cmpl $0x0, 0x2edffc(%rip)    # 0x2f80b4
je 0xa0bb
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xe9813(%rip), %rdi     # 0xf38d9
callq 0x9460
testq %rax, %rax
je 0xa0d5
cmpb $0x0, (%rax)
jne 0xa0f2
leaq 0xe9805(%rip), %rdi     # 0xf38e1
callq 0x9460
testq %rax, %rax
je 0xa0eb
cmpb $0x0, (%rax)
jne 0xa0f2
movq 0x13dc26(%rip), %rax    # 0x147d18
movq %rax, %rdi
xorl %esi, %esi
popq %rbp
jmp 0x9f69