LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq 0x10(%rbp), %rsi
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x54c0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x54c0
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x50(%rbp)
callq 0x12cb0
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x48(%rbp)
callq 0x12cb0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x40(%rax)
movb -0xa(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x41(%rax)
movb -0xb(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x42(%rax)
movq 0x10(%rbp), %rsi
callq 0x5050
jmp 0x1ad05
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x48, %rdi
callq 0x1c890
jmp 0x1ad18
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x60, %rdi
callq 0x1c890
jmp 0x1ad2b
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x13160
movq -0x50(%rbp), %rdi
callq 0x13160
movq -0x38(%rbp), %rdi
callq 0x56c0
movq -0x40(%rbp), %rdi
callq 0x56c0
movq -0x28(%rbp), %rdi
callq 0x5610
nopw (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::reg_func(char const*, sysY_AST::data_t)
void reg_func(const char *_name, data_t ret_type)
{
	dbg_printf("%s return int: %d\n", _name, ret_type == INT);
	string name(_name);
	assert(!name.empty());
	if (defined(name))
	{
		string msg = "identifier '" + name + "' was already defined";
		yyerror(msg.c_str());
		return;
	}
	func_table[name] = func_entry(name, ret_type);
	now_func_name = name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x5620
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x8780
jmp 0x1be46
leaq -0x31(%rbp), %rdi
callq 0x5370
leaq -0x30(%rbp), %rdi
callq 0x1bff0
movb %al, -0xf9(%rbp)
jmp 0x1be60
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x1be6f
jmp 0x1bf43
leaq 0x31e72(%rip), %rsi     # 0x4dce8
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x12d60
jmp 0x1be88
leaq 0x3229f(%rip), %rdx     # 0x4e12e
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x12d10
jmp 0x1bea1
leaq -0x88(%rbp), %rdi
callq 0x56c0
leaq -0x68(%rbp), %rdi
callq 0x5160
movq %rax, %rdi
leaq 0x564b0(%rip), %rax     # 0x72370
movl (%rax), %esi
callq 0xa6c0
jmp 0x1bec9
movl $0x1, -0x8c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x56c0
jmp 0x1bfb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x5370
jmp 0x1bfe6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1bfdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x56c0
jmp 0x1bfdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x56c0
jmp 0x1bfdd
movl -0xc(%rbp), %edx
leaq -0xe8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ad70
jmp 0x1bf58
leaq 0x564e1(%rip), %rdi     # 0x72440
leaq -0x30(%rbp), %rsi
callq 0x13a90
movq %rax, -0x108(%rbp)
jmp 0x1bf71
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
movq %rsi, -0x110(%rbp)
callq 0x1ce70
movq -0x110(%rbp), %rdi
callq 0x13fa0
leaq 0x564da(%rip), %rdi     # 0x72478
leaq -0x30(%rbp), %rsi
callq 0x5050
jmp 0x1bfa9
movl $0x0, -0x8c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x56c0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x13fa0
leaq -0x30(%rbp), %rdi
callq 0x56c0
movq -0x40(%rbp), %rdi
callq 0x5610
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x56439(%rip), %rdi     # 0x72440
callq 0x1cd30
cmpq $0x0, %rax
je 0x1c018
movb $0x1, -0x1(%rbp)
jmp 0x1c047
movslq 0x56479(%rip), %rsi     # 0x72498
leaq 0x56402(%rip), %rdi     # 0x72428
callq 0x13e00
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd60
cmpq $0x0, %rax
je 0x1c043
movb $0x1, -0x1(%rbp)
jmp 0x1c047
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::inc_blk()
void inc_blk()
{
	if (create)
	{
		blk_id++;
		var_stack.push_back(var_table_t());
	}
	create = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
testb $0x1, 0x56305(%rip)     # 0x72374
je 0x1c0d7
movl 0x56421(%rip), %eax     # 0x72498
incl %eax
movl %eax, 0x56419(%rip)     # 0x72498
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1cb50
movq -0x58(%rbp), %rsi
leaq 0x5637a(%rip), %rdi     # 0x72428
callq 0x1cb20
jmp 0x1c0b5
leaq -0x40(%rbp), %rdi
callq 0x1cb70
jmp 0x1c0d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1cb70
jmp 0x1c0e4
movb $0x1, 0x56296(%rip)     # 0x72374
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5610
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl 0x5639e(%rip), %eax     # 0x72498
addl $-0x1, %eax
movl %eax, 0x56395(%rip)     # 0x72498
cmpl $0x0, 0x5638e(%rip)     # 0x72498
jne 0x1c129
movl $0x0, 0x56386(%rip)     # 0x7249c
leaq 0x5635b(%rip), %rdi     # 0x72478
leaq 0x32b3c(%rip), %rsi     # 0x4ec60
callq 0x54b0
leaq 0x562f8(%rip), %rdi     # 0x72428
callq 0x1cd90
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl 0x55fc2(%rip), %eax     # 0x72498
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1c53c
movslq -0x1c(%rbp), %rsi
leaq 0x55f3e(%rip), %rdi     # 0x72428
callq 0x13e00
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd60
cmpq $0x0, %rax
je 0x1c52f
movslq -0x1c(%rbp), %rsi
leaq 0x55f1c(%rip), %rdi     # 0x72428
callq 0x13e00
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1cdc0
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0x1cdf0
movb $0x1, -0x1(%rbp)
jmp 0x1c540
jmp 0x1c531
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c4d9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0x55f36(%rip), %eax     # 0x72498
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1c5a0
movslq -0x14(%rbp), %rsi
leaq 0x55eb2(%rip), %rdi     # 0x72428
callq 0x13e00
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd60
cmpq $0x0, %rax
je 0x1c593
movb $0x1, -0x1(%rbp)
jmp 0x1c5a4
jmp 0x1c595
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c565
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x55e75(%rip), %rdi     # 0x72440
callq 0x1cd30
cmpq $0x0, %rax
jne 0x1c5dc
movb $0x0, -0x1(%rbp)
jmp 0x1c5fc
movq -0x10(%rbp), %rsi
leaq 0x55e59(%rip), %rdi     # 0x72440
callq 0x13a90
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0x1ced0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::check_main()
bool check_main()
{
	bool valid = true;
	func_entry query;
	if (!find_func("main", query))
	{
		yyerror("function 'main' should be defined");
		valid = false;
	}
	else if (query.ret_type != INT)
	{
		yyerror("function 'main' should return 'int'");
		valid = false;
	}
	else if (query.params.size() != 0)
	{
		yyerror("function 'main' should not have parameter");
		valid = false;
	}
	return valid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb $0x1, -0x1(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x13ac0
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5620
movq -0xa0(%rbp), %rdx
leaq 0x315ba(%rip), %rsi     # 0x4dc33
leaq -0x80(%rbp), %rdi
callq 0x8780
jmp 0x1c684
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c5b0
movb %al, -0xa1(%rbp)
jmp 0x1c699
movb -0xa1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa2(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x56c0
leaq -0x81(%rbp), %rdi
callq 0x5370
movb -0xa2(%rbp), %al
testb $0x1, %al
jne 0x1c6c8
jmp 0x1c73c
leaq 0x55ca1(%rip), %rax     # 0x72370
movl (%rax), %esi
leaq 0x31a70(%rip), %rdi     # 0x4e148
callq 0xa6c0
jmp 0x1c6df
movb $0x0, -0x1(%rbp)
jmp 0x1c791
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1c717
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x56c0
leaq -0x81(%rbp), %rdi
callq 0x5370
jmp 0x1c7b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1c7b4
cmpl $0x1, -0x10(%rbp)
je 0x1c75f
leaq 0x55c27(%rip), %rax     # 0x72370
movl (%rax), %esi
leaq 0x31a18(%rip), %rdi     # 0x4e16a
callq 0xa6c0
jmp 0x1c759
movb $0x0, -0x1(%rbp)
jmp 0x1c78f
leaq -0x60(%rbp), %rdi
addq $0x20, %rdi
callq 0x13be0
cmpq $0x0, %rax
je 0x1c78d
leaq 0x55bf7(%rip), %rax     # 0x72370
movl (%rax), %esi
leaq 0x31a0c(%rip), %rdi     # 0x4e18e
callq 0xa6c0
jmp 0x1c789
movb $0x0, -0x1(%rbp)
jmp 0x1c78f
jmp 0x1c791
movb -0x1(%rbp), %al
movb %al, -0xa3(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x13fa0
movb -0xa3(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x13fa0
movq -0x90(%rbp), %rdi
callq 0x5610
nopl (%rax)
// File: lhydave[P]SysYCompilerLab/back/eeyore_AST.cpp
// Function: eeyore_AST::build_AST(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void build_AST(const string &eeyore_code)
{
	eeyore_f = std::istringstream(eeyore_code);
	now_func = "";
	func_table.clear();
	label2stmt.clear();
	labels.clear();
	while (!params.empty())
		params.pop();
	// initialize global var_table
	func_table[""] = func_entry("", 0);
	// parseline!
	while (parseline())
		;
	dbg_printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movq %rdi, -0x268(%rbp)
movl $0x8, %edx
callq 0x55c0
movq -0x268(%rbp), %rsi
leaq 0x507df(%rip), %rdi     # 0x728d8
callq 0x5310
jmp 0x22100
leaq -0x188(%rbp), %rdi
callq 0x56b8
leaq 0x507a5(%rip), %rdi     # 0x728b8
leaq 0x2cb46(%rip), %rsi     # 0x4ec60
callq 0x54b0
leaq 0x5068a(%rip), %rdi     # 0x727b0
callq 0x24250
leaq 0x506ce(%rip), %rdi     # 0x72800
callq 0x24270
leaq 0x50712(%rip), %rdi     # 0x72850
callq 0x24290
leaq 0x5071e(%rip), %rdi     # 0x72868
callq 0x242b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x22157
jmp 0x22188
leaq 0x5070a(%rip), %rdi     # 0x72868
callq 0x242d0
jmp 0x22143
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x56b8
jmp 0x2230d
leaq -0x231(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x5620
movq -0x270(%rbp), %rdx
leaq 0x2cab7(%rip), %rsi     # 0x4ec60
leaq -0x230(%rbp), %rdi
callq 0x8780
jmp 0x221b7
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
xorl %edx, %edx
callq 0x242f0
jmp 0x221ce
leaq -0x259(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x5620
movq -0x278(%rbp), %rdx
leaq 0x2ca71(%rip), %rsi     # 0x4ec60
leaq -0x258(%rbp), %rdi
callq 0x8780
jmp 0x221fd
leaq 0x505ac(%rip), %rdi     # 0x727b0
leaq -0x258(%rbp), %rsi
callq 0x241f0
movq %rax, -0x280(%rbp)
jmp 0x22219
movq -0x280(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x24340
leaq -0x258(%rbp), %rdi
callq 0x56c0
leaq -0x259(%rbp), %rdi
callq 0x5370
leaq -0x210(%rbp), %rdi
callq 0x243a0
leaq -0x230(%rbp), %rdi
callq 0x56c0
leaq -0x231(%rbp), %rdi
callq 0x5370
callq 0x22320
testb $0x1, %al
jne 0x22276
jmp 0x22304
jmp 0x22268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x222f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x222ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x222d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x56c0
leaq -0x259(%rbp), %rdi
callq 0x5370
leaq -0x210(%rbp), %rdi
callq 0x243a0
leaq -0x230(%rbp), %rdi
callq 0x56c0
leaq -0x231(%rbp), %rdi
callq 0x5370
jmp 0x2230d
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x5610
nopl (%rax)
// File: lhydave[P]SysYCompilerLab/back/eeyore_AST.cpp
// Function: eeyore_AST::simple_label()
void simple_label()
{
	for (auto i : gotos)
		i->goto_label = label2stmt[i->goto_label]->label;
	gotos.clear();
	label2stmt.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x4f3e9(%rip), %rax     # 0x72838
movq %rax, -0x8(%rbp)
leaq 0x4f3de(%rip), %rdi     # 0x72838
callq 0x279e0
movq %rax, -0x10(%rbp)
leaq 0x4f3ce(%rip), %rdi     # 0x72838
callq 0x27a10
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27a40
testb $0x1, %al
jne 0x23489
jmp 0x23510
leaq -0x10(%rbp), %rdi
callq 0x27a80
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x27aa0
movq -0x48(%rbp), %rdi
callq 0x27ad0
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x4f347(%rip), %rdi     # 0x72800
callq 0x26f20
movq %rax, -0x40(%rbp)
jmp 0x234c4
movq -0x40(%rbp), %rdi
callq 0x26d80
movl 0x4(%rax), %eax
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x27ad0
movl -0x4c(%rbp), %ecx
movl %ecx, 0x8(%rax)
leaq -0x28(%rbp), %rdi
callq 0x26a80
leaq -0x10(%rbp), %rdi
callq 0x27af0
jmp 0x23473
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x26a80
jmp 0x2352e
leaq 0x4f321(%rip), %rdi     # 0x72838
callq 0x27b10
leaq 0x4f2dd(%rip), %rdi     # 0x72800
callq 0x24270
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5610
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x235d1
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x27df0
leaq 0x4f23d(%rip), %rdi     # 0x727b0
leaq 0x4f33e(%rip), %rsi     # 0x728b8
callq 0x26e40
movq %rax, -0x78(%rbp)
jmp 0x23585
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
callq 0x27e40
movq %rax, -0x80(%rbp)
jmp 0x2359c
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x27e70
leaq -0x38(%rbp), %rdi
callq 0x26140
jmp 0x23651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x26140
jmp 0x2365a
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x70(%rbp), %rdi
movl $0x1, %ecx
callq 0x27df0
leaq 0x4f1c3(%rip), %rdi     # 0x727b0
leaq 0x4f2c4(%rip), %rsi     # 0x728b8
callq 0x26e40
movq %rax, -0x88(%rbp)
jmp 0x23602
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
callq 0x27e40
movq %rax, -0x90(%rbp)
jmp 0x2361f
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x27e70
leaq -0x70(%rbp), %rdi
callq 0x26140
jmp 0x23651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x26140
jmp 0x2365a
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5610
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movl $0x8, %edx
callq 0x55c0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5390
movsbl (%rax), %edi
callq 0x5570
cmpl $0x0, %eax
jne 0x23738
leaq -0x190(%rbp), %rdi
leaq -0x194(%rbp), %rsi
callq 0x51f0
jmp 0x236d8
leaq -0x1b8(%rbp), %rdi
leaq -0x194(%rbp), %rsi
callq 0x2af40
jmp 0x236ed
movq -0x1e0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x2afb0
leaq -0x1b8(%rbp), %rdi
callq 0x2afe0
movl $0x1, -0x1bc(%rbp)
jmp 0x23773
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x56b8
jmp 0x2378f
movq -0x10(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x2b000
jmp 0x2374a
movq -0x1e0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x2b070
leaq -0x1d0(%rbp), %rdi
callq 0x2b0a0
movl $0x1, -0x1bc(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x56b8
movq -0x1d8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x5610
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41fc0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41ff0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41dc0
testb $0x1, %al
jne 0x3f7b1
jmp 0x3f7fe
leaq -0x20(%rbp), %rdi
callq 0x42020
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x41e20
testb $0x1, -0x2c(%rbp)
je 0x3f7de
movslq -0x30(%rbp), %rax
shrq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3f7ea
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x26110
leaq -0x20(%rbp), %rdi
callq 0x42050
jmp 0x3f79e
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/back/no_alloc.cpp
// Function: no_alloc::gen_ret(std::shared_ptr<eeyore_AST::ret_node> const&)
void gen_ret(const shared_ptr<ret_node> &stmt)
{
	if (stmt->ret_val)
	{
		auto reg = alloc_temp_reg(stmt->ret_val, 1);
		tigger_dst << emit_exp_assign(ret_reg, reg);
	}
	tigger_dst << emit_return();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42420
movq %rax, %rdi
addq $0x8, %rdi
callq 0x42370
testb $0x1, %al
jne 0x4021d
jmp 0x402a9
movq -0x8(%rbp), %rdi
callq 0x42420
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x1, %edx
callq 0x40a50
movq -0x80(%rbp), %rdx
leaq 0x32886(%rip), %rsi     # 0x72ad0
leaq -0x48(%rbp), %rdi
callq 0x34ea0
jmp 0x40255
leaq 0x3225c(%rip), %rdi     # 0x724b8
leaq -0x48(%rbp), %rsi
callq 0x52b0
jmp 0x40267
leaq -0x48(%rbp), %rdi
callq 0x56c0
leaq -0x28(%rbp), %rdi
callq 0x56c0
jmp 0x402a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4029e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x56c0
leaq -0x28(%rbp), %rdi
callq 0x56c0
jmp 0x402f5
leaq -0x78(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x354e0
movq -0x88(%rbp), %rsi
leaq 0x321f1(%rip), %rdi     # 0x724b8
callq 0x52b0
jmp 0x402ce
leaq -0x78(%rbp), %rdi
callq 0x56c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x56c0
movq -0x50(%rbp), %rdi
callq 0x5610
nop
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c700
movq %rax, %rdi
addq $0x50, %rdi
callq 0x2dba0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x403f1
movl -0x14(%rbp), %esi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x13410
movq -0xb8(%rbp), %rdx
leaq 0x32722(%rip), %rsi     # 0x72a90
leaq -0x38(%rbp), %rdi
callq 0x42130
jmp 0x40379
movq -0x8(%rbp), %rdi
callq 0x2c700
movq %rax, %rdi
addq $0x50, %rdi
movslq -0x14(%rbp), %rsi
callq 0x42440
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x404d0
jmp 0x403a0
leaq -0x38(%rbp), %rdi
callq 0x56c0
leaq -0x58(%rbp), %rdi
callq 0x56c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4031a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x403e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x56c0
leaq -0x58(%rbp), %rdi
callq 0x56c0
jmp 0x404c0
movq -0x8(%rbp), %rdi
callq 0x2c700
movq %rax, %rsi
addq $0x68, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x353f0
movq -0xc0(%rbp), %rsi
leaq 0x32096(%rip), %rdi     # 0x724b8
callq 0x52b0
jmp 0x40429
leaq -0x88(%rbp), %rdi
callq 0x56c0
movq -0x10(%rbp), %rdi
callq 0x55b0
testb $0x1, %al
jne 0x404b7
movq -0x10(%rbp), %rsi
leaq 0x32683(%rip), %rdx     # 0x72ad0
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x34ea0
movq -0xc8(%rbp), %rsi
leaq 0x3204a(%rip), %rdi     # 0x724b8
callq 0x52b0
jmp 0x40475
leaq -0xa8(%rbp), %rdi
callq 0x56c0
jmp 0x404b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x56c0
jmp 0x404c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x56c0
jmp 0x404c0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5610
nopl (%rax)
// File: lhydave[P]SysYCompilerLab/back/riscv/emit_riscv.cpp
// Function: riscv::emit_global_var(std::shared_ptr<tigger::global_var> const&)
void emit_global_var(const shared_ptr<tigger::global_var> &stmt)
{
	if (stmt->is_array) // array
		riscv_dst << "\t.comm " << stmt->name << ", " << stmt->size << ", 4\n";
	else // variable
	{
		auto f = [](const string &name, int val) {
			return "\t.global\t" + name +
				"\n\t.section\t.sdata\n\t.align\t2\n\t.type\t" + name +
				", @object\n\t.size\t" + name + ", 4\n" + name +
				":\n\t.word\t" + to_string(val) + "\n\n";
		};
		riscv_dst << f(stmt->name, stmt->val);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x48be0
testb $0x1, 0x28(%rax)
je 0x46054
leaq 0x2c63e(%rip), %rdi     # 0x72630
leaq 0x8b1b(%rip), %rsi      # 0x4eb14
callq 0x52f0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x48be0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x52b0
movq %rax, %rdi
leaq 0x8bd1(%rip), %rsi      # 0x4ebf6
callq 0x52f0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x48be0
movq -0x48(%rbp), %rdi
movl 0x2c(%rax), %esi
callq 0x55f0
movq %rax, %rdi
leaq 0x8acf(%rip), %rsi      # 0x4eb1c
callq 0x52f0
jmp 0x460ba
movq -0x8(%rbp), %rdi
callq 0x48be0
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0x48be0
movq -0x60(%rbp), %rdx
movl 0x30(%rax), %ecx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x9(%rbp), %rsi
callq 0x481a0
movq -0x58(%rbp), %rsi
leaq 0x2c59f(%rip), %rdi     # 0x72630
callq 0x52b0
jmp 0x46098
leaq -0x30(%rbp), %rdi
callq 0x56c0
jmp 0x460ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x56c0
jmp 0x460c0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5610
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x490e0
movl 0x28(%rax), %edi
callq 0x490b0
testb $0x1, %al
jne 0x478e3
jmp 0x47952
leaq 0x2ad46(%rip), %rdi     # 0x72630
leaq 0x7230(%rip), %rsi      # 0x4eb21
callq 0x52f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x490e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x52b0
movq %rax, %rdi
leaq 0x72d9(%rip), %rsi      # 0x4ebf6
callq 0x52f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x490e0
movq -0x10(%rbp), %rdi
movl 0x28(%rax), %esi
shll $0x2, %esi
callq 0x55f0
movq %rax, %rdi
leaq 0x72c8(%rip), %rsi      # 0x4ec10
callq 0x52f0
jmp 0x479e2
leaq 0x2acd7(%rip), %rdi     # 0x72630
leaq 0x7290(%rip), %rsi      # 0x4ebf0
callq 0x52f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x490e0
movq -0x28(%rbp), %rdi
movl 0x28(%rax), %esi
shll $0x2, %esi
callq 0x55f0
movq %rax, %rdi
leaq 0x62b5(%rip), %rsi      # 0x4dc40
callq 0x52f0
leaq 0x2ac99(%rip), %rdi     # 0x72630
leaq 0x7278(%rip), %rsi      # 0x4ec16
callq 0x52f0
leaq 0x2ac86(%rip), %rdi     # 0x72630
leaq 0x7170(%rip), %rsi      # 0x4eb21
callq 0x52f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x490e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x52b0
movq %rax, %rdi
leaq 0x72dd(%rip), %rsi      # 0x4ecba
callq 0x52f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49120
movq %rax, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x56a0
movsbl (%rax), %edi
callq 0x52c0
cmpl $0x0, %eax
je 0x47d83
movq -0x8(%rbp), %rdi
callq 0x49120
movq %rax, %rdi
addq $0x8, %rdi
callq 0x5160
movq %rax, %rdi
callq 0x5540
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x490b0
testb $0x1, %al
jne 0x47cb4
jmp 0x47d12
leaq 0x2a975(%rip), %rdi     # 0x72630
leaq 0x6f7c(%rip), %rsi      # 0x4ec3e
callq 0x52f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49120
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rsi
callq 0x52b0
movq %rax, %rdi
leaq 0x6f57(%rip), %rsi      # 0x4ec45
callq 0x52f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
shll $0x2, %esi
callq 0x55f0
movq %rax, %rdi
leaq 0x5f35(%rip), %rsi      # 0x4dc40
callq 0x52f0
jmp 0x47d81
leaq 0x2a917(%rip), %rdi     # 0x72630
leaq 0x6ed0(%rip), %rsi      # 0x4ebf0
callq 0x52f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
shll $0x2, %esi
callq 0x55f0
movq %rax, %rdi
leaq 0x5f03(%rip), %rsi      # 0x4dc40
callq 0x52f0
leaq 0x2a8e7(%rip), %rdi     # 0x72630
leaq 0x6efc(%rip), %rsi      # 0x4ec4c
callq 0x52f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49120
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rsi
callq 0x52b0
movq %rax, %rdi
leaq 0x6ed6(%rip), %rsi      # 0x4ec52
callq 0x52f0
jmp 0x47dee
leaq 0x2a8a6(%rip), %rdi     # 0x72630
leaq 0x6ecb(%rip), %rsi      # 0x4ec5c
callq 0x52f0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49120
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rsi
callq 0x52b0
movq %rax, %rdi
leaq 0x6e39(%rip), %rsi      # 0x4ebf6
callq 0x52f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49120
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x52b0
movq %rax, %rdi
leaq 0x5e57(%rip), %rsi      # 0x4dc40
callq 0x52f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x2638
movq -0x28(%rbp), %rax
leaq 0x1a96(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x1af9(%rip), %rsi      # 0x407b
callq 0x22b0
cmpl $0x0, %eax
jne 0x2596
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
jmp 0x2638
movq -0x10(%rbp), %rdi
leaq 0x1b09(%rip), %rsi      # 0x40af
callq 0x22b0
cmpl $0x0, %eax
jne 0x25ba
movq -0x20(%rbp), %rax
movl $0x3, (%rax)
jmp 0x2638
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x2290
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
jmp 0x2638
movq -0x10(%rbp), %rdi
leaq 0x1a9e(%rip), %rsi      # 0x4082
callq 0x22b0
cmpl $0x0, %eax
jne 0x25f8
movq -0x20(%rbp), %rax
movl $0x5, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x1a86(%rip), %rsi      # 0x4089
callq 0x22b0
cmpl $0x0, %eax
jne 0x2617
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x1a70(%rip), %rsi      # 0x4092
callq 0x22b0
cmpl $0x0, %eax
jne 0x2636
movq -0x20(%rbp), %rax
movl $0x7, (%rax)
jmp 0x2638
addq $0x30, %rsp
popq %rbp
retq
nop
// File: pstuifzand[P]magento-tools/src/magento-modules.cpp
// Function: character_data_handler(void*, char const*, int)
void character_data_handler(void* udata, const XML_Char* s, int len) {
    user_data* data = (user_data*)udata;
    switch (data->state) {
        case State::IN_ACTIVE:
        case State::IN_CODEPOOL:
            data->current_text.append(s, len);
            break;
        case State::IN_DEPENDS:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
addl $-0x5, %eax
subl $0x2, %eax
jb 0x28d8
jmp 0x28ce
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x28ef
jmp 0x28f1
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2050
jmp 0x28f1
jmp 0x28f1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x31c0
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x24f0
testb $0x1, %al
jne 0x2af0
jmp 0x2b12
leaq -0x18(%rbp), %rdi
callq 0x31e0
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2b03
jmp 0x2add
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3200
jmp 0x2add
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x12d0
movq -0x68(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x12f0
jmp 0x1262
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1340
movq -0x70(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x1370
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1320
jmp 0x128f
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x13a0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x13a0
movq -0x40(%rbp), %rdi
callq 0x10d0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0xb455c(%rip), %rcx     # 0xcf03b
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x19260
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x44(%rsp), %rdx
callq 0x18140
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x1ab67
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x18460
movl %eax, 0x54(%rsp)
jmp 0x1ac77
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x108(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq *%rax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x19210
cmpl $0x0, 0x2c(%rsp)
je 0x1abcf
movq 0x48(%rsp), %rdi
movl 0x2c(%rsp), %edx
xorl %esi, %esi
callq 0x18a00
movq 0x48(%rsp), %rdi
callq 0x19ad0
movl %eax, 0x54(%rsp)
jmp 0x1ac77
jmp 0x1abd1
jmp 0x1abd3
movq 0xe23be(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x1abf2
movq 0x20(%rsp), %rsi
leaq 0xb4462(%rip), %rdi     # 0xcf04d
movb $0x0, %al
callq 0x189d0
jmp 0x1abf4
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0xb43fb(%rip), %rdx     # 0xcf000
xorl %ecx, %ecx
callq 0x18350
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rax
leaq 0x75(%rip), %rcx        # 0x1acc0
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xb435d(%rip), %rsi     # 0xcf065
callq 0x18fa0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18dc0
cmpl $0x0, %eax
jne 0x1ad2b
movl $0x0, 0x34(%rsp)
jmp 0x1ad7c
jmp 0x1ad2d
movq 0xe2264(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x1ad4c
movq 0x18(%rsp), %rsi
leaq 0xb4337(%rip), %rdi     # 0xcf07c
movb $0x0, %al
callq 0x189d0
jmp 0x1ad4e
movq 0x10(%rsp), %rdi
callq 0x19fd0
movq 0x50(%rax), %rax
movq 0x110(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x18dc0
cmpl $0x0, %eax
jne 0x1b259
movl $0x0, 0x34(%rsp)
jmp 0x1b299
jmp 0x1b25b
movq 0xe1d36(%rip), %rax     # 0xfcf98
cmpl $0x0, (%rax)
je 0x1b27a
movq 0x18(%rsp), %rsi
leaq 0xb3e65(%rip), %rdi     # 0xcf0d8
movb $0x0, %al
callq 0x189d0
jmp 0x1b27c
movq (%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *%rax
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb461a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1e, %esi
movl $0x2, %edx
callq 0x19d20
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xb45fd(%rip), %rcx     # 0xcf923
callq 0x1a640
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2d0(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq (%rsp), %rdx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb458a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x193e0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x1b419
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x1b468
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2d8(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x30(%rsp), %edx
movq 0x10(%rsp), %rcx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x18, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xb446a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x19190
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x30(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x1a5b0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x1b539
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x10, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x186d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x18460
movl %eax, 0x44(%rsp)
jmp 0x1b588
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2e0(%rax), %rax
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x30(%rsp), %edx
movq 0x10(%rsp), %rcx
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x30(%rsp), %ecx
movl $0x10, %edx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x18dd0
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb434a(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movsd 0xb3b1d(%rip), %xmm0    # 0xcf0f8
callq 0x18990
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2e8(%rax), %rax
movq 0x10(%rsp), %rdi
movss 0xc(%rsp), %xmm0
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0xb42da(%rip), %rcx     # 0xcf909
callq 0x1a640
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x4, %esi
callq 0x188a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x2f0(%rax), %rax
movq 0x10(%rsp), %rdi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
movss 0x4(%rsp), %xmm2
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)