LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/eeyore_AST.cpp
// Function: eeyore_AST::reg_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
static void reg_var(const string &eeyore_name, int size)
{
	if (size == -1) // variable
		func_table[now_func].temps[eeyore_name] = var_entry(eeyore_name);
	else // array
		func_table[now_func].temps[eeyore_name] =
			var_entry(eeyore_name, size, true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x10ced
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5380
movl %ebp, 0x20(%r14)
movb $0x1, 0x24(%r14)
leaq 0x1da28(%rip), %rdi     # 0x2e6f8
leaq 0x1db29(%rip), %rsi     # 0x2e800
callq 0x13dd2
addq $0x20, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11d64
jmp 0x10d2c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5380
movl $0x4, 0x20(%r14)
movb $0x0, 0x24(%r14)
leaq 0x1d9e7(%rip), %rdi     # 0x2e6f8
leaq 0x1dae8(%rip), %rsi     # 0x2e800
callq 0x13dd2
addq $0x20, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11d64
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11d3c
movq %rbx, %rdi
callq 0x5548
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10d4f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5548
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/eeyore_AST.cpp
// Function: eeyore_AST::parse_var_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static shared_ptr<op_node> parse_var_num(const string &s)
{
	std::istringstream s_f(s);
	if (!isalpha(s[0]))
	{
		int val;
		s_f >> val;
		return make_shared<num_node>(val);
	}
	return make_shared<var_node>(s);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x5480
movq (%r14), %rax
movsbl (%rax), %edi
callq 0x5440
testl %eax, %eax
je 0x10d9f
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x128a9
jmp 0x10dbd
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5170
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1288b
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x11548
leaq 0x28(%rsp), %rdi
callq 0x5550
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x10df3
jmp 0x10df3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5550
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/emit_tigger.cpp
// Function: tigger::emit_global_var[abi:cxx11](int, int, int, bool)
string emit_global_var(int No, int num, int size, bool is_array)
{
	seq.push_back(
		make_shared<global_var>("v" + to_string(No), is_array, size, num));
	if (is_array)
		return "v" + to_string(No) + " = malloc " + to_string(size) + "\n";
	return "v" + to_string(No) + " = " + to_string(num) + "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movb %r8b, 0x7(%rsp)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0xc6d2
leaq 0xaca3(%rip), %rsi      # 0x1f81e
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0xc95f
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x15be9
leaq 0x58(%rsp), %r15
leaq 0x78(%rsp), %r14
movaps -0x8(%r14), %xmm0
movaps %xmm0, -0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r14)
leaq 0x19dd7(%rip), %rdi     # 0x2e9a0
leaq 0x50(%rsp), %rsi
callq 0x15fd8
movq %r15, %rdi
callq 0x11548
movq %r14, %rdi
callq 0x11548
leaq 0x10(%rsp), %rdi
callq 0x5548
leaq 0x30(%rsp), %rdi
callq 0x5548
cmpb $0x1, 0x7(%rsp)
jne 0x14c75
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0xc6d2
leaq 0xac0a(%rip), %rsi      # 0x1f81e
leaq 0x50(%rsp), %rdi
movq %r14, %rdx
callq 0xc95f
leaq 0xa75a(%rip), %rdx      # 0x1f382
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc579
movl 0x8(%rsp), %esi
leaq 0x98(%rsp), %rdi
callq 0xc6d2
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0xc66b
leaq 0x9d76(%rip), %rdx      # 0x1e9dc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc579
jmp 0x14cea
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0xc6d2
leaq 0xab93(%rip), %rsi      # 0x1f81e
leaq 0x50(%rsp), %rdi
movq %r14, %rdx
callq 0xc95f
leaq 0x9c8c(%rip), %rdx      # 0x1e92b
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc579
movl 0xc(%rsp), %esi
leaq 0x98(%rsp), %rdi
callq 0xc6d2
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0xc66b
leaq 0x9cff(%rip), %rdx      # 0x1e9dc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc579
leaq 0x10(%rsp), %rdi
callq 0x5548
leaq 0x98(%rsp), %rdi
callq 0x5548
leaq 0x30(%rsp), %rdi
callq 0x5548
leaq 0x50(%rsp), %rdi
callq 0x5548
leaq 0x70(%rsp), %rdi
callq 0x5548
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14d32
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5548
jmp 0x14d46
jmp 0x14d43
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x5548
jmp 0x14d5a
jmp 0x14d57
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5548
jmp 0x14d6b
jmp 0x14d68
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5548
jmp 0x14d7c
jmp 0x14d79
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x14daf
movq %rax, %rbx
movq %r15, %rdi
callq 0x11548
movq %r14, %rdi
callq 0x11548
jmp 0x14d9b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5548
jmp 0x14daa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5548
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/emit_tigger.cpp
// Function: tigger::emit_goto(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string emit_goto(int label, const string &cond)
{
	seq.push_back(make_shared<goto_stmt>(cond, label));
	if (cond.empty()) // unconditional jump
		return "\tgoto l" + to_string(label) + "\n";
	// conditional jump
	return "\tif " + cond + " goto l" + to_string(label) + "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl %esi, (%rdx)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x15c73
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r15
movaps -0x8(%r15), %xmm0
movaps %xmm0, -0x8(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq 0x197ef(%rip), %rdi     # 0x2e9a0
leaq 0x10(%rsp), %rsi
callq 0x15fd8
movq %r12, %rdi
callq 0x11548
movq %r15, %rdi
callq 0x11548
cmpq $0x0, 0x8(%r14)
je 0x1525c
leaq 0x9a45(%rip), %rsi      # 0x1ec22
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xc598
leaq 0x9a45(%rip), %rdx      # 0x1ec39
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0xc579
movl 0xc(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0xc6d2
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0xc66b
leaq 0x97b2(%rip), %rdx      # 0x1e9dc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc579
leaq 0x10(%rsp), %rdi
callq 0x5548
leaq 0x58(%rsp), %rdi
callq 0x5548
leaq 0x30(%rsp), %rdi
callq 0x5548
leaq 0x78(%rsp), %rdi
jmp 0x152a4
movl 0xc(%rsp), %esi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0xc6d2
leaq 0x978a(%rip), %rsi      # 0x1e9fe
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0xc95f
leaq 0x9754(%rip), %rdx      # 0x1e9dc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xc579
leaq 0x10(%rsp), %rdi
callq 0x5548
leaq 0x30(%rsp), %rdi
callq 0x5548
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5548
jmp 0x152cd
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x15309
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5548
jmp 0x152e6
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5548
jmp 0x152f5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5548
jmp 0x15304
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x5548
jmp 0x15323
movq %rax, %rbx
movq %r12, %rdi
callq 0x11548
movq %r15, %rdi
callq 0x11548
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/no_alloc.cpp
// Function: no_alloc::gen_code()
void gen_code()
{
	// for global variables
	auto globals = func_table[""].temps;
	int global_cnt = 0;
	for (auto i : globals)
	{
		auto j = i.second;
		global_var2no[j.eeyore_name] = global_cnt;
		if (j.is_array)
			tigger_dst << emit_global_var(global_cnt, 0, j.size, true);
		else
			tigger_dst << emit_global_var(global_cnt);
		global_cnt++;
		dbg_printf("global var %s init\n", j.eeyore_name.c_str());
	}
	if (!globals.empty())
		tigger_dst << "\n";
	// generate functions
	for (auto i : funcnames)
		gen_func(func_table[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x8598(%rip), %rsi      # 0x1f91c
leaq 0x28(%rsp), %rdi
movq %rsp, %rdx
callq 0x68d2
leaq 0x17360(%rip), %rdi     # 0x2e6f8
leaq 0x28(%rsp), %rsi
callq 0x1499e
addq $0x20, %rax
leaq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x18fae
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x5548
movq 0xa0(%rsp), %r12
xorl %ebp, %ebp
movq %rsp, %r15
leaq 0x70(%rsp), %r13
leaq 0x17024(%rip), %r14     # 0x2e400
testq %r12, %r12
je 0x17478
leaq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x18d88
movq %r15, %rdi
leaq 0x48(%rsp), %rsi
callq 0x18dc2
leaq 0x176ea(%rip), %rdi     # 0x2eaf0
movq %r15, %rsi
callq 0x19624
movl %ebp, (%rax)
cmpb $0x1, 0x24(%rsp)
jne 0x17438
movl 0x20(%rsp), %ecx
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
pushq $0x1
popq %r8
callq 0x14b48
movq %r14, %rdi
movq %r13, %rsi
callq 0x5210
jmp 0x17455
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
pushq $0x4
popq %rcx
xorl %r8d, %r8d
callq 0x14b48
movq %r14, %rdi
movq %r13, %rsi
callq 0x5210
movq %r13, %rdi
callq 0x5548
incl %ebp
movq %r15, %rdi
callq 0x5548
movq %rbx, %rdi
callq 0x11830
movq (%r12), %r12
jmp 0x173dc
cmpq $0x0, 0xa8(%rsp)
je 0x17496
leaq 0x16f76(%rip), %rdi     # 0x2e400
leaq 0x754b(%rip), %rsi      # 0x1e9dc
callq 0x5230
leaq 0x17293(%rip), %rax     # 0x2e730
movq (%rax), %rbx
movq 0x8(%rax), %r12
leaq 0x28(%rsp), %r14
leaq 0x17248(%rip), %r15     # 0x2e6f8
cmpq %r12, %rbx
je 0x174e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5380
movq %r15, %rdi
movq %r14, %rsi
callq 0x13dd2
movq %rax, %rdi
callq 0x17570
movq %r14, %rdi
callq 0x5548
addq $0x20, %rbx
jmp 0x174b0
leaq 0x90(%rsp), %rdi
callq 0x1192e
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17549
movq %rax, %rbx
jmp 0x17568
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5548
jmp 0x17568
jmp 0x17532
jmp 0x17532
jmp 0x1751c
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x5548
jmp 0x17535
jmp 0x17549
movq %rax, %rbx
jmp 0x1753d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5548
leaq 0x28(%rsp), %rdi
callq 0x11830
jmp 0x1755b
movq %rax, %rbx
jmp 0x1755b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5548
leaq 0x90(%rsp), %rdi
callq 0x1192e
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/no_alloc.cpp
// Function: no_alloc::stack_size(eeyore_AST::func_entry const&)
size_t stack_size(const func_entry &func)
{
	size_t size = func.param_n;
	for (auto i : func.temps)
	{

		if (i.second.is_array)
			size += i.second.size / int_size;
		else
			size++;
	}
	return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movslq 0x70(%rdi), %rbx
addq $0x30, %r14
movq %rsp, %r15
pushq $0x1
popq %r12
movq (%r14), %r14
testq %r14, %r14
je 0x1782c
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x18d88
movslq 0x40(%rsp), %rax
shrq $0x2, %rax
cmpb $0x0, 0x44(%rsp)
cmoveq %r12, %rax
addq %rax, %rbx
movq %r15, %rdi
callq 0x11830
jmp 0x177f9
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/no_alloc.cpp
// Function: no_alloc::gen_stmt(std::shared_ptr<eeyore_AST::stmt_node> const&)
void gen_stmt(const shared_ptr<stmt_node> &stmt)
{
	if (stmt->label != -1)
		tigger_dst << emit_label(stmt->label);
	switch (stmt->stmt_type)
	{
	case STMT_ASSIGN:
	{
		dbg_printf("assign stmt gen\n");
		auto stmt_new = std::static_pointer_cast<assign_node>(stmt);
		gen_assign(stmt_new->lval, stmt_new->rval);
		break;
	}
	case STMT_GOTO:
	{
		dbg_printf("goto stmt gen\n");
		auto stmt_new = std::static_pointer_cast<goto_node>(stmt);
		gen_goto(stmt_new);
		break;
	}
	case STMT_RET:
	{
		dbg_printf("ret stmt gen\n");
		auto stmt_new = std::static_pointer_cast<ret_node>(stmt);
		gen_ret(stmt_new);
		break;
	}
	case STMT_CALL:
	{
		dbg_printf("call stmt gen\n");
		auto stmt_new = std::static_pointer_cast<call_node>(stmt);
		gen_call(stmt_new);
		break;
	}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x4(%rax), %esi
cmpl $-0x1, %esi
je 0x17879
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1532b
leaq 0x16b9c(%rip), %rdi     # 0x2e400
movq %r14, %rsi
callq 0x5210
leaq 0x8(%rsp), %rdi
callq 0x5548
movq (%rbx), %rax
movl (%rax), %eax
cmpq $0x3, %rax
ja 0x17936
leaq 0x7ee0(%rip), %rcx      # 0x1f76c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18e47
movq (%r14), %rsi
leaq 0x8(%rsi), %rdi
addq $0x18, %rsi
callq 0x1797f
jmp 0x1792c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18e63
movq %r14, %rdi
callq 0x17d9f
jmp 0x1792c
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x18e7f
leaq 0x8037(%rip), %rsi      # 0x1f91c
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x68d2
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x17e43
leaq 0x8(%rsp), %rdi
callq 0x5548
leaq 0x30(%rsp), %rdi
jmp 0x17931
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x119a5
movq %r14, %rdi
callq 0x17b17
leaq 0x10(%rsp), %rdi
callq 0x11548
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5548
jmp 0x17954
jmp 0x1795b
jmp 0x1795b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x17963
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x11548
jmp 0x17977
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5548
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/no_alloc.cpp
// Function: no_alloc::gen_assign(std::shared_ptr<eeyore_AST::op_node> const&, std::shared_ptr<eeyore_AST::op_node> const&)
void gen_assign(
	const shared_ptr<op_node> &lval, const shared_ptr<op_node> &rval)
{
	if (lval->exp_type == EXP_ARRAY) // store
	{
		gen_array(lval, 1, 2);
		string left = temp_prefix + to_string(1) + "[0]";
		auto right = alloc_temp_reg(rval, 2);
		tigger_dst << emit_exp_assign(left, right);
		return;
	}
	auto var = std::static_pointer_cast<var_node>(lval);
	string left = temp_prefix + to_string(1);
	gen_assign(left, rval);
	dealloc_temp_reg(lval, 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpl $0x2, 0x8(%rax)
jne 0x17a40
pushq $0x1
popq %rbp
pushq $0x2
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1856a
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0xc6d2
leaq 0x17098(%rip), %rsi     # 0x2ea58
movq %rsp, %rdi
movq %r14, %rdx
callq 0x18e23
leaq 0x7dc6(%rip), %rdx      # 0x1f798
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0xc579
movq %rsp, %rdi
callq 0x5548
leaq 0x20(%rsp), %rdi
callq 0x5548
movq %rsp, %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x18224
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
callq 0x15048
leaq 0x169e8(%rip), %rdi     # 0x2e400
leaq 0x20(%rsp), %rsi
callq 0x5210
leaq 0x20(%rsp), %rdi
callq 0x5548
movq %rsp, %rdi
callq 0x5548
leaq 0x40(%rsp), %rdi
callq 0x5548
jmp 0x17aa0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x18eb7
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0xc6d2
leaq 0x16ff9(%rip), %rsi     # 0x2ea58
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
callq 0x18e23
movq %rsp, %rdi
callq 0x5548
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x17f65
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1888a
leaq 0x40(%rsp), %rdi
callq 0x5548
leaq 0x28(%rsp), %rdi
callq 0x11548
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5548
jmp 0x17abb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5548
jmp 0x17ac8
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x17af1
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x17b00
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5548
jmp 0x17aec
movq %rax, %rbx
jmp 0x17b05
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5548
jmp 0x17b0f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5548
leaq 0x28(%rsp), %rdi
callq 0x11548
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/no_alloc.cpp
// Function: no_alloc::gen_call(std::shared_ptr<eeyore_AST::call_node> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void gen_call(const shared_ptr<call_node> &stmt, const string &ret_store)
{
	// set parameters
	for (auto i = 0; i < stmt->params.size(); i++)
		gen_assign(param_prefix + to_string(i), stmt->params[i]);
	// call it!
	tigger_dst << emit_call(stmt->func_name);
	if (!ret_store.empty()) // assign
		tigger_dst << emit_exp_assign(ret_store, ret_reg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x28(%rsp), %r15
leaq 0x16b72(%rip), %r12     # 0x2e9d8
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
movq (%r14), %rsi
movq 0x58(%rsi), %rax
subq 0x50(%rsi), %rax
sarq $0x4, %rax
cmpq %rbp, %rax
jbe 0x17ec4
movq %r15, %rdi
movl %ebp, %esi
callq 0xc6d2
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x18e23
movq (%r14), %rax
movq 0x50(%rax), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0x17f65
movq %r13, %rdi
callq 0x5548
movq %r15, %rdi
callq 0x5548
incq %rbp
addq $0x10, %rbx
jmp 0x17e6d
addq $0x68, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1541b
leaq 0x16524(%rip), %rdi     # 0x2e400
movq %r14, %rsi
callq 0x5210
leaq 0x8(%rsp), %rdi
callq 0x5548
movq (%rsp), %rsi
cmpq $0x0, 0x8(%rsi)
je 0x17f26
leaq 0x16b18(%rip), %rdx     # 0x2ea18
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x15048
leaq 0x164ec(%rip), %rdi     # 0x2e400
movq %r14, %rsi
callq 0x5210
leaq 0x8(%rsp), %rdi
callq 0x5548
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17f37
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x17f58
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5548
jmp 0x17f53
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5548
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/riscv/emit_riscv.cpp
// Function: riscv::emit_store(std::shared_ptr<tigger::store_stmt> const&)
void emit_store(const shared_ptr<tigger::store_stmt> &stmt)
{
	if (in_int10(stmt->num))
		riscv_dst << "\tsw\t" << stmt->reg << ", " << stmt->num * 4 << "(sp)\n";
	else
	{
		riscv_dst << "\tli\tt0, " << stmt->num * 4 << "\n";
		riscv_dst << "\tadd\tt0, t0, sp\n";
		riscv_dst << "\tsw\t" << stmt->reg << ", 0(t0)\n";
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl $0x200, %ecx            # imm = 0x200
addl 0x28(%rax), %ecx
cmpl $0x3ff, %ecx            # imm = 0x3FF
ja 0x1b270
leaq 0x1334c(%rip), %rdi     # 0x2e578
leaq 0x45aa(%rip), %rsi      # 0x1f7dd
callq 0x5230
movq (%rbx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x4664(%rip), %rsi      # 0x1f8b2
movq %rax, %rdi
callq 0x5230
movq (%rbx), %rcx
movl 0x28(%rcx), %esi
shll $0x2, %esi
movq %rax, %rdi
callq 0x54a0
leaq 0x465e(%rip), %rsi      # 0x1f8cc
jmp 0x1b2da
leaq 0x13301(%rip), %r14     # 0x2e578
leaq 0x462e(%rip), %rsi      # 0x1f8ac
movq %r14, %rdi
callq 0x5230
movq (%rbx), %rcx
movl 0x28(%rcx), %esi
shll $0x2, %esi
movq %rax, %rdi
callq 0x54a0
leaq 0x373e(%rip), %rsi      # 0x1e9dc
movq %rax, %rdi
callq 0x5230
leaq 0x4625(%rip), %rsi      # 0x1f8d2
movq %r14, %rdi
callq 0x5230
leaq 0x4521(%rip), %rsi      # 0x1f7dd
movq %r14, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x469c(%rip), %rsi      # 0x1f976
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5230
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/riscv/emit_riscv.cpp
// Function: riscv::emit_load(std::shared_ptr<tigger::load_stmt> const&)
void emit_load(const shared_ptr<tigger::load_stmt> &stmt)
{
	if (isdigit(stmt->addr[0])) // stack
	{
		auto num = atoi(stmt->addr.c_str());
		if (in_int10(num))
			riscv_dst << "\tlw\t" << stmt->reg << ", " << num * 4 << "(sp)\n";
		else
		{
			riscv_dst << "\tli\tt0, " << num * 4 << "\n";
			riscv_dst << "\tadd\tt0, t0, sp\n";
			riscv_dst << "\tlw\t" << stmt->reg << ", 0(t0)\n";
		}
	}
	else // global_var
	{
		riscv_dst << "\tlui\t" << stmt->reg << ", %hi(" << stmt->addr << ")\n";
		riscv_dst << "\tlw\t" << stmt->reg << ", %lo(" << stmt->addr << ")("
				  << stmt->reg << ")\n";
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movsbl (%rdi), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x1b369
callq 0x5400
movl %eax, %r14d
leal 0x200(%r14), %eax
cmpl $0x3ff, %eax            # imm = 0x3FF
ja 0x1b420
leaq 0x13254(%rip), %rdi     # 0x2e578
leaq 0x44c5(%rip), %rsi      # 0x1f7f0
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x456c(%rip), %rsi      # 0x1f8b2
movq %rax, %rdi
callq 0x5230
shll $0x2, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x54a0
leaq 0x4568(%rip), %rsi      # 0x1f8cc
jmp 0x1b488
leaq 0x13208(%rip), %r15     # 0x2e578
leaq 0x456c(%rip), %rsi      # 0x1f8e3
movq %r15, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x4554(%rip), %rsi      # 0x1f8e9
movq %rax, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x45c9(%rip), %r14      # 0x1f97c
movq %rax, %rdi
movq %r14, %rsi
callq 0x5230
leaq 0x442b(%rip), %rsi      # 0x1f7f0
movq %r15, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x450d(%rip), %rsi      # 0x1f8f0
movq %rax, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x44f6(%rip), %rsi      # 0x1f8f7
movq %rax, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
movq %rax, %rdi
movq %r14, %rsi
jmp 0x1b48b
leaq 0x13151(%rip), %r15     # 0x2e578
leaq 0x447e(%rip), %rsi      # 0x1f8ac
movq %r15, %rdi
callq 0x5230
shll $0x2, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x54a0
leaq 0x3590(%rip), %rsi      # 0x1e9dc
movq %rax, %rdi
callq 0x5230
leaq 0x4477(%rip), %rsi      # 0x1f8d2
movq %r15, %rdi
callq 0x5230
leaq 0x4386(%rip), %rsi      # 0x1f7f0
movq %r15, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x44ee(%rip), %rsi      # 0x1f976
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5230
// File: /workspace/github_cpp_makefile_star2_O2/lhydave[P]SysYCompilerLab/back/riscv/emit_riscv.cpp
// Function: riscv::emit_loadaddr(std::shared_ptr<tigger::loadaddr_stmt> const&)
void emit_loadaddr(const shared_ptr<tigger::loadaddr_stmt> &stmt)
{
	if (isdigit(stmt->addr[0])) // stack
	{
		auto num = atoi(stmt->addr.c_str());
		if (in_int10(num))
			riscv_dst << "\taddi\t" << stmt->reg << ", sp, " << num * 4 << "\n";
		else
		{
			riscv_dst << "\tli\tt0, " << num * 4 << "\n";
			riscv_dst << "\tadd\t" << stmt->reg << ", sp, t0\n";
		}
	}
	else // global_var
		riscv_dst << "\tla\t" << stmt->reg << ", " << stmt->addr << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movsbl (%rdi), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x1b50b
callq 0x5400
movl %eax, %r14d
leal 0x200(%r14), %eax
cmpl $0x3ff, %eax            # imm = 0x3FF
ja 0x1b554
leaq 0x130a8(%rip), %rdi     # 0x2e578
leaq 0x4423(%rip), %rsi      # 0x1f8fa
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x440f(%rip), %rsi      # 0x1f901
movq %rax, %rdi
callq 0x5230
shll $0x2, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x54a0
jmp 0x1b54b
leaq 0x13066(%rip), %rdi     # 0x2e578
leaq 0x43ff(%rip), %rsi      # 0x1f918
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x437e(%rip), %rsi      # 0x1f8b2
movq %rax, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x348a(%rip), %rsi      # 0x1e9dc
jmp 0x1b5ad
leaq 0x1301d(%rip), %r15     # 0x2e578
leaq 0x434a(%rip), %rsi      # 0x1f8ac
movq %r15, %rdi
callq 0x5230
shll $0x2, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x54a0
leaq 0x345c(%rip), %rsi      # 0x1e9dc
movq %rax, %rdi
callq 0x5230
leaq 0x4379(%rip), %rsi      # 0x1f908
movq %r15, %rdi
callq 0x5230
movq (%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x5210
leaq 0x4361(%rip), %rsi      # 0x1f90e
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5230
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/magento-modules.cpp
// Function: root_start_element_handler(void*, char const*, char const**)
void root_start_element_handler(void* udata, const XML_Char* name, const XML_Char** atts) {
    user_data* data = (user_data*)udata;

    //std::cout << state_names[int(data->state)] << " " << name << "\n";

    switch (data->state) {
        case State::ROOT:
            // expect <config>
            if (strcmp(name, "config") == 0) data->state = State::IN_CONFIG;
            break;
        case State::IN_CONFIG:
            // expect <modules>
            if (strcmp(name, "modules") == 0) data->state = State::IN_MODULES;
            break;
        case State::IN_MODULES:
            // name == module_name
            data->current_name = name;
            data->state = State::IN_MODULE;
            break;
        case State::IN_MODULE:
            if (strcmp(name, "active") == 0) data->state = State::IN_ACTIVE;
            if (strcmp(name, "codePool") == 0) data->state = State::IN_CODEPOOL;
            if (strcmp(name, "depends") == 0) data->state = State::IN_DEPENDS;
            break;
    }
}

// Assembly:
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x2476
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc26(%rip), %rcx       # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc89(%rip), %rsi       # 0x3077
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x246f
pushq $0x2
jmp 0x246c
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2270
pushq $0x4
jmp 0x246c
leaq 0xc69(%rip), %rsi       # 0x307e
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x2427
movl $0x5, (%rbx)
leaq 0xc57(%rip), %rsi       # 0x3085
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x2440
movl $0x6, (%rbx)
leaq 0xc47(%rip), %rsi       # 0x308e
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x246f
pushq $0x7
jmp 0x246c
leaq 0xc4d(%rip), %rsi       # 0x30ab
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x246f
pushq $0x3
popq %rax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/fs.hpp
// Function: void fs::for_all_files<parse_module_config>(fs::dir&, parse_module_config)
void for_all_files(fs::dir& d, F func) {
    fs::file f;
    while (next_file(d, f)) {
        if (f.name()[0] == '.') continue;
        func(f);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r14, %rdi
callq 0x26dc
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2721
cmpb $0x2e, 0x13(%rax)
je 0x26fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2920
jmp 0x26fc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/magento-modules.cpp
// Function: parse_module_config::operator()(fs::file const&)
void operator()(const fs::file& f) {
        XML_SetUserData(parser.handle(), &data);
        XML_SetElementHandler(parser.handle(), root_start_element_handler, root_end_element_handler);
        XML_SetCharacterDataHandler(parser.handle(), character_data_handler);

        data.filename = f.name();

        std::stringstream name;
        name << "app/etc/modules/";
        name << f.name();

        struct stat stat_buf;
        stat(name.str().c_str(), &stat_buf);
        if (S_ISREG(stat_buf.st_mode)) {
            std::ifstream in{name.str()};
            if (in) parse_xml(parser, in, &data);
            else std::cerr << "Can't open " << name.str() << "\n";
        }
        parser.reset();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x440, %rsp            # imm = 0x440
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8(%rbx), %r14
movq %r14, %rsi
callq 0x2050
movq (%rbx), %rdi
leaq -0x58f(%rip), %rsi      # 0x23c0
leaq -0x4df(%rip), %rdx      # 0x2477
callq 0x2150
movq (%rbx), %rdi
leaq -0x339(%rip), %rsi      # 0x262c
callq 0x2180
movq (%r15), %rax
addq $0x13, %rax
movq %rax, 0x10(%rbx)
leaq 0x228(%rsp), %rdi
callq 0x20d0
leaq 0x238(%rsp), %r12
leaq 0x74c(%rip), %rsi       # 0x30dd
movq %r12, %rdi
callq 0x2160
movq (%r15), %rsi
addq $0x13, %rsi
movq %r12, %rdi
callq 0x2160
leaq 0x240(%rsp), %r15
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x21f0
leaq 0x20(%rsp), %r12
movq (%r12), %rdi
leaq 0x3b0(%rsp), %r13
movq %r13, %rsi
callq 0x2140
movq %r12, %rdi
callq 0x20a0
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%r13), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x2a84
movq %rsp, %rdi
movq %r15, %rsi
callq 0x21f0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
pushq $0x8
popq %rdx
callq 0x2210
movq %rsp, %rdi
callq 0x20a0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x2a6a
movq 0x25c4(%rip), %rdi      # 0x4ff0
leaq 0x6bb(%rip), %rsi       # 0x30ee
callq 0x2160
movq %rax, %r14
movq %rsp, %rdi
movq %r15, %rsi
callq 0x21f0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2130
leaq 0x649(%rip), %rsi       # 0x30a1
movq %rax, %rdi
callq 0x2160
movq %rsp, %rdi
callq 0x20a0
jmp 0x2a7a
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2af3
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2bd8
leaq 0x228(%rsp), %rdi
callq 0x20f0
addq $0x440, %rsp            # imm = 0x440
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2aac
movq %rax, %rbx
jmp 0x2acb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
jmp 0x2ade
jmp 0x2adb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x2060
jmp 0x2ade
jmp 0x2adb
jmp 0x2adb
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/buffer.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud, *device_ud;
    VkResult ec;
    VkBuffer buffer;
    VkBufferCreateInfo* info;
    VkDevice device = checkdevice(L, 1, &device_ud);
    const VkAllocationCallbacks *allocator = optallocator(L, 3);
#define CLEANUP zfreeVkBufferCreateInfo(L, info, 1)
    info = zcheckVkBufferCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    ec = device_ud->ddt->CreateBuffer(device, info, allocator, &buffer);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    TRACE_CREATE(buffer, "buffer");
    ud = newuserdata_nondispatchable(L, buffer, BUFFER_MT);
    ud->parent_ud = device_ud;
    ud->device = device;
    ud->instance = device_ud->instance;
    ud->destructor = freebuffer;
    ud->allocator = allocator;
    ud->ddt = device_ud->ddt;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x62768(%rip), %rcx     # 0x7d03b
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x1a500
movq %rax, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x191a0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x18130
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x1a939
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1a981
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rsp, %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x108(%rax)
movl %eax, %r13d
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x19150
testl %r13d, %r13d
je 0x1a994
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa05fd(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x1a9b2
movq (%rsp), %rsi
leaq 0x626a2(%rip), %rdi     # 0x7d04d
xorl %eax, %eax
callq 0x18960
movq (%rsp), %rsi
leaq 0x62643(%rip), %rdx     # 0x7d000
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18330
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r14, 0x20(%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
leaq 0x3f(%rip), %rdx        # 0x1aa22
movq %rdx, 0x8(%rax)
movq %r15, 0x40(%rax)
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
jmp 0x1a983
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/buffer.c
// Function: freebuffer
static int freebuffer(lua_State *L, ud_t *ud)
    {
    VkBuffer buffer = (VkBuffer)ud->handle;
    VkDevice device = ud->device;
    const VkAllocationCallbacks *allocator = ud->allocator;
    freechildren(L, BUFFER_VIEW_MT, ud);
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(buffer, "buffer");
    UD(device)->ddt->DestroyBuffer(device, buffer, allocator);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
leaq 0x62622(%rip), %rsi     # 0x7d065
movq %r12, %rdx
callq 0x18ee0
movq %r13, %rdi
movq %r12, %rsi
callq 0x18d20
testl %eax, %eax
je 0x1aa92
movq 0xa0537(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x1aa77
leaq 0x6260f(%rip), %rdi     # 0x7d07c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
callq 0x19eb0
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x110(%rax)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/buffer_view.c
// Function: Create
static int Create(lua_State *L)
    {
    int err;
    ud_t *ud, *buffer_ud;
    VkResult ec;
    VkBufferView buffer_view;
    VkBufferViewCreateInfo* info;

    VkBuffer buffer = checkbuffer(L, 1, &buffer_ud);
    VkDevice device = buffer_ud->device;
    const VkAllocationCallbacks *allocator = optallocator(L, 3);

#define CLEANUP zfreeVkBufferViewCreateInfo(L, info, 1)
    info = zcheckVkBufferViewCreateInfo(L, 2, &err);
    if(err) { CLEANUP; return argerror(L, 2); }
    info->buffer = buffer;

    ec = buffer_ud->ddt->CreateBufferView(device, info, allocator, &buffer_view);
    CLEANUP;
    CheckError(L, ec);
#undef CLEANUP
    TRACE_CREATE(buffer_view, "buffer_view");
    ud = newuserdata_nondispatchable(L, buffer_view, BUFFER_VIEW_MT);
    ud->parent_ud = buffer_ud;
    ud->device = device;
    ud->instance = UD(device)->instance;
    ud->allocator = allocator;
    ud->destructor = freebuffer_view;
    ud->ddt = buffer_ud->ddt;
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x623d9(%rip), %rcx     # 0x7d000
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r13
movq (%r14), %rax
movq 0x20(%rax), %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x191a0
movq %rax, %r15
pushq $0x2
popq %rsi
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x19970
movq %rax, %r12
cmpl $0x0, (%rbp)
je 0x1ac94
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19150
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
jmp 0x1ace2
movq %r13, 0x18(%r12)
movq (%rsp), %rax
movq 0x50(%rax), %rax
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x118(%rax)
movl %eax, %r13d
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x19150
testl %r13d, %r13d
je 0x1acf5
movq %rbx, %rdi
xorl %esi, %esi
movl %r13d, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199c0
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa029c(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x1ad14
movq 0x8(%rsp), %rsi
leaq 0x623ae(%rip), %rdi     # 0x7d0bb
xorl %eax, %eax
callq 0x18960
movq 0x8(%rsp), %rsi
leaq 0x62345(%rip), %rdx     # 0x7d065
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18330
movq %rax, %rbx
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r14, 0x20(%rbx)
movq %r14, %rdi
callq 0x19eb0
movq 0x18(%rax), %rax
movq %rax, 0x18(%rbx)
movq %r15, 0x40(%rbx)
leaq 0x42(%rip), %rax        # 0x1ad96
movq %rax, 0x8(%rbx)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x50(%rbx)
jmp 0x1ace4
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/buffer_view.c
// Function: freebuffer_view
static int freebuffer_view(lua_State *L, ud_t *ud)
    {
    VkBufferView buffer_view = (VkBufferView)ud->handle;
    const VkAllocationCallbacks *allocator = ud->allocator;
    VkDevice device = ud->device;
    PFN_vkDestroyBufferView DestroyBufferView = ud->ddt->DestroyBufferView;
    if(!freeuserdata(L, ud))
        return 0; /* double call */
    TRACE_DELETE(buffer_view, "buffer_view");
    DestroyBufferView(device, buffer_view, allocator);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rbx
movq 0x20(%rsi), %r15
movq 0x40(%rsi), %r14
movq 0x50(%rsi), %rax
movq 0x120(%rax), %r12
callq 0x18d20
testl %eax, %eax
je 0x1ade6
movq 0xa01d4(%rip), %rax     # 0xbaf98
cmpl $0x0, (%rax)
je 0x1adda
leaq 0x62308(%rip), %rdi     # 0x7d0d8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *%r12
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdBindPipeline
static int CmdBindPipeline(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkPipelineBindPoint pipelineBindPoint = checkpipelinebindpoint(L, 2);
    VkPipeline pipeline = checkpipeline(L, 3, NULL);
    ud->ddt->CmdBindPipeline(cb, pipelineBindPoint, pipeline);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x62af6(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x1e
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x19c00
movl %eax, %ebp
leaq 0x62ae8(%rip), %rcx     # 0x7d923
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a500
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq *0x2d0(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetViewport
static int CmdSetViewport(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t firstViewport = luaL_checkinteger(L, 2);
#define CLEANUP zfreearrayVkViewport (L, viewports, count, 1)
    VkViewport *viewports = zcheckarrayVkViewport(L, 3, &count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdSetViewport(cb, firstViewport, count, viewports);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x62a88(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x3
popq %rsi
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rcx
callq 0x19300
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x1aefa
movl 0xc(%rsp), %ecx
pushq $0x18
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r15d
jmp 0x1af32
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0xc(%rsp), %edx
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rcx
callq *0x2d8(%rax)
movl 0xc(%rsp), %ecx
xorl %r15d, %r15d
pushq $0x18
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetScissor
static int CmdSetScissor(lua_State *L)
    {
    int err;
    uint32_t count;
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    uint32_t first = luaL_checkinteger(L, 2);
#define CLEANUP zfreearrayVkRect2D(L, scissors, count, 1)
    VkRect2D* scissors = zcheckarrayVkRect2D(L, 3, &count, &err);
    if(err) { CLEANUP; return argerror(L, 3); }
    ud->ddt->CmdSetScissor(cb, first, count, scissors);
    CLEANUP;
#undef CLEANUP
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x629af(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq %rax, %r12
pushq $0x3
popq %rsi
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rcx
callq 0x1a470
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x1afd3
movl 0xc(%rsp), %ecx
pushq $0x10
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x18680
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18420
movl %eax, %r15d
jmp 0x1b00b
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0xc(%rsp), %edx
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rcx
callq *0x2e0(%rax)
movl 0xc(%rsp), %ecx
xorl %r15d, %r15d
pushq $0x10
popq %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0x18d30
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetLineWidth
static int CmdSetLineWidth(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    float line_width = luaL_optnumber(L, 2, 1.0);
    ud->ddt->CmdSetLineWidth(cb, line_width);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x628da(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movsd 0x620ab(%rip), %xmm0    # 0x7d0f8
movq %rbx, %rdi
callq 0x18920
cvtsd2ss %xmm0, %xmm0
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
callq *0x2e8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBias
static int CmdSetDepthBias(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    float depthBiasConstantFactor = luaL_checknumber(L, 2);
    float depthBiasClamp = luaL_checknumber(L, 3); 
    float depthBiasSlopeFactor = luaL_checknumber(L, 4);
    ud->ddt->CmdSetDepthBias(cb, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x62881(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm2
movq (%rbx), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq *0x2f0(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetBlendConstants
static int CmdSetBlendConstants(lua_State *L)
    {
    float blendConstants[4];
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    blendConstants[0] = luaL_checknumber(L, 2);
    blendConstants[1] = luaL_checknumber(L, 3);
    blendConstants[2] = luaL_checknumber(L, 4);
    blendConstants[3] = luaL_checknumber(L, 5);
    ud->ddt->CmdSetBlendConstants(cb, blendConstants);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x627fa(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movss %xmm0, (%r12)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%r12)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%r12)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%r12)
movq (%rbx), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x2f8(%rax)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetDepthBounds
static int CmdSetDepthBounds(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    float minDepthBounds = luaL_checknumber(L, 2);
    float maxDepthBounds = luaL_checknumber(L, 3);
    ud->ddt->CmdSetDepthBounds(cb, minDepthBounds, maxDepthBounds);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x62757(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x18840
cvtsd2ss %xmm0, %xmm1
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %r15, %rdi
movss 0x4(%rsp), %xmm0
callq *0x300(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilCompareMask
static int CmdSetStencilCompareMask(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkStencilFaceFlags faceMask = checkflags(L, 2);
    uint32_t compareMask = luaL_checkinteger(L, 3);
    ud->ddt->CmdSetStencilCompareMask(cb, faceMask, compareMask);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x626ec(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18f50
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq *0x308(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/stetre[P]moonvulkan/src/cmd.c
// Function: CmdSetStencilWriteMask
static int CmdSetStencilWriteMask(lua_State *L)
    {
    ud_t *ud;
    VkCommandBuffer cb = checkcommand_buffer(L, 1, &ud);
    VkStencilFaceFlags faceMask = checkflags(L, 2);
    uint32_t writeMask = luaL_checkinteger(L, 3);
    ud->ddt->CmdSetStencilWriteMask(cb, faceMask, writeMask);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6268d(%rip), %rcx     # 0x7d909
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x1a500
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18f50
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x190d0
movq (%r14), %rcx
movq 0x50(%rcx), %rcx
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq *0x310(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq