LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::str2num(char const*, int)
int str2num(const char *s, int base)
{
	int len = strlen(s);
	int val = 0;
	for (int i = 0; i < len; i++)
	{
		if (s[i] >= '0' && s[i] <= '9')
			val = val * base + (s[i] - '0');
		else if (s[i] >= 'a' && s[i] <= 'f')
			val = val * base + (s[i] - 'a') + 10;
		else if (s[i] >= 'A' && s[i] <= 'F')
			val = val * base + (s[i] - 'A') + 10;
		else
			return -1;
	}
	return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x5110
testl %eax, %eax
jle 0x81b8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
movb (%r14,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x8186
imull %ebx, %ecx
movzbl %dil, %esi
addl %esi, %ecx
jmp 0x81ae
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x8198
imull %ebx, %ecx
movzbl %dil, %esi
jmp 0x81a9
addb $-0x41, %sil
cmpb $0x5, %sil
ja 0x81bc
imull %ebx, %ecx
movzbl %sil, %esi
addl %esi, %ecx
addl $0xa, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x816e
jmp 0x81c1
xorl %ecx, %ecx
jmp 0x81c1
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::vardef_node::set_shape(sysY_AST::exp_node*)
void vardef_node::set_shape(exp_node *first_dim)
{
	size = 1;
	if (is_pt)
		dim.push_back(0);
	while (first_dim)
	{
		first_dim->reduce();
		size_t temp = first_dim->num;
		if (first_dim->exp_type != EXP_NUM || first_dim->num <= 0)
		{
			yyerror("array size in delaration must be a positive constant int");
			temp = 1;
		}
		size *= temp;
		dim.push_back(temp);
		first_dim = first_dim->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, 0xa4(%rdi)
cmpb $0x1, 0xa0(%rdi)
jne 0x868f
movl $0x0, 0x4(%rsp)
movq 0x78(%r14), %rsi
cmpq 0x80(%r14), %rsi
je 0x8681
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x78(%r14)
jmp 0x868f
leaq 0x70(%r14), %rdi
leaq 0x4(%rsp), %rdx
callq 0x1294e
testq %rbx, %rbx
je 0x871a
leaq 0x70(%r14), %r15
leaq 0x2cc0d(%rip), %rbp     # 0x352b0
leaq 0x2027e(%rip), %r12     # 0x28928
movq %rsp, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
cmpl $0x2, 0x98(%rbx)
jne 0x86c9
movl 0x94(%rbx), %eax
testl %eax, %eax
jg 0x86d9
movl (%rbp), %esi
movq %r12, %rdi
callq 0x8030
movl $0x1, %eax
movl 0xa4(%r14), %ecx
imull %eax, %ecx
movl %ecx, 0xa4(%r14)
movl %eax, (%rsp)
movq 0x78(%r14), %rsi
cmpq 0x80(%r14), %rsi
je 0x8706
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x78(%r14)
jmp 0x8711
movq %r15, %rdi
movq %r13, %rdx
callq 0x1294e
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x86ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::funcdef_node::funcdef_node(char const*, sysY_AST::data_t, sysY_AST::node_basic*)
funcdef_node::funcdef_node(
	const char *_name, data_t _ret_type, node_basic *_blk)
{
	blk = _blk;
	name = string(_name);
	dbg_printf("def a func named %s\n", _name);
	ret_type = _ret_type;
	add_ret(blk != nullptr);
	gen_code();
	temp_id = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %r12, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
leaq 0x2b5da(%rip), %rdx     # 0x352b0
movl (%rdx), %edx
movl %edx, 0x38(%rdi)
leaq 0x2a736(%rip), %rdx     # 0x34418
movq %rdx, (%rdi)
leaq 0x40(%rdi), %r14
leaq 0x50(%rdi), %r13
movq %r13, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
movq %rcx, 0x68(%rdi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6d4c
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5310
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9d40
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movl %ebp, 0x60(%rbx)
xorl %esi, %esi
cmpq $0x0, 0x68(%rbx)
setne %sil
movq %rbx, %rdi
callq 0x9dd2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl $0x0, 0x2b5e0(%rip)     # 0x35348
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9d79
movq %rax, %r15
leaq 0x70(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9d97
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x5240
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x9dab
movq (%r13), %rsi
incq %rsi
callq 0x5240
leaq 0x2a85e(%rip), %rax     # 0x34610
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r12, %rdi
je 0x9dca
movq (%r12), %rsi
incq %rsi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::funcdef_node::add_ret(bool)
void funcdef_node::add_ret(bool is_append)
{
	dbg_printf("add ret is_append: %d\n", is_append);
	now_func_name = name;
	auto has_ret_val = (func_table[name].ret_type == INT);
	ret_stmt_node *ret_stmt;
	if (has_ret_val)
		ret_stmt = new ret_stmt_node(new exp_node(EXP_NUM, "", 0));
	else
		ret_stmt = new ret_stmt_node(nullptr);
	if (is_append)
		blk->code += ret_stmt->code;
	else
		blk = ret_stmt;
	now_func_name = "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x2b5c8(%rip), %r14     # 0x353b8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5140
leaq 0x2b57e(%rip), %rdi     # 0x35380
movq %rbx, %rsi
callq 0x1313a
movl 0x50(%rax), %r12d
movl $0x48, %edi
callq 0x5220
movq %rax, %rbx
cmpl $0x1, %r12d
jne 0x9e94
movl $0xa0, %edi
callq 0x5220
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1faf3(%rip), %rdx     # 0x29931
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x6d8a
movb $0x1, %r13b
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe1ee
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdd6e
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9e9e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0x9e9e
movq %rbx, %rdi
xorl %esi, %esi
callq 0xdd6e
testb %bpl, %bpl
je 0x9eba
movq 0x68(%r15), %rdi
addq $0x18, %rdi
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
callq 0x50c0
jmp 0x9ebe
movq %rbx, 0x68(%r15)
movq 0x8(%r14), %rdx
leaq 0x1fa68(%rip), %rcx     # 0x29931
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x53f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x9f15
jmp 0x9eec
movq %rax, %r14
jmp 0x9f22
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9f10
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
testb %r13b, %r13b
je 0x9f22
movl $0xa0, %esi
movq %r12, %rdi
callq 0x5240
movl $0x48, %esi
movq %rbx, %rdi
callq 0x5240
movq %r14, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::stmt_node::stmt_node(sysY_AST::node_basic*)
stmt_node::stmt_node(node_basic *_child)
{
	child = _child;
	if (blk_id == 1) // in the function
		last_stmt = this;
	gen_code();
	dbg_printf("create a stmt_node...\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq %r15, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq 0x2a0f1(%rip), %rax     # 0x352b0
movl (%rax), %eax
movl %eax, 0x38(%rdi)
leaq 0x2926d(%rip), %rax     # 0x34438
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x2a1ff(%rip), %rax     # 0x353d8
cmpl $0x1, (%rax)
jne 0xb1e5
movq %rbx, 0x2a16b(%rip)     # 0x35350
testq %rsi, %rsi
je 0xb1fe
leaq 0x18(%rbx), %rdi
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rdx
movq %rax, %rsi
callq 0x50c0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x29402(%rip), %rax     # 0x34610
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xb225
movq (%r15), %rsi
incq %rsi
callq 0x5240
movq %r14, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::assign_stmt_node::assign_stmt_node(sysY_AST::exp_node*, sysY_AST::exp_node*)
assign_stmt_node::assign_stmt_node(exp_node *_lval, exp_node *_assign_exp)
{
	lval = _lval;
	assign_exp = _assign_exp;
	if (lval->exp_type != EXP_ARRAY && lval->exp_type != EXP_VAR)
		yyerror("expression is not assignable");

	assign_exp->reduce();
	if (lval->exp_type == EXP_ARRAY)
		assign_exp->new_temp();
	gen_code();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
movq %r15, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq 0x2a02c(%rip), %rsi     # 0x352b0
movl (%rsi), %esi
movl %esi, 0x38(%rdi)
leaq 0x291a8(%rip), %rdi     # 0x34438
movq %rdi, (%rbx)
movq %rcx, 0x10(%rbx)
leaq 0x2a13a(%rip), %rcx     # 0x353d8
cmpl $0x1, (%rcx)
jne 0xb2aa
movq %rbx, 0x2a0a6(%rip)     # 0x35350
leaq 0x291af(%rip), %rcx     # 0x34460
movq %rcx, (%rbx)
movq %rax, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movl 0x98(%rax), %eax
cmpl $0x1, %eax
je 0xb2dc
cmpl $0x4, %eax
je 0xb2dc
leaq 0x1d742(%rip), %rdi     # 0x28a15
callq 0x8030
movq 0x48(%rbx), %rdx
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x18(%rax)
movq 0x40(%rbx), %rax
cmpl $0x4, 0x98(%rax)
jne 0xb2fc
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x292fc(%rip), %rax     # 0x34610
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq %r15, %rdi
je 0xb32b
movq (%r15), %rsi
incq %rsi
callq 0x5240
movq %r14, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::exp_stmt_node::gen_code()
void exp_stmt_node::gen_code()
{
	if (exp_stmt->exp_type == EXP_FUNC_CALL)
	{
		auto func_exp_stmt = static_cast<func_call_exp_node *>(exp_stmt);
		func_entry query;
		find_func(func_exp_stmt->sysy_func_name, query);
		if (query.ret_type == INT)
		{
			exp_stmt->new_temp();
			code = exp_stmt->code;
		}
		else
		{
			code = exp_stmt->code;
			code += "\t" + exp_stmt->eeyore_name + "\n";
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rdi
cmpl $0x3, 0x98(%rdi)
jne 0xb7b0
leaq 0x58(%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, %rdi
leaq 0x48(%rsp), %rsi
callq 0x152f6
cmpl $0x1, 0x98(%rsp)
movq 0x40(%r14), %rsi
jne 0xb6c0
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq 0x40(%r14), %rsi
addq $0x18, %rsi
addq $0x18, %r14
movq %r14, %rdi
callq 0x5140
jmp 0xb77d
addq $0x18, %rsi
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
callq 0x5140
movq 0x40(%r14), %rdx
addq $0x70, %rdx
leaq 0x1e251(%rip), %rsi     # 0x29930
leaq 0x28(%rsp), %rdi
callq 0x11c02
leaq 0x1d323(%rip), %rsi     # 0x28a13
leaq 0x28(%rsp), %rdi
callq 0x5510
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xb721
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xb72b
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x50c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb762
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb77d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x68(%rsp), %rbx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x12144
movq %rbx, %rdi
callq 0x12144
movq -0x38(%r14), %rdi
cmpq %r15, %rdi
je 0xb7b0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5240
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xb7dc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xb7dc
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb7fe
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xb7fe
jmp 0xb7fb
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x11f70
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::if_stmt_node::update(sysY_AST::cond_exp_node*, sysY_AST::node_basic*, sysY_AST::node_basic*)
void if_stmt_node::update(
	cond_exp_node *_cond, node_basic *_true_stmt, node_basic *_false_stmt)
{
	cond = _cond;
	true_stmt = _true_stmt;
	false_stmt = _false_stmt;
	has_else = (false_stmt != nullptr);
	if (!has_else)
	{
		cond->true_label = true_label = fall_label;
		cond->false_label = false_label = new_label();
	}
	else
	{
		cond->true_label = true_label = new_label();
		cond->false_label = false_label = new_label();
	}
	cond->traverse();
	gen_code();
	fall_label = old_fall_label;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
testq %rcx, %rcx
setne 0x64(%rdi)
je 0xb899
movl 0x29ac7(%rip), %ecx     # 0x35358
leal 0x1(%rcx), %eax
leal 0x2(%rcx), %edx
jmp 0xb8a8
movl 0x29abd(%rip), %ecx     # 0x3535c
movl 0x29ab3(%rip), %eax     # 0x35358
leal 0x1(%rax), %edx
movl %ecx, 0x58(%rbx)
movl %ecx, 0xb0(%rsi)
movl %edx, 0x29aa1(%rip)     # 0x35358
movl %eax, 0x5c(%rbx)
movl %eax, 0xb4(%rsi)
movq %rsi, %rdi
callq 0xb8dc
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl 0x60(%rbx), %eax
movl %eax, 0x29a83(%rip)     # 0x3535c
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::while_stmt_node::update(sysY_AST::cond_exp_node*, sysY_AST::node_basic*, sysY_AST::node_basic*)
void while_stmt_node::update(
	cond_exp_node *_cond, node_basic *_true_stmt, node_basic *_next_stmt)
{
	cond = _cond;
	true_stmt = _true_stmt;
	cond->true_label = true_label = fall_label;
	cond->false_label = while_next_label;
	cond->traverse();
	gen_code();
	fall_label = old_fall_label;
	while_start_label = old_start_label;
	while_next_label = old_next_label;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
movl 0x28172(%rip), %eax     # 0x3535c
movl %eax, 0x50(%rdi)
movl %eax, 0xb0(%rsi)
movl 0x2816b(%rip), %eax     # 0x35364
movl %eax, 0xb4(%rsi)
movq %rsi, %rdi
callq 0xb8dc
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl 0x54(%rbx), %eax
movl %eax, 0x28144(%rip)     # 0x3535c
movl 0x5c(%rbx), %eax
movl %eax, 0x2813f(%rip)     # 0x35360
movl 0x58(%rbx), %eax
movl %eax, 0x2813a(%rip)     # 0x35364
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe12d
addq $0x18, %rsi
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
callq 0x5140
movq 0x40(%r14), %rdx
addq $0x70, %rdx
leaq 0x1a9b9(%rip), %rsi     # 0x28aa3
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x11c02
leaq 0x1a915(%rip), %rsi     # 0x28a13
movq %r14, %rdi
callq 0x5510
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xe147
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xe151
addq $0x18, %r14
leaq 0x1a974(%rip), %rsi     # 0x28aac
movq %r14, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0x5510
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x50c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe188
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe1a3
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 0xe1ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xe1ca
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe1e5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5240
movq %rbx, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 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 0x27084(%rip), %rcx     # 0x352b0
movl (%rcx), %ecx
movl %ecx, 0x38(%rdi)
leaq 0x26318(%rip), %rcx     # 0x34550
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 0xe2cf
movq (%r13), %rsi
incq %rsi
callq 0x5240
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0xe2e9
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
leaq 0x26320(%rip), %rax     # 0x34610
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0xe30e
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7c0
movq (%rax), %rbp
subq %rax, %rbx
sarq $0x3, %rbx
cmpq $0x2, %rbx
jb 0xf81b
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 0x1a215(%rip), %rdx     # 0x29931
movq %rdx, %rsi
callq 0x6d8a
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 0xe1ee
movq 0x8(%rsp), %rdi
movq %r14, %r15
cmpq %r14, %rdi
je 0xf761
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 0xf8a2
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 0xf8a2
incq %r13
cmpq %r13, %rbx
movq %r15, %r14
leaq 0x8(%rsp), %r15
jne 0xf700
jmp 0xf81b
movl $0xa0, %edi
callq 0x5220
movq %rax, %rbp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a154(%rip), %rdx     # 0x29931
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x6d8a
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xe1ee
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xf81b
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 0xf84c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xf84c
movq %rax, %r15
movl $0xa0, %esi
jmp 0xf891
movq %rax, %r15
jmp 0xf872
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xf872
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movl $0xa0, %esi
movq %r12, %rdi
jmp 0xf894
movq %rax, %r15
movl $0xb0, %esi
movq %r14, %rdi
jmp 0xf894
movq %rax, %r15
movl $0xb0, %esi
movq %rbp, %rdi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a067(%rip), %rdx     # 0x29931
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x6d8a
movq %rsp, %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0xe1ee
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xf900
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x24ca9(%rip), %rax     # 0x345b0
movq %rax, (%rbx)
movq %r14, 0xa0(%rbx)
movq %r15, 0xa8(%rbx)
cmpb $0x0, 0x25a25(%rip)     # 0x35344
jne 0xf946
cmpl $0xf, 0x90(%rbx)
jne 0xf946
leaq 0x2597f(%rip), %rax     # 0x352b0
movl (%rax), %esi
leaq 0x191da(%rip), %rdi     # 0x28b14
callq 0x8030
movq 0xa0(%rbx), %r14
cmpl $0x6, 0x98(%r14)
je 0xf965
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0xf97a
cmpl $0x6, 0x98(%rax)
jne 0xf97a
leaq 0x25944(%rip), %rax     # 0x352b0
movl (%rax), %esi
leaq 0x191d7(%rip), %rdi     # 0x28b4c
callq 0x8030
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 0x11fa0
jmp 0xf9bb
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xf9bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0xf9bb
movq %rax, %r14
movq %r14, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11332
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 0x152f6
cmpl $0x1, 0xb0(%rsp)
je 0x112fc
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x17817(%rip), %rsi     # 0x28a46
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0x11c02
leaq 0x179e2(%rip), %rsi     # 0x28c25
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 0x11275
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
jmp 0x1127d
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 0x112b9
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x112d4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5240
movq (%rsp), %rdi
leaq 0x23fd1(%rip), %rax     # 0x352b0
movl (%rax), %esi
callq 0x8030
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x112fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
leaq 0x80(%rsp), %rbx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x12144
movq %rbx, %rdi
callq 0x12144
movq -0x38(%r14), %rdi
cmpq %r15, %rdi
je 0x11332
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 0x11364
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0x11364
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1137f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
jmp 0x1137f
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x11f70
movq %rbx, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x154f8
movq %rbp, %rdi
movq %r15, %rsi
callq 0x154f8
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 0x1369c
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x5240
movq (%r12), %rdi
testq %rdi, %rdi
je 0x136b1
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x5240
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0x136cb
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x136e5
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5240
movq %r15, %rdi
callq 0x54c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x207bf(%rip), %rdi     # 0x35380
movq %rbx, %rsi
callq 0x1620c
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x14bf3
movslq 0x207fe(%rip), %rax     # 0x353d8
imulq $0x38, %rax, %rdi
addq 0x20783(%rip), %rdi     # 0x35368
movq %rbx, %rsi
callq 0x16246
testq %rax, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20761(%rip)           # 0x353d8
jne 0x14ca7
pushq %rax
movl $0x0, 0x20758(%rip)     # 0x353dc
movq 0x20735(%rip), %rdx     # 0x353c0
leaq 0x20726(%rip), %rdi     # 0x353b8
leaq 0x14c98(%rip), %rcx     # 0x29931
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x53f0
addq $0x8, %rsp
movq 0x206c2(%rip), %rdi     # 0x35370
addq $-0x38, %rdi
movq %rdi, 0x206b7(%rip)     # 0x35370
jmp 0x156a6
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq 0x201d1(%rip), %r12     # 0x353d8
testq %r12, %r12
js 0x15239
movq %rsi, %rbx
movq %rdi, %r14
imulq $0x38, %r12, %r15
incq %r12
movq 0x20148(%rip), %rdi     # 0x35368
addq %r15, %rdi
movq %r14, %rsi
callq 0x16246
testq %rax, %rax
jne 0x1523d
addq $-0x38, %r15
decq %r12
jg 0x15219
xorl %eax, %eax
jmp 0x1529c
addq 0x20124(%rip), %r15     # 0x35368
movq %r15, %rdi
movq %r14, %rsi
callq 0x16348
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 0x154f8
addq $0x60, %rbx
addq $0x60, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154f8
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movslq 0x20124(%rip), %r14     # 0x353d8
testq %r14, %r14
js 0x152ee
movq %rdi, %rbx
imulq $0x38, %r14, %r15
movq 0x200a1(%rip), %rdi     # 0x35368
addq %r15, %rdi
movq %rbx, %rsi
callq 0x16246
movq %rax, %rcx
testq %rax, %rax
setne %al
testq %r14, %r14
jle 0x152f0
decq %r14
addq $-0x38, %r15
testq %rcx, %rcx
je 0x152c0
jmp 0x152f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20078(%rip), %rdi     # 0x35380
movq %r15, %rsi
callq 0x1620c
movq %rax, %r14
testq %rax, %rax
je 0x15356
leaq 0x20061(%rip), %rdi     # 0x35380
movq %r15, %rsi
callq 0x1313a
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5140
leaq 0x20(%rbx), %rdi
leaq 0x20(%r15), %rsi
callq 0x157c2
leaq 0x38(%rbx), %rdi
leaq 0x38(%r15), %rsi
callq 0x157c2
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_O3/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 0x17cfc
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 0x121f8
movl %ebp, 0x20(%r14)
movb $0x1, 0x24(%r14)
leaq 0x1da11(%rip), %rdi     # 0x356f0
leaq 0x1db12(%rip), %rsi     # 0x357f8
callq 0x1a682
addq $0x20, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18dca
jmp 0x17d4b
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 0x121f8
movl $0x4, 0x20(%r14)
movb $0x0, 0x24(%r14)
leaq 0x1d9c0(%rip), %rdi     # 0x356f0
leaq 0x1dac1(%rip), %rsi     # 0x357f8
callq 0x1a682
addq $0x20, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18dca
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 0x17d87
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17d96
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x17db0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5240
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/back/eeyore_AST.cpp
// Function: eeyore_AST::parse_var_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static shared_ptr<op_node> parse_var_num(const string &s)
{
	std::istringstream s_f(s);
	if (!isalpha(s[0]))
	{
		int val;
		s_f >> val;
		return make_shared<num_node>(val);
	}
	return make_shared<var_node>(s);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movl $0x8, %edx
callq 0x5480
movq (%r14), %rax
movsbl (%rax), %edi
callq 0x5440
testl %eax, %eax
je 0x17e07
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rcx
callq 0x19880
jmp 0x17e37
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5160
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x196ac
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x1d182(%rip), %rsi     # 0x34fc8
leaq 0x28(%rsp), %rdi
callq 0x5390
leaq 0xa0(%rsp), %rdi
callq 0x50d0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x17e6c
jmp 0x17e6c
movq %rax, %rbx
movq 0x1d152(%rip), %rsi     # 0x34fc8
leaq 0x28(%rsp), %rdi
callq 0x5390
leaq 0xa0(%rsp), %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f7a4
leaq 0x10(%rsp), %r13
movq %rsp, %r14
movl $0x1, %ebp
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x22910
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 0x1f783
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5240
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1f799
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5240
addq %r12, %rbx
movq (%r15), %r15
testq %r15, %r15
jne 0x1f749
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_O3/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 0xf63c(%rip), %r14      # 0x35570
cmpl $0x3ff, %ecx            # imm = 0x3FF
ja 0x25f9c
leaq 0x38af(%rip), %rsi      # 0x297f2
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 0x395a(%rip), %rsi      # 0x298c7
movl $0x2, %edx
movq %rax, %rdi
callq 0x52a0
movq (%rbx), %rax
movl 0x28(%rax), %esi
shll $0x2, %esi
movq %r14, %rdi
callq 0x54a0
leaq 0x394f(%rip), %rsi      # 0x298e1
movl $0x5, %edx
jmp 0x2601c
leaq 0x391e(%rip), %rsi      # 0x298c1
movl $0x8, %edx
movq %r14, %rdi
callq 0x52a0
movq (%rbx), %rax
movl 0x28(%rax), %esi
shll $0x2, %esi
movq %r14, %rdi
callq 0x54a0
leaq 0x2a4b(%rip), %rsi      # 0x28a13
movl $0x1, %edx
movq %rax, %rdi
callq 0x52a0
leaq 0x390b(%rip), %rsi      # 0x298e7
movl $0x10, %edx
movq %r14, %rdi
callq 0x52a0
leaq 0x3802(%rip), %rsi      # 0x297f2
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 0x3974(%rip), %rsi      # 0x2998b
movl $0x8, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x262d3
callq 0x5410
movl %eax, %r14d
leal 0x200(%r14), %eax
leaq 0xf2f7(%rip), %r15      # 0x35570
cmpl $0x3ff, %eax            # imm = 0x3FF
ja 0x26339
leaq 0x3684(%rip), %rsi      # 0x2990f
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 0x3661(%rip), %rsi      # 0x29916
movl $0x6, %edx
movq %rax, %rdi
callq 0x52a0
shll $0x2, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x54a0
jmp 0x2632b
leaq 0xf296(%rip), %r14      # 0x35570
leaq 0x364c(%rip), %rsi      # 0x2992d
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 0x35bc(%rip), %rsi      # 0x298c7
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 0x26e1(%rip), %rsi      # 0x28a13
movl $0x1, %edx
jmp 0x263a3
leaq 0x3581(%rip), %rsi      # 0x298c1
movl $0x8, %edx
movq %r15, %rdi
callq 0x52a0
shll $0x2, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x54a0
leaq 0x26b0(%rip), %rsi      # 0x28a13
movl $0x1, %edx
movq %rax, %rdi
callq 0x52a0
leaq 0x35a6(%rip), %rsi      # 0x2991d
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 0x3585(%rip), %rsi      # 0x29923
movl $0x9, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x52a0
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rdi), %rdi
callq 0x21d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2874
leaq 0x8(%rsp), %r15
cmpb $0x2e, 0x13(%rax)
je 0x2862
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a0a
movq (%r14), %rdi
callq 0x21d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x2851
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x9(%rbp), %rdx
xorl %esi, %esi
callq 0x1246
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x121d
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 0x123e
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x1060
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x71788(%rip), %rcx     # 0x8c03b
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x1a4e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191b0
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 0x1a928
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1a9d3
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 0x19160
testl %ebp, %ebp
je 0x1a96f
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
jmp 0x1a9d3
movq 0xa5652(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x1a98d
movq (%rsp), %rsi
leaq 0x716c7(%rip), %rdi     # 0x8c04d
xorl %eax, %eax
callq 0x18960
movq (%rsp), %rsi
leaq 0x71668(%rip), %rdx     # 0x8c000
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18320
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r14, 0x20(%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
leaq 0x53(%rip), %rdx        # 0x1aa11
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_O3/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 0x71633(%rip), %rsi     # 0x8c065
movq %r12, %rdx
callq 0x18ef0
movq %r13, %rdi
movq %r12, %rsi
callq 0x18d20
testl %eax, %eax
je 0x1aa81
movq 0xa5578(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x1aa66
leaq 0x71620(%rip), %rdi     # 0x8c07c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x18960
movq %r15, %rdi
callq 0x19e90
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_O3/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 0x713e9(%rip), %rcx     # 0x8c000
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x1a4e0
movq %rax, %r13
movq (%r14), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x191b0
movq %rax, %r15
leaq 0x14(%rsp), %rbp
movq %rbx, %rdi
movl $0x2, %esi
movq %rbp, %rdx
callq 0x19950
movq %rax, %r12
cmpl $0x0, (%rbp)
je 0x1ac93
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19160
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x18680
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x18410
jmp 0x1ad54
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 0x19160
testl %ebp, %ebp
je 0x1ace0
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x18980
movq %rbx, %rdi
callq 0x199a0
jmp 0x1ad54
movq 0xa52e1(%rip), %rax     # 0xbffc8
cmpl $0x0, (%rax)
je 0x1acff
movq 0x8(%rsp), %rsi
leaq 0x713c3(%rip), %rdi     # 0x8c0bb
xorl %eax, %eax
callq 0x18960
movq 0x8(%rsp), %rsi
leaq 0x7135a(%rip), %rdx     # 0x8c065
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x18320
movq %rax, %rbx
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r14, 0x20(%rbx)
movq %r14, %rdi
callq 0x19e90
movq 0x18(%rax), %rax
movq %rax, 0x18(%rbx)
movq %r15, 0x40(%rbx)
leaq 0x53(%rip), %rax        # 0x1ad92
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