LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::ret_stmt_node::gen_code()
void ret_stmt_node::gen_code()
{
	if (ret_val)
	{
		code = ret_val->code;
		code += "\treturn " + ret_val->eeyore_name + "\n";
		dbg_printf("gen_code in ret_stmt...ret_val:%s\n",
			ret_val->eeyore_name.c_str());
	}
	else
		code += "\treturn\n";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rsi
testq %rsi, %rsi
je 0xe409
addq $0x18, %rsi
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
callq 0x5140
movq 0x40(%r14), %rdx
addq $0x70, %rdx
leaq 0x1a6a6(%rip), %rsi     # 0x28a6c
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x11eb4
leaq 0x1a602(%rip), %rsi     # 0x289dc
movq %r14, %rdi
callq 0x5510
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xe423
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xe42a
addq $0x18, %r14
leaq 0x1a661(%rip), %rsi     # 0x28a75
movq %r14, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x5510
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe46b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe486
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5240
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe4ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xe4ad
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4c8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5240
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::exp_node::exp_node(sysY_AST::exp_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, sysY_AST::op_t, sysY_AST::exp_node*)
exp_node::exp_node(exp_t _exp_type, const string &_sysy_name, int _num,
	op_t _op, exp_node *_child)
{
	exp_type = _exp_type;
	sysy_name = _sysy_name;
	child = _child;
	num = _num;
	op = _op;
	reduce();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdi, %rbx
leaq 0x260e7(%rip), %rax     # 0x345d8
movq %rax, (%rdi)
leaq 0x28(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
leaq 0x26d98(%rip), %rcx     # 0x352b0
movl (%rcx), %ecx
movl %ecx, 0x38(%rdi)
leaq 0x25ff4(%rip), %rcx     # 0x34518
movq %rcx, (%rdi)
movq %rax, 0x40(%rdi)
leaq 0x50(%rdi), %r14
leaq 0x60(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x80(%rdi), %r13
movq %r13, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movb %al, 0x80(%rdi)
movq %rax, 0x90(%rdi)
movl $0x0, 0x9c(%rdi)
movl %esi, 0x98(%rdi)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x5140
movq %r15, 0x48(%rbx)
movl %r12d, 0x94(%rbx)
movl %ebp, 0x90(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x70(%rbx), %rdi
cmpq %r13, %rdi
je 0xe5bb
movq (%r13), %rsi
incq %rsi
callq 0x5240
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0xe5d5
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
leaq 0x25ffc(%rip), %rax     # 0x345d8
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0xe5fa
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::idx_open(std::vector<sysY_AST::exp_node*, std::allocator<sysY_AST::exp_node*>> const&, sysY_AST::var_entry const&)
static exp_node *idx_open(
	const vector<exp_node *> &idx, const var_entry &query_arr)
{
	if (idx.empty())
		return new exp_node(EXP_NUM, "", 0);
	auto ret = *idx.begin();
	auto size = idx.size();
	for (auto i = 1; i < size; i++)
	{
		auto scale = new exp_node(EXP_NUM, "", query_arr.dim[i]);
		dbg_printf("idx num: %d,\n", idx[i]->num);
		ret = new arith_exp_node(MUL, ret, scale);
		ret = new arith_exp_node(ADD, ret, idx[i]);
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq (%rdi), %rax
movq %rdi, 0x28(%rsp)
movq 0x8(%rdi), %rbx
cmpq %rbx, %rax
je 0xfaa1
movq (%rax), %rbp
subq %rax, %rbx
sarq $0x3, %rbx
cmpq $0x2, %rbx
jb 0xfafc
movl $0x1, %r13d
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0xa0, %edi
callq 0x5220
movq %rax, %r12
movq %r14, 0x8(%rsp)
movq %r15, %rdi
leaq 0x19edc(%rip), %rdx     # 0x298d9
movq %rdx, %rsi
callq 0x6ef6
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rax
movl (%rax,%r13,4), %ecx
movq %r12, %rdi
movl $0x2, %esi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe4d0
movq 0x8(%rsp), %rdi
movq %r14, %r15
cmpq %r14, %rdi
je 0xfa42
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movl $0xb0, %edi
callq 0x5220
movq %rax, %r14
movq %rax, %rdi
movl $0xa, %esi
movq %rbp, %rdx
movq %r12, %rcx
callq 0xfb82
movl $0xb0, %edi
callq 0x5220
movq %rax, %rbp
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %rcx
movq %rbp, %rdi
movl $0x7, %esi
movq %r14, %rdx
callq 0xfb82
incq %r13
cmpq %r13, %rbx
movq %r15, %r14
leaq 0x8(%rsp), %r15
jne 0xf9e1
jmp 0xfafc
movl $0xa0, %edi
callq 0x5220
movq %rax, %rbp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19e1b(%rip), %rdx     # 0x298d9
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x6ef6
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe4d0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfafc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movq %rbp, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfb2d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xfb2d
movq %rax, %r15
movl $0xa0, %esi
jmp 0xfb72
movq %rax, %r15
jmp 0xfb53
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfb53
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movl $0xa0, %esi
movq %r12, %rdi
jmp 0xfb75
movq %rax, %r15
movl $0xb0, %esi
movq %r14, %rdi
jmp 0xfb75
movq %rax, %r15
movl $0xb0, %esi
movq %rbp, %rdi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::arith_exp_node::arith_exp_node(sysY_AST::op_t, sysY_AST::exp_node*, sysY_AST::exp_node*)
arith_exp_node::arith_exp_node(op_t _op, exp_node *_left, exp_node *_right) :
	exp_node(EXP_TEMP, "", 0, _op), left(_left), right(_right)
{
	assert(op != NONE && op != AND && op != OR);
	if (!is_cond && op == NOT)
		yyerror("operator '!' should only appear in condition expression");
	if (left->exp_type == EXP_PTR || (right && right->exp_type == EXP_PTR))
		yyerror("pointer cannot be in an expression");
	reduce();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x19d2f(%rip), %rdx     # 0x298d9
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x6ef6
movq %rsp, %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0xe4d0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xfbe0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x24991(%rip), %rax     # 0x34578
movq %rax, (%rbx)
movq %r15, 0xa0(%rbx)
movq %r14, 0xa8(%rbx)
cmpb $0x0, 0x25745(%rip)     # 0x35344
jne 0xfc1f
cmpl $0xf, 0x90(%rbx)
jne 0xfc1f
leaq 0x2569f(%rip), %rax     # 0x352b0
movl (%rax), %esi
leaq 0x18ec3(%rip), %rdi     # 0x28add
callq 0x81dc
movq 0xa0(%rbx), %rax
cmpl $0x6, 0x98(%rax)
je 0xfc44
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0xfc59
cmpl $0x6, 0x98(%rax)
jne 0xfc59
leaq 0x25665(%rip), %rax     # 0x352b0
movl (%rax), %esi
leaq 0x18ec1(%rip), %rdi     # 0x28b15
callq 0x81dc
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x12252
jmp 0xfc9a
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xfc9a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xfc9a
movq %rax, %r14
movq %r14, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::func_call_exp_node::check_ret_type(sysY_AST::exp_node*)
void func_call_exp_node::check_ret_type(exp_node *func_exp)
{
	if (func_exp->exp_type != EXP_FUNC_CALL) // not a function call
		return;
	auto func_call_exp = static_cast<func_call_exp_node *>(func_exp);
	func_entry query;
	find_func(func_call_exp->sysy_func_name, query);
	if (query.ret_type != INT)
	{
		string msg;
		msg = "function '" + func_call_exp->sysy_func_name +
			"' has no return value";
		yyerror(msg.c_str());
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
cmpl $0x3, 0x98(%rdi)
jne 0x115d6
movq %rdi, %rbx
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x30(%r15)
addq $0xb8, %rbx
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x150b3
cmpl $0x1, 0xb0(%rsp)
je 0x115a0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x1753c(%rip), %rsi     # 0x28a0f
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0x11eb4
leaq 0x17707(%rip), %rsi     # 0x28bee
leaq 0x20(%rsp), %rdi
callq 0x5510
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x11519
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
jmp 0x11521
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rbx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5310
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1155d
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11578
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5240
movq (%rsp), %rdi
leaq 0x23d2d(%rip), %rax     # 0x352b0
movl (%rax), %esi
callq 0x81dc
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x115a0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x80(%rsp), %rbx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x123f6
movq %rbx, %rdi
callq 0x123f6
movq -0x38(%r14), %rdi
cmpq %r15, %rdi
je 0x115d6
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x5240
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11608
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0x11608
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11623
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0x11623
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x12222
movq %rbx, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::var_entry::var_entry(bool, bool, bool, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
var_entry::var_entry(bool _is_array, bool _is_const, bool _is_param,
	const vector<int> &_dim, const vector<int> &_val, const string &_sysy_name)
{
	is_array = _is_array;
	is_const = _is_const;
	is_param = _is_param;
	sysy_name = _sysy_name;
	dim = _dim;
	val = _val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rdi, %rbx
movq 0x50(%rsp), %rax
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, (%rbx)
xorl %edi, %edi
movq %rdi, 0x8(%rbx)
movb %dil, 0x10(%rbx)
leaq 0x20(%rbx), %r14
leaq 0x30(%rbx), %r8
movq %r8, 0x8(%rsp)
movq %r8, 0x20(%rbx)
movq %rdi, 0x28(%rbx)
movb %dil, 0x30(%rbx)
leaq 0x48(%rbx), %r12
leaq 0x60(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movb %sil, 0x40(%rbx)
movb %dl, 0x41(%rbx)
movb %cl, 0x42(%rbx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5140
movq %r12, %rdi
movq %r13, %rsi
callq 0x152b0
movq %rbp, %rdi
movq %r15, %rsi
callq 0x152b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x133c8
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x5240
movq (%r12), %rdi
testq %rdi, %rdi
je 0x133dd
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x5240
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0x133f7
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x13411
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::defined(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool defined(const string &name)
{
	if (func_table.count(name))
		return true;

	if (var_stack[blk_id].count(name))
		return true;
	return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x20a4c(%rip), %rdi     # 0x35380
movq %rbx, %rsi
callq 0x15fd2
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x14966
movslq 0x20a8b(%rip), %rax     # 0x353d8
imulq $0x38, %rax, %rdi
addq 0x20a10(%rip), %rdi     # 0x35368
movq %rbx, %rsi
callq 0x1600c
testq %rax, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::dec_blk()
void dec_blk()
{
	blk_id--;
	if (blk_id == 0)
	{
		param_id = 0;
		now_func_name = "";
	}
	var_stack.pop_back();
}

// Assembly:
decl 0x209ed(%rip)           # 0x353d8
jne 0x14a1b
pushq %rax
movl $0x0, 0x209e4(%rip)     # 0x353dc
movq 0x209c1(%rip), %rdx     # 0x353c0
leaq 0x209b2(%rip), %rdi     # 0x353b8
leaq 0x14ecc(%rip), %rcx     # 0x298d9
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x53f0
addq $0x8, %rsp
movq 0x2094e(%rip), %rdi     # 0x35370
addq $-0x38, %rdi
movq %rdi, 0x20943(%rip)     # 0x35370
jmp 0x15450
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::find_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, sysY_AST::var_entry&)
bool find_var(const string &name, var_entry &store)
{
	for (int i = blk_id; i >= 0; i--)
		if (var_stack[i].count(name))
		{
			store = var_stack[i][name];
			return true;
		}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x2045d(%rip), %r15     # 0x353d8
testq %r15, %r15
setns %bpl
js 0x15032
movq %rsi, %rbx
movq %rdi, %r14
imulq $0x38, %r15, %r12
movq 0x203cf(%rip), %rdi     # 0x35368
addq %r12, %rdi
movq %r14, %rsi
callq 0x1600c
testq %rax, %rax
jne 0x14fd4
addq $-0x38, %r12
testq %r15, %r15
setg %bpl
jle 0x15032
decq %r15
movq 0x203a8(%rip), %rdi     # 0x35368
addq %r12, %rdi
movq %r14, %rsi
callq 0x1600c
addq $-0x38, %r12
testq %rax, %rax
je 0x14fad
imulq $0x38, %r15, %rdi
addq 0x20389(%rip), %rdi     # 0x35368
movq %r14, %rsi
callq 0x1610e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5140
leaq 0x20(%rbx), %rdi
leaq 0x20(%r14), %rsi
callq 0x5140
movb 0x42(%r14), %al
movb %al, 0x42(%rbx)
movzwl 0x40(%r14), %eax
movw %ax, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x48(%r14), %rsi
callq 0x152b0
addq $0x60, %rbx
addq $0x60, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x152b0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::find_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool find_var(const string &name)
{
	for (int i = blk_id; i >= 0; i--)
		if (var_stack[i].count(name))
			return true;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x2038c(%rip), %r15     # 0x353d8
testq %r15, %r15
setns %bpl
js 0x150a8
movq %rdi, %rbx
imulq $0x38, %r15, %r14
movq 0x20305(%rip), %rdi     # 0x35368
addq %r14, %rdi
movq %rbx, %rsi
callq 0x1600c
testq %rax, %rax
jne 0x150a8
addq $-0x38, %r14
incq %r15
leaq -0x1(%r15), %rax
testq %rax, %rax
setg %bpl
decq %r15
jle 0x150a8
leaq -0x38(%r14), %r12
addq 0x202d3(%rip), %r14     # 0x35368
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1600c
movq %r12, %r14
testq %rax, %rax
je 0x1507a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::find_func(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, sysY_AST::func_entry&)
bool find_func(const string &name, func_entry &store)
{
	if (func_table.count(name) == 0)
		return false;
	store = func_table[name];
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x202bb(%rip), %rdi     # 0x35380
movq %r15, %rsi
callq 0x15fd2
movq %rax, %r14
testq %rax, %rax
je 0x15113
leaq 0x202a4(%rip), %rdi     # 0x35380
movq %r15, %rsi
callq 0x12e54
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5140
leaq 0x20(%rbx), %rdi
leaq 0x20(%r15), %rsi
callq 0x1556c
leaq 0x38(%rbx), %rdi
leaq 0x38(%r15), %rsi
callq 0x1556c
movl 0x50(%r15), %eax
movl %eax, 0x50(%rbx)
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x17b6a
movl %esi, %ebp
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x124aa
movl %ebp, 0x20(%r14)
movb $0x1, 0x24(%r14)
leaq 0x1dba3(%rip), %rdi     # 0x356f0
leaq 0x1dca4(%rip), %rsi     # 0x357f8
callq 0x1a652
addq $0x20, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18d04
jmp 0x17bb9
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x124aa
movl $0x4, 0x20(%r14)
movb $0x0, 0x24(%r14)
leaq 0x1db52(%rip), %rdi     # 0x356f0
leaq 0x1dc53(%rip), %rsi     # 0x357f8
callq 0x1a652
addq $0x20, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18d04
movq %rax, %rbx
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x5310
movb 0x4(%r12), %al
movb %al, 0x24(%rbx)
movl (%r12), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x17bf5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17c04
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x17c1e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movl $0x8, %edx
callq 0x5480
movq (%r14), %rax
movsbl (%rax), %edi
callq 0x5440
testl %eax, %eax
je 0x17c75
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rcx
callq 0x19808
jmp 0x17ca5
leaq 0x18(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x5160
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x3(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x1962e
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x8(%rbx)
movq 0x1d300(%rip), %rsi     # 0x34fc8
leaq 0x18(%rsp), %rdi
callq 0x5390
leaq 0x90(%rsp), %rdi
callq 0x50d0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x17cf1
jmp 0x17cf1
movq %rax, %rbx
movq 0x1d2cd(%rip), %rsi     # 0x34fc8
leaq 0x18(%rsp), %rdi
callq 0x5390
leaq 0x90(%rsp), %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movslq 0x70(%rdi), %rbx
movq 0x30(%rdi), %r15
testq %r15, %r15
je 0x1f830
leaq 0x10(%rsp), %r13
movq %rsp, %r14
movl $0x1, %ebp
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x22986
movslq 0x40(%rsp), %r12
shrq $0x2, %r12
cmpb $0x0, 0x44(%rsp)
cmoveq %rbp, %r12
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x1f80f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5240
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1f825
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
addq %r12, %rbx
movq (%r15), %r15
testq %r15, %r15
jne 0x1f7d5
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0xf5aa(%rip), %r14      # 0x35570
cmpl $0x3ff, %ecx            # imm = 0x3FF
ja 0x2602e
leaq 0x37c5(%rip), %rsi      # 0x2979a
movl $0x4, %edx
movq %r14, %rdi
callq 0x52a0
movq (%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x52a0
movq %rax, %r14
leaq 0x3870(%rip), %rsi      # 0x2986f
movl $0x2, %edx
movq %rax, %rdi
callq 0x52a0
movq (%rbx), %rax
movl 0x28(%rax), %esi
shll $0x2, %esi
movq %r14, %rdi
callq 0x54a0
leaq 0x3865(%rip), %rsi      # 0x29889
movl $0x5, %edx
jmp 0x260ae
leaq 0x3834(%rip), %rsi      # 0x29869
movl $0x8, %edx
movq %r14, %rdi
callq 0x52a0
movq (%rbx), %rax
movl 0x28(%rax), %esi
shll $0x2, %esi
movq %r14, %rdi
callq 0x54a0
leaq 0x2982(%rip), %rsi      # 0x289dc
movl $0x1, %edx
movq %rax, %rdi
callq 0x52a0
leaq 0x3821(%rip), %rsi      # 0x2988f
movl $0x10, %edx
movq %r14, %rdi
callq 0x52a0
leaq 0x3718(%rip), %rsi      # 0x2979a
movl $0x4, %edx
movq %r14, %rdi
callq 0x52a0
movq (%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x52a0
leaq 0x388a(%rip), %rsi      # 0x29933
movl $0x8, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26365
callq 0x5410
movl %eax, %r14d
leal 0x200(%r14), %eax
leaq 0xf265(%rip), %r15      # 0x35570
cmpl $0x3ff, %eax            # imm = 0x3FF
ja 0x263cb
leaq 0x359a(%rip), %rsi      # 0x298b7
movl $0x6, %edx
movq %r15, %rdi
callq 0x52a0
movq (%rbx), %rax
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
movq %r15, %rdi
callq 0x52a0
movq %rax, %rbx
leaq 0x3577(%rip), %rsi      # 0x298be
movl $0x6, %edx
movq %rax, %rdi
callq 0x52a0
shll $0x2, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x54a0
jmp 0x263bd
leaq 0xf204(%rip), %r14      # 0x35570
leaq 0x3562(%rip), %rsi      # 0x298d5
movl $0x4, %edx
movq %r14, %rdi
callq 0x52a0
movq (%rbx), %rax
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
movq %r14, %rdi
callq 0x52a0
movq %rax, %r14
leaq 0x34d2(%rip), %rsi      # 0x2986f
movl $0x2, %edx
movq %rax, %rdi
callq 0x52a0
movq (%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x52a0
leaq 0x2618(%rip), %rsi      # 0x289dc
movl $0x1, %edx
jmp 0x26435
leaq 0x3497(%rip), %rsi      # 0x29869
movl $0x8, %edx
movq %r15, %rdi
callq 0x52a0
shll $0x2, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x54a0
leaq 0x25e7(%rip), %rsi      # 0x289dc
movl $0x1, %edx
movq %rax, %rdi
callq 0x52a0
leaq 0x34bc(%rip), %rsi      # 0x298c5
movl $0x5, %edx
movq %r15, %rdi
callq 0x52a0
movq (%rbx), %rax
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
movq %r15, %rdi
callq 0x52a0
leaq 0x349b(%rip), %rsi      # 0x298cb
movl $0x9, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x52a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24ca
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xbff(%rip), %rcx       # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc62(%rip), %rsi       # 0x3077
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x24bf
movl $0x2, %eax
jmp 0x24bd
leaq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0x20a0
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x21f0
movl $0x4, %eax
jmp 0x24bd
leaq 0xc1e(%rip), %rsi       # 0x307e
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x2472
movl $0x5, (%rbx)
leaq 0xc0c(%rip), %rsi       # 0x3085
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x248b
movl $0x6, (%rbx)
leaq 0xbfc(%rip), %rsi       # 0x308e
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x24bf
movl $0x7, %eax
jmp 0x24bd
leaq 0xbff(%rip), %rsi       # 0x30ab
movq %r14, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x24bf
movl $0x3, %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
callq 0x21d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x288f
leaq 0x8(%rsp), %r15
cmpb $0x2e, 0x13(%rax)
je 0x287d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a20
movq (%r14), %rdi
callq 0x21d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x286c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_40.cc
// Function: main
int main(int argc, char const *argv[])
{
	Foo b;
	std::vector<Foo> v;
	v.push_back(Foo());
	b = fcn3(v.begin(), v.end());
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rsi
testq %rsi, %rsi
je 0x120c
incq %rsi
movq %rsi, -0x28(%rbp)
jmp 0x1219
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1258
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x122e
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x1060
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x124f
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x1060
movq %rbx, %rdi
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74748(%rip), %rcx     # 0x8f03b
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191c0
movq %rax, %r15
leaq 0x14(%rsp), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0x18130
movq %rax, %r12
cmpl $0x0, (%r13)
je 0x1a968
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1aa13
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, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
testl %ebp, %ebp
je 0x1a9af
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18990
movq %rbx, %rdi
callq 0x199e0
jmp 0x1aa13
movq 0xa8612(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x1a9cd
movq (%rsp), %rsi
leaq 0x74687(%rip), %rdi     # 0x8f04d
xorl %eax, %eax
callq 0x18970
movq (%rsp), %rsi
leaq 0x74628(%rip), %rdx     # 0x8f000
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 0x53(%rip), %rdx        # 0x1aa51
movq %rdx, 0x8(%rax)
movq %r15, 0x40(%rax)
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x745f3(%rip), %rsi     # 0x8f065
movq %r12, %rdx
callq 0x18f00
movq %r13, %rdi
movq %r12, %rsi
callq 0x18d30
testl %eax, %eax
je 0x1aac1
movq 0xa8538(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x1aaa6
leaq 0x745e0(%rip), %rdi     # 0x8f07c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
movq %r15, %rdi
callq 0x19ed0
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
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x743a9(%rip), %rcx     # 0x8f000
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r13
movq (%r14), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191c0
movq %rax, %r15
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movl $0x2, %esi
movq %rbp, %rdx
callq 0x19990
movq %rax, %r12
cmpl $0x0, (%rbp)
je 0x1acd3
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18420
jmp 0x1ad94
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, %ebp
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19170
testl %ebp, %ebp
je 0x1ad20
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18990
movq %rbx, %rdi
callq 0x199e0
jmp 0x1ad94
movq 0xa82a1(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x1ad3f
movq 0x8(%rsp), %rsi
leaq 0x74383(%rip), %rdi     # 0x8f0bb
xorl %eax, %eax
callq 0x18970
movq 0x8(%rsp), %rsi
leaq 0x7431a(%rip), %rdx     # 0x8f065
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 0x19ed0
movq 0x18(%rax), %rax
movq %rax, 0x18(%rbx)
movq %r15, 0x40(%rbx)
leaq 0x53(%rip), %rax        # 0x1add2
movq %rax, 0x8(%rbx)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x50(%rbx)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18d30
testl %eax, %eax
je 0x1ae22
movq 0xa81c8(%rip), %rax     # 0xc2fc8
cmpl $0x0, (%rax)
je 0x1ae16
leaq 0x742cc(%rip), %rdi     # 0x8f0d8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18970
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_O1/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 0x74aba(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19c20
movl %eax, %ebp
leaq 0x74aa6(%rip), %rcx     # 0x8f923
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1a520
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_O1/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 0x74a44(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r12
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rcx
callq 0x19320
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x1af4c
movl 0xc(%rsp), %ecx
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r15d
jmp 0x1af88
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
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74959(%rip), %rcx     # 0x8f909
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x190f0
movq %rax, %r12
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movl $0x3, %esi
movq %r13, %rcx
callq 0x1a490
movq %rax, %r14
cmpl $0x0, (%r13)
je 0x1b037
movl 0xc(%rsp), %ecx
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18690
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x18420
movl %eax, %r15d
jmp 0x1b073
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
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x18d40
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74872(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movsd 0x74044(%rip), %xmm0    # 0x8f0f8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18930
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_O1/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, %rbx
leaq 0x74815(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm2
movq (%r14), %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_O1/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 0x74786(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1a520
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movss %xmm0, (%r12)
movq %r14, %rdi
movl $0x3, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%r12)
movq %r14, %rdi
movl $0x4, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%r12)
movq %r14, %rdi
movl $0x5, %esi
callq 0x18850
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_O1/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 0x746d9(%rip), %rcx     # 0x8f909
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18850
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x18850
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_O1/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 0x74668(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18f70
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
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_O1/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 0x74603(%rip), %rcx     # 0x8f909
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a520
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x18f70
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x190f0
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