LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::sort_symbol()
void xbytes::sort_symbol()
{
	symbol_array terminals;
	symbol_array nonterminals;

	for(int i = 0; i < symbols.size(); ++i)
	{
		symbol* s = symbols[i];
		if(s->type == ST_TERMINAL) 
			terminals.push_back(s);
		else
			nonterminals.push_back(s);
	}
	for(int i = 0; i < terminals.size(); ++i)
	{
		symbols[i] = terminals[i];
		symbols[i]->index = i;
	}
	for(int i = 0; i < nonterminals.size(); ++i)
	{
		int index = terminals.size() + i;
		symbols[index] = nonterminals[i];
		symbols[index]->index = index;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movq %rax, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0x4f38
leaq -0x38(%rbp), %r12
xorl %r13d, %r13d
leaq -0x40(%rbp), %r14
leaq -0x60(%rbp), %r15
movq (%rax,%r13,8), %rax
movq %rax, -0x68(%rbp)
cmpl $0x1, 0x48(%rax)
jne 0x4f07
movq -0x38(%rbp), %rsi
movq %r14, %rdi
movq %r12, %rcx
cmpq -0x30(%rbp), %rsi
je 0x4f18
movq %rax, (%rsi)
addq $0x8, (%rcx)
jmp 0x4f21
movq -0x58(%rbp), %rsi
movq %r15, %rdi
leaq -0x58(%rbp), %rcx
cmpq -0x50(%rbp), %rsi
jne 0x4efe
leaq -0x68(%rbp), %rdx
callq 0xb024
incq %r13
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x4ee0
movq -0x40(%rbp), %rcx
cmpq %rcx, -0x38(%rbp)
je 0x4f71
xorl %eax, %eax
movq (%rcx,%rax,8), %rcx
movq 0x8(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movl %eax, (%rcx)
incq %rax
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
ja 0x4f44
movq -0x60(%rbp), %rdi
cmpq %rdi, -0x58(%rbp)
je 0x4fbb
xorl %eax, %eax
movq -0x38(%rbp), %rcx
subq -0x40(%rbp), %rcx
shrq $0x3, %rcx
addl %eax, %ecx
movq (%rdi,%rax,8), %rdx
movslq %ecx, %rcx
movq 0x8(%rbx), %rsi
movq %rdx, (%rsi,%rcx,8)
movq 0x8(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
movl %ecx, (%rdx)
incq %rax
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
ja 0x4f7d
testq %rdi, %rdi
je 0x4fcc
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x3260
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4fe1
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x3260
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x5008
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x3260
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3420
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_symbol_precedence()
void xbytes::find_symbol_precedence()
{
	//make symbol's precedence & associativity
	for(int i = 0; i < assoc_precs.size(); ++i)
	{
		int ass = assoc_precs[i].associativity;
		string_array& sa = assoc_precs[i].symbol_names;
		for(int m = 0; m < sa.size(); ++m)
		{
			symbol* s = find_symbol(sa[m]);
			if(s)
			{
				s->associativity = ass;
				s->precedence = i;
			}
		}
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x698(%rdi), %rax
movq 0x6a0(%rdi), %rcx
movq %rax, -0x30(%rbp)
subq %rax, %rcx
je 0x50bd
movq %rdi, %rbx
movq %rcx, %rax
sarq $0x5, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x5, %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx,%rax), %r12
movq 0x8(%rcx,%rax), %r14
subq %r14, %r12
je 0x50b4
movq -0x30(%rbp), %rcx
movl (%rcx,%rax), %r15d
sarq $0x5, %r12
cmpq $0x1, %r12
adcq $0x0, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7cec
testq %rax, %rax
je 0x50ab
movl %r15d, 0xa4(%rax)
movl %r13d, 0xa0(%rax)
addq $0x20, %r14
decq %r12
jne 0x508d
incq %r13
cmpq -0x38(%rbp), %r13
jne 0x505f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_rule_precedence()
void xbytes::find_rule_precedence()
{


	//make rule's precedence
	for(int i = 0; i < rules.size(); ++i)
	{
		rule* r = rules[i];
		if(r->precedence_symbol != NULL) continue;

		for(int m = 0; m < r->rights.size() && r->precedence_symbol == NULL; ++m)
		{
			symbol* s = r->rights[m];
			if(s->type != ST_TERMINAL) continue;
			
			if(s->precedence >= 0)
			{
				r->precedence_symbol = s;
				break;
			}
		}
	}
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq %rax, %rcx
je 0x5175
pushq %rbp
movq %rsp, %rbp
pushq %rbx
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
cmpq $0x0, 0xa0(%rsi)
je 0x5108
incq %rdx
cmpq %rcx, %rdx
jne 0x50f0
jmp 0x5173
movq 0x30(%rsi), %rdi
movq 0x38(%rsi), %r8
subq %rdi, %r8
je 0x50fe
sarq $0x3, %r8
movq 0xa0(%rsi), %r9
cmpq $0x1, %r8
adcq $0x0, %r8
xorl %r10d, %r10d
testq %r9, %r9
jne 0x50fe
movq (%rdi,%r10,8), %rbx
movl $0x7, %r11d
cmpl $0x1, 0x48(%rbx)
jne 0x515e
cmpl $0x0, 0xa0(%rbx)
js 0x515b
movq %rbx, 0xa0(%rsi)
movl $0x5, %r11d
movq %rbx, %r9
jmp 0x515e
xorl %r11d, %r11d
cmpl $0x7, %r11d
je 0x5169
testl %r11d, %r11d
jne 0x50fe
incq %r10
cmpq %r10, %r8
jne 0x512b
jmp 0x50fe
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_nullable()
void xbytes::find_nullable()
{
	for(int i = 0; i < symbols.size(); ++i)
	{
		symbols[i]->is_nullable = false;
	}

	while(true)
	{
		bool is_change = false;
		for(int i = 0; i < rules.size(); ++i)
		{
			rule* r = rules[i];
			if(r->left->is_nullable) continue;
			if(r->rights.size() == 0)
			{
				r->left->is_nullable = true;
				is_change = true;
				continue;
			}

			bool is_all_nullable = true;
			for(int j = 0; j < r->rights.size(); ++j)
			{
				if(!r->rights[j]->is_nullable)
				{
					is_all_nullable = false;
					break;
				}
			}

			if(is_all_nullable)
			{
				r->left->is_nullable = true;
				is_change = true;
			}
		}

		if(!is_change) break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
je 0x51a6
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movb $0x0, 0x68(%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0x5196
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
cmpq %rax, %rcx
je 0x5228
xorl %esi, %esi
xorl %edi, %edi
movq (%rax,%rsi,8), %r10
movq 0x8(%r10), %r8
cmpb $0x0, 0x68(%r8)
jne 0x520e
movq 0x30(%r10), %r9
movq 0x38(%r10), %r10
subq %r9, %r10
je 0x5206
sarq $0x3, %r10
cmpq $0x1, %r10
adcq $0x0, %r10
xorl %r11d, %r11d
movq (%r9,%r11,8), %rbx
cmpb $0x0, 0x68(%rbx)
je 0x520e
incq %r11
cmpq %r11, %r10
jne 0x51f4
movb $0x1, 0x68(%r8)
movb $0x1, %dil
incq %rsi
cmpq %rdx, %rsi
jne 0x51c9
cmpq %rax, %rcx
je 0x5228
xorl %esi, %esi
testb $0x1, %dil
movl $0x0, %edi
jne 0x51c9
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_first_set()
void xbytes::find_first_set()
{
	for(int i = 0; i < symbols.size(); ++i)
	{
		if(symbols[i]->type == ST_TERMINAL)
		{
			symbols[i]->first_set.push_back(symbols[i]);
		}
	}

	while(true)
	{
		int change_count = 0;
		for(int i = 0; i < rules.size(); ++i)
		{
			rule* r = rules[i];
			if(r->rights.size() == 0) continue;

			change_count += merge_symbol_set(r->left->first_set, r->rights[0]->first_set);
			for(int j = 0; j < r->rights.size() - 1; ++j)
			{
				if(!r->rights[j]->is_nullable) break;
				change_count += merge_symbol_set(r->left->first_set, r->rights[j+1]->first_set);
			}
		}

		if(!change_count) break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
cmpq %rdx, 0x10(%rdi)
je 0x5342
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rdx,%r14), %rdi
cmpl $0x1, 0x48(%rdi)
jne 0x527e
movq 0x78(%rdi), %rsi
cmpq 0x80(%rdi), %rsi
je 0x5272
movq %rdi, (%rsi)
addq $0x8, 0x78(%rdi)
jmp 0x527e
addq %r14, %rdx
addq $0x70, %rdi
callq 0xb024
incq %r15
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
addq $0x8, %r14
cmpq %r15, %rax
ja 0x5251
jmp 0x5342
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rax,%r14,8), %r12
movq 0x30(%r12), %rax
cmpq %rax, 0x38(%r12)
je 0x5322
movq 0x8(%r12), %rsi
addq $0x70, %rsi
movq (%rax), %rdx
addq $0x70, %rdx
callq 0x6c10
addl %eax, %r15d
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
je 0x5322
xorl %r13d, %r13d
movq (%rax,%r13,8), %rcx
cmpb $0x1, 0x68(%rcx)
jne 0x5322
movq 0x8(%r12), %rsi
addq $0x70, %rsi
movq 0x8(%rax,%r13,8), %rdx
incq %r13
addq $0x70, %rdx
callq 0x6c10
addl %eax, %r15d
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
decq %rcx
cmpq %r13, %rcx
ja 0x52e2
incq %r14
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x52a4
testl %r15d, %r15d
je 0x5350
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
jne 0x529e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_lr_state()
void xbytes::find_lr_state()
{
	//set first state
	make_first_state();

	//set follow state and goto
	while(true)
	{
		int change_count = 0;

		for(int i = 0; i < states.size(); ++i)
		{
			lr_state* ls = states[i];
			if(ls->is_completed) continue;
			for(int j = 0; j < ls->terms.size(); ++j)
			{
				term* t = ls->terms[j];
				if(t->dot >= t->r->rights.size()) continue;

				symbol* s = t->r->rights[t->dot];
				if(s->name == ACCEPT_TERMINAL) continue;

				lr_state ns = lr_goto(*ls, s);
				change_count += add_lr_state(ns);
				change_count += add_lr_goto(*ls, s, ns.state);		
			}
			if(!change_count) ls->is_completed = true;
		}

		if(!change_count) break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rsi
leaq -0x120(%rbp), %rdi
movq %rsi, -0x30(%rbp)
callq 0x6cf2
leaq -0xd0(%rbp), %rdi
callq 0xa644
leaq -0x100(%rbp), %r14
movq %r14, %rdi
callq 0xa6d4
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x55fe
movq -0x108(%rbp), %rsi
subq %rdi, %rsi
callq 0x3260
movq -0x30(%rbp), %rcx
movq 0x38(%rcx), %rax
cmpq %rax, 0x40(%rcx)
je 0x573e
xorl %edx, %edx
xorl %r15d, %r15d
movq (%rax,%rdx,8), %r14
cmpb $0x0, 0x68(%r14)
jne 0x5716
movq %rdx, -0x40(%rbp)
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x5708
xorl %ebx, %ebx
movq (%rax,%rbx,8), %rcx
movslq 0x8(%rcx), %rax
movq (%rcx), %rdx
movq 0x30(%rdx), %rcx
movq 0x38(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x56ed
movq (%rcx,%rax,8), %r12
leaq 0x8(%r12), %rdi
leaq 0x7b2e(%rip), %rsi      # 0xd199
callq 0x30a0
testl %eax, %eax
je 0x56ed
movl %r15d, -0x34(%rbp)
leaq -0xb0(%rbp), %r13
movq %r13, %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x6dac
movq %r15, %rdi
movq %r13, %rsi
callq 0x6f0c
movl %eax, %r15d
movl -0xb0(%rbp), %ecx
movq %r14, %rsi
movq %r12, %rdx
callq 0x7088
movl %eax, %r12d
leaq -0x60(%rbp), %rdi
callq 0xa644
leaq -0x90(%rbp), %rdi
callq 0xa6d4
movq -0xa8(%rbp), %rdi
testq %rdi, %rdi
je 0x56e6
movq -0x98(%rbp), %rsi
subq %rdi, %rsi
callq 0x3260
addl -0x34(%rbp), %r15d
addl %r12d, %r15d
incq %rbx
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
ja 0x5638
testl %r15d, %r15d
jne 0x5712
movb $0x1, 0x68(%r14)
movq -0x40(%rbp), %rdx
incq %rdx
movq -0x30(%rbp), %rcx
movq 0x38(%rcx), %rax
movq 0x40(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rdx, %rcx
ja 0x5615
testl %r15d, %r15d
jne 0x55fe
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0xa0ba
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::merge_symbol_set(std::vector<xbytes::symbol*, std::allocator<xbytes::symbol*>>&, std::vector<xbytes::symbol*, std::allocator<xbytes::symbol*>>&)
int xbytes::merge_symbol_set(symbol_array& s1, symbol_array& s2)
{
	int insert_count = 0;
	for(int i = 0; i < s2.size(); ++i)
	{
		bool is_add = true;
		for(int j = 0; j < s1.size(); ++j)
		{
			if(s2[i] == s1[j])
			{
				is_add = false;
				break;
			}
		}
		if(is_add)
		{
			insert_count++;
			s1.push_back(s2[i]);
		}
	}

	return insert_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x6c9a
movq %rdx, %rbx
movq %rsi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq (%r14), %rcx
movq 0x8(%r14), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
je 0x6c60
sarq $0x3, %rdx
movq (%rax,%r12,8), %rdi
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r8d, %r8d
cmpq (%rcx,%r8,8), %rdi
je 0x6c82
incq %r8
cmpq %r8, %rdx
jne 0x6c52
incl %r15d
leaq (%rax,%r12,8), %rdx
cmpq 0x10(%r14), %rsi
je 0x6c7a
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x6c82
movq %r14, %rdi
callq 0xb024
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x6c30
jmp 0x6c9d
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::make_first_state()
lr_state xbytes::make_first_state()
{
	lr_state start_state;
	start_state.state = 0;

	term* t = new term();
	t->r = start;
	t->dot = 0;

	start_state.terms.push_back(t);

	closure(start_state);

	add_lr_state(start_state);

	return start_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x28(%rdi), %rcx
movl %eax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movl %eax, (%rdi)
movl $0x30, %edi
callq 0x3250
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rax, -0x18(%rbp)
movq (%r14), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x6d6a
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x6d77
leaq 0x8(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0xb164
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f0c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa0ba
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::lr_goto(xbytes::lr_state&, xbytes::symbol*)
lr_state xbytes::lr_goto(lr_state& state, symbol* s)
{
	lr_state next_state;
	for(int i = 0; i < state.terms.size(); ++i)
	{
		term* t = state.terms[i];
		assert(t->r != NULL);
		if(t->dot >= t->r->rights.size()) continue;
		if(t->r->rights[t->dot] == s)
		{
			term tt;
			tt.r = t->r;
			tt.dot = t->dot + 1;
			tt.forwards = t->forwards;
			add_term(next_state, tt);
		}
	}

	closure(next_state);
	return next_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x28(%rdi), %rcx
movl $0x0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movq 0x8(%rdx), %rax
cmpq %rax, 0x10(%rdx)
je 0x6ea2
movq %rdx, %r12
leaq -0x50(%rbp), %r13
xorl %r14d, %r14d
movq (%rax,%r14,8), %rsi
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x6ec0
movslq 0x8(%rsi), %rax
movq 0x30(%rdx), %rcx
movq 0x38(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x6e85
cmpq %r15, (%rcx,%rax,8)
jne 0x6e85
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq (%rsi), %rax
movq %rax, -0x60(%rbp)
movl 0x8(%rsi), %eax
incl %eax
movl %eax, -0x58(%rbp)
addq $0x10, %rsi
movq %r13, %rdi
callq 0xa1b4
movq %rbx, %rsi
leaq -0x60(%rbp), %rdx
callq 0x759a
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x6e85
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x3260
incq %r14
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x6e0b
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x70f8
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x62d4(%rip), %rdi      # 0xd19b
leaq 0x62da(%rip), %rsi      # 0xd1a8
leaq 0x62de(%rip), %rcx      # 0xd1b3
movl $0x20e, %edx            # imm = 0x20E
callq 0x3150
movq %rax, %r14
jmp 0x6efc
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x6efc
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x3260
movq %rbx, %rdi
callq 0xa0ba
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::add_lr_state(xbytes::lr_state&)
int xbytes::add_lr_state(lr_state& s)
{
	for(int i = 0; i < states.size(); ++i)
	{
		lr_state& ls = *(states[i]);
		if(is_merge_lr_state(ls, s))
		{
			s.state = states[i]->state;
			if(is_same_lr_state(ls, s)) return 0;
			return merge_lr_state(ls, s);
		}
	}

	s.state = states.size();

	lr_state* ls = new lr_state();
	*ls = s;
	ls->is_completed = false;
	states.push_back(ls);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x38(%rdi), %rax
cmpq %rax, 0x40(%rdi)
setne %r15b
movq %rdi, -0x38(%rbp)
je 0x6f9f
xorl %r14d, %r14d
movq (%rax,%r14,8), %r13
movq %r13, %rsi
movq %rbx, %rdx
callq 0x73ac
movl %eax, %r12d
testb %al, %al
je 0x6f79
movl (%r13), %eax
movl %eax, (%rbx)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x742c
movl $0x0, -0x2c(%rbp)
testb %al, %al
jne 0x6f79
movq %r13, %rsi
movq %rbx, %rdx
callq 0x74bc
movl %eax, -0x2c(%rbp)
testb %r12b, %r12b
jne 0x6fa1
incq %r14
movq -0x38(%rbp), %rdi
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
seta %r15b
ja 0x6f35
jmp 0x6fa5
jmp 0x6fa5
movq -0x38(%rbp), %rdi
testb $0x1, %r15b
movl -0x2c(%rbp), %eax
jne 0x7079
movq 0x40(%rdi), %r14
subq 0x38(%rdi), %r14
shrq $0x3, %r14
movl %r14d, (%rbx)
movl $0x70, %edi
callq 0x3250
movq %rax, %r15
leaq 0x8(%rax), %rdi
addq $0x28, %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x50(%r15)
movaps %xmm0, 0x60(%r15)
movaps %xmm0, (%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, 0x20(%r15)
leaq 0x50(%r15), %r12
leaq 0x20(%r15), %r13
movq %rax, 0x38(%r15)
movq %rax, 0x40(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x58(%r15)
movq %r15, -0x40(%rbp)
movl %r14d, (%r15)
leaq 0x8(%rbx), %rsi
callq 0xa732
leaq 0x20(%rbx), %rsi
movq %r13, %rdi
callq 0xa9ae
leaq 0x50(%rbx), %rsi
movq %r12, %rdi
movq -0x38(%rbp), %r14
callq 0xa812
movb 0x68(%rbx), %al
movb %al, 0x68(%r15)
movq -0x40(%rbp), %rax
movb $0x0, 0x68(%rax)
movq 0x40(%r14), %rsi
cmpq 0x48(%r14), %rsi
je 0x7064
movq %rax, (%rsi)
addq $0x8, 0x40(%r14)
jmp 0x7074
addq $0x38, %r14
leaq -0x40(%rbp), %rdx
movq %r14, %rdi
callq 0xb286
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::is_same_lr_state(xbytes::lr_state&, xbytes::lr_state&)
bool xbytes::is_same_lr_state(lr_state& l, lr_state& r)
{
	if(l.terms.size() != r.terms.size()) return false;
	
	for(int i = 0; i < l.terms.size(); ++i)
	{
		if(!is_same_term(*(l.terms[i]), *(r.terms[i]))) return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rax
movq %rax, %r15
subq %r14, %r15
movq 0x8(%rdx), %r12
movq 0x10(%rdx), %rcx
subq %r12, %rcx
cmpq %rcx, %r15
jne 0x74a9
cmpq %r14, %rax
sete %bl
je 0x74ab
sarq $0x3, %r15
cmpq $0x1, %r15
movq %r15, %r13
adcq $0x0, %r13
movq (%r14), %rsi
movq (%r12), %rdx
callq 0x7522
testb %al, %al
je 0x74ab
movl $0x1, %ecx
movq %rcx, %rbx
cmpq %rcx, %r13
je 0x74a1
movq (%r14,%rbx,8), %rsi
movq (%r12,%rbx,8), %rdx
callq 0x7522
leaq 0x1(%rbx), %rcx
testb %al, %al
jne 0x7484
cmpq %rbx, %r15
setbe %bl
jmp 0x74ab
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::merge_lr_state(xbytes::lr_state&, xbytes::lr_state&)
int xbytes::merge_lr_state(lr_state& l, lr_state& r)
{
	int cc = 0;
	for(int i = 0; i < l.terms.size(); ++i)
	{
		term* lt = l.terms[i];
		term* rt = r.terms[i];

		cc += merge_symbol_set(lt->forwards, rt->forwards);
	}

	return cc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rsi), %rax
cmpq %rax, 0x10(%rsi)
je 0x7512
movq %rdx, %rbx
movq %rsi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq (%rax,%r12,8), %rsi
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
addq $0x10, %rsi
addq $0x10, %rdx
callq 0x6c10
addl %eax, %r15d
incq %r12
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x74dd
jmp 0x7515
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::is_same_term(xbytes::term&, xbytes::term&)
bool xbytes::is_same_term(term& l, term& r)
{
	if(l.r != r.r || l.dot != r.dot || l.forwards.size() != r.forwards.size()) return false;
	for(int i = 0; i < l.forwards.size(); ++i)
	{
		if(l.forwards[i] != r.forwards[i]) return false;
	}
	return true;
}

// Assembly:
movq (%rsi), %rax
cmpq (%rdx), %rax
jne 0x7597
movl 0x8(%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0x7597
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rax
movq %rax, %rsi
subq %rcx, %rsi
movq 0x10(%rdx), %rdi
movq 0x18(%rdx), %rdx
subq %rdi, %rdx
cmpq %rdx, %rsi
jne 0x7597
cmpq %rcx, %rax
sete %al
je 0x7596
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rsi
cmpq $0x1, %rsi
movq %rsi, %rdx
adcq $0x0, %rdx
movq (%rcx), %r8
cmpq (%rdi), %r8
jne 0x7595
movl $0x1, %r8d
movq %r8, %rax
cmpq %r8, %rdx
je 0x758f
movq (%rcx,%rax,8), %r9
leaq 0x1(%rax), %r8
cmpq (%rdi,%rax,8), %r9
je 0x7579
cmpq %rax, %rsi
setbe %al
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::add_term(xbytes::lr_state&, xbytes::term&)
int xbytes::add_term(lr_state& s, term& tt)
{	
	for(int i = 0; i < s.terms.size(); ++i)
	{
		//完全一样则返回
		term& t = *(s.terms[i]);
		if(is_same_term(t, tt)) return 0;

		//如果是向前看符号集不一样则合并向前看符号集
		if(t.r == tt.r && t.dot == tt.dot)
		{
			return merge_symbol_set(t.forwards, tt.forwards);
		}
	}

	term* t = new term();
	*t = tt;
	t->is_completed = false;
	s.terms.push_back(t);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x10(%rsi)
setne %r15b
je 0x764f
leaq 0x10(%rdx), %rax
movq %rax, -0x40(%rbp)
xorl %r13d, %r13d
movq %r12, -0x30(%rbp)
movq (%rcx,%r13,8), %r12
movq %r12, %rsi
movq %rdx, %rbx
callq 0x7522
movq %rbx, %rdx
movl %eax, %ecx
movl $0x0, %esi
movl $0x0, %eax
testb %cl, %cl
jne 0x7624
movq (%r12), %rax
movb $0x1, %sil
cmpq (%rdx), %rax
je 0x7602
movl %r14d, %eax
jmp 0x7624
movl 0x8(%r12), %ecx
movl %r14d, %eax
cmpl 0x8(%rdx), %ecx
jne 0x7624
addq $0x10, %r12
movq %r12, %rsi
movq -0x40(%rbp), %rdx
callq 0x6c10
movq %rbx, %rdx
xorl %esi, %esi
testb %sil, %sil
je 0x7651
incq %r13
movq -0x30(%rbp), %r12
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movl %eax, %r14d
cmpq %r13, %rsi
seta %r15b
ja 0x75cf
jmp 0x7655
jmp 0x7655
movq -0x30(%rbp), %r12
testb $0x1, %r15b
jne 0x76d6
movq %rdx, %rbx
movl $0x30, %edi
callq 0x3250
movq %rax, %r15
leaq 0x10(%rax), %rdi
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rax)
movups %xmm0, 0x1c(%rax)
movl $0x0, 0x2c(%rax)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r15)
movq (%rbx), %rax
movq %rax, (%r15)
leaq 0x10(%rbx), %rsi
callq 0xa1b4
movb 0x28(%rbx), %al
movb %al, 0x28(%r15)
movq -0x38(%rbp), %rax
movb $0x0, 0x28(%rax)
movq 0x10(%r12), %rsi
cmpq 0x18(%r12), %rsi
je 0x76c1
movq %rax, (%rsi)
addq $0x8, 0x10(%r12)
jmp 0x76d1
addq $0x8, %r12
leaq -0x38(%rbp), %rdx
movq %r12, %rdi
callq 0xb164
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::make_symbol(xbytes::rule&, xbytes::symbol&)
void xbytes::make_symbol(rule& r, symbol& s)
{
	if(s.name.size() == 0) return;

	//add to symbol table
	symbol* ss = find_symbol(s.name);
	if(ss == NULL)
	{
		ss = new symbol();
		ss->index = symbols.size();
		ss->name = s.name;
		ss->alias = s.alias;
		ss->type = ss->name[0] >= 'a' && ss->name[0] <= 'z' ? ST_NONTERMINAL : ST_TERMINAL;
		ss->precedence = -1;
		ss->associativity = AT_NONE;
		symbols.push_back(ss);
	}
	assert(ss != NULL);

	//attach to rule
	if(r.left == NULL)
	{
		r.left = ss;
		r.left_alias = s.alias;
	}
	else
	{
		r.rights.push_back(ss);
		r.right_alias.push_back(s.alias);
	}

	//clear symbol
	s.name.clear();
	s.alias.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdx)
je 0x79e3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdx), %r12
movq %r12, %rsi
callq 0x7cec
movq %rax, -0x30(%rbp)
testq %rax, %rax
jne 0x7976
movl $0xa8, %edi
callq 0x3250
leaq 0x8(%rax), %rdi
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
xorl %r13d, %r13d
movq %r13, 0x10(%rax)
movb %r13b, 0x18(%rax)
leaq 0x38(%rax), %rcx
movq %rcx, 0x28(%rax)
movq %r13, 0x30(%rax)
movb %r13b, 0x38(%rax)
movl %r13d, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movq %r13, 0x60(%rax)
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x80(%rax)
movups %xmm0, 0x90(%rax)
movq %rax, -0x30(%rbp)
movq 0x10(%r15), %rcx
subq 0x8(%r15), %rcx
shrq $0x3, %rcx
movl %ecx, (%rax)
movq %r12, %rsi
callq 0x3120
leaq 0x28(%rbx), %rsi
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x3120
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movb (%rcx), %cl
addb $-0x61, %cl
cmpb $0x1a, %cl
adcl $0x1, %r13d
movl %r13d, 0x48(%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0xa0(%rax)
movq 0x10(%r15), %rsi
cmpq 0x18(%r15), %rsi
je 0x7966
movq %rax, (%rsi)
addq $0x8, 0x10(%r15)
jmp 0x7976
addq $0x8, %r15
leaq -0x30(%rbp), %rdx
movq %r15, %rdi
callq 0xb024
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x79f2
cmpq $0x0, 0x8(%r14)
je 0x799a
movq 0x38(%r14), %rsi
cmpq 0x40(%r14), %rsi
je 0x79b0
movq %rax, (%rsi)
addq $0x8, 0x38(%r14)
jmp 0x79bd
movq %rax, 0x8(%r14)
leaq 0x28(%rbx), %rsi
addq $0x10, %r14
movq %r14, %rdi
callq 0x3120
jmp 0x79cd
leaq 0x30(%r14), %rdi
leaq -0x30(%rbp), %rdx
callq 0xb024
addq $0x48, %r14
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xa320
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rcx
movb %al, (%rcx)
movq %rax, 0x30(%rbx)
movq 0x28(%rbx), %rcx
movb %al, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5af0(%rip), %rdi      # 0xd4e9
leaq 0x57a8(%rip), %rsi      # 0xd1a8
leaq 0x5aed(%rip), %rcx      # 0xd4f4
movl $0x45a, %edx            # imm = 0x45A
callq 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
symbol* xbytes::find_symbol(const string& name)
{
	for(int i = 0; i < symbols.size(); ++i)
	{
		if(symbols[i]->name == name)
		{
			return symbols[i];
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
subq %r15, %r12
je 0x7d4b
sarq $0x3, %r12
movq (%rsi), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rsi), %r13
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %ebx, %ebx
movq (%r15,%rbx,8), %r14
movq 0x10(%r14), %rdx
cmpq %r13, %rdx
jne 0x7d43
testq %rdx, %rdx
je 0x7d4e
movq 0x8(%r14), %rdi
movq -0x30(%rbp), %rsi
callq 0x3270
testl %eax, %eax
je 0x7d4e
incq %rbx
cmpq %rbx, %r12
jne 0x7d20
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::dump()
void xbytes::dump()
{
	dump_symbol();
	dump_rule();
	dump_first_set();
	dump_follow_set();
	dump_lr_state();
	dump_action_table();
	dump_associativity();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x80b6
movq %rbx, %rdi
callq 0x8436
movq %rbx, %rdi
callq 0x857a
movq %rbx, %rdi
callq 0x8724
movq %rbx, %rdi
callq 0x88da
movq %rbx, %rdi
callq 0x8d64
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x91a0
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::dump_rule()
void xbytes::dump_rule()
{
	std::cout << "==============RULE============" << std::endl;
	for(int i = 0; i < rules.size(); ++i)
	{	
		std::cout << i << ": " << rules[i]->str_rule;

		if(rules[i]->code.size() > 0)
		{
			std::cout << "	[" << rules[i]->code << "].";
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8b8a(%rip), %r14      # 0x10fd8
leaq 0x51fc(%rip), %rsi      # 0xd651
movl $0x1e, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x856b
xorl %r15d, %r15d
leaq 0x50f7(%rip), %r12      # 0xd598
movq %r14, %rdi
movl %r15d, %esi
callq 0x33b0
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32b0
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x80(%rax), %rsi
movq 0x88(%rax), %rdx
movq %r13, %rdi
callq 0x32b0
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpq $0x0, 0x68(%rax)
je 0x852c
movl $0x2, %edx
movq %r14, %rdi
leaq 0x5175(%rip), %rsi      # 0xd670
callq 0x32b0
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x60(%rax), %rsi
movq 0x68(%rax), %rdx
movq %r14, %rdi
callq 0x32b0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x514c(%rip), %rsi      # 0xd673
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
incq %r15
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
sarq $0x3, %rax
cmpq %r15, %rax
ja 0x84a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::dump_first_set()
void xbytes::dump_first_set()
{
	std::cout << "==============FIRST SET============" << std::endl;
	for(int i = 0; i < symbols.size(); ++i)
	{
		symbol* s = symbols[i];
		if(s->type == ST_TERMINAL) continue;

		std::cout << s->name << "[";
		for(int j = 0; j < s->first_set.size(); ++j)
		{
			std::cout << s->first_set[j]->name << ",";
		}
		std::cout << "]" << std::endl;
	}
	std::cout << std::endl << std::endl;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8a46(%rip), %rbx      # 0x10fd8
leaq 0x50dd(%rip), %rsi      # 0xd676
movl $0x23, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x86c5
xorl %r15d, %r15d
leaq 0x5232(%rip), %r13      # 0xd817
movq %r14, -0x30(%rbp)
movq (%rax,%r15,8), %r12
cmpl $0x1, 0x48(%r12)
je 0x86aa
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x32b0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x5057(%rip), %rsi      # 0xd671
callq 0x32b0
movq 0x70(%r12), %rax
cmpq %rax, 0x78(%r12)
je 0x866b
xorl %r14d, %r14d
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x32b0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x32b0
incq %r14
movq 0x70(%r12), %rax
movq 0x78(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x862e
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x4f5e(%rip), %rsi      # 0xd5d8
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq -0x30(%rbp), %r14
incq %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x85e9
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::dump_follow_set()
void xbytes::dump_follow_set()
{
	std::cout << "==============FOLLOW SET============" << std::endl;
	for(int i = 0; i < symbols.size(); ++i)
	{
		symbol* s = symbols[i];
		if(s->type == ST_TERMINAL) continue;

		std::cout << s->name << "[";
		for(int j = 0; j < s->follow_set.size(); ++j)
		{
			std::cout << s->follow_set[j]->name << ",";
		}
		std::cout << "]" << std::endl;
	}
	std::cout << std::endl << std::endl;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x889c(%rip), %rbx      # 0x10fd8
leaq 0x4f57(%rip), %rsi      # 0xd69a
movl $0x24, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x887b
xorl %r15d, %r15d
leaq 0x5088(%rip), %r13      # 0xd817
movq %r14, -0x30(%rbp)
movq (%rax,%r15,8), %r12
cmpl $0x1, 0x48(%r12)
je 0x8860
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x32b0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4ead(%rip), %rsi      # 0xd671
callq 0x32b0
movq 0x88(%r12), %rax
cmpq %rax, 0x90(%r12)
je 0x8821
xorl %r14d, %r14d
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x32b0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x32b0
incq %r14
movq 0x88(%r12), %rax
movq 0x90(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x87de
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x4da8(%rip), %rsi      # 0xd5d8
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq -0x30(%rbp), %r14
incq %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x8793
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::dump_associativity()
void xbytes::dump_associativity()
{
	std::cout << "==============ASSOCIATIVITY============" << std::endl;
	for(int i = 0; i < assoc_precs.size(); ++i)
	{
		std::cout << "precedence=" << i;
		if(assoc_precs[i].associativity == AT_LEFT)
		{
			std::cout << " LEFT<< ";
		}
		else if(assoc_precs[i].associativity == AT_RIGHT)
		{
			std::cout << " RIGHT<< ";
		}
		else
		{
			std::cout << " ERROR<< ";
		}
		for(int m = 0; m < assoc_precs[i].symbol_names.size(); ++m)
		{
			std::cout << assoc_precs[i].symbol_names[m] << " ";
		}
		std::cout << ">>" << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x7e1d(%rip), %rbx      # 0x10fd8
leaq 0x45b1(%rip), %rsi      # 0xd773
movl $0x27, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x6a0(%r14), %rax
cmpq 0x698(%r14), %rax
je 0x935a
xorl %r12d, %r12d
movq %r14, -0x30(%rbp)
movl $0xb, %edx
movq %rbx, %rdi
leaq 0x457b(%rip), %rsi      # 0xd79b
callq 0x32b0
movq %rbx, %rdi
movl %r12d, %esi
callq 0x33b0
movq 0x698(%r14), %rax
movq %r12, %r15
shlq $0x5, %r15
movl (%rax,%r15), %eax
cmpl $0x2, %eax
movq %r12, -0x38(%rbp)
je 0x9261
cmpl $0x1, %eax
jne 0x9272
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x4548(%rip), %rsi      # 0xd7a7
jmp 0x9281
movl $0x9, %edx
movq %rbx, %rdi
leaq 0x4540(%rip), %rsi      # 0xd7b0
jmp 0x9281
movl $0x9, %edx
movq %rbx, %rdi
leaq 0x4539(%rip), %rsi      # 0xd7ba
callq 0x32b0
movq 0x698(%r14), %rcx
movq 0x8(%rcx,%r15), %rax
cmpq %rax, 0x10(%rcx,%r15)
leaq 0x4337(%rip), %r14      # 0xd5d5
movq 0x7d33(%rip), %rbx      # 0x10fd8
je 0x92f9
movl $0x8, %r13d
xorl %r12d, %r12d
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x32b0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x32b0
incq %r12
movq -0x30(%rbp), %rax
movq 0x698(%rax), %rcx
movq 0x8(%rcx,%r15), %rax
movq 0x10(%rcx,%r15), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %r12, %rcx
ja 0x92b0
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x44bc(%rip), %rsi      # 0xd7c4
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq -0x38(%rbp), %r12
incq %r12
movq -0x30(%rbp), %r14
movq 0x6a0(%r14), %rax
subq 0x698(%r14), %rax
sarq $0x5, %rax
cmpq %r12, %rax
ja 0x9211
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::output_declare_symbol(std::basic_ofstream<char, std::char_traits<char>>&)
void xbytes::output_declare_symbol(std::ofstream& ss)
{
	ss << "#define SYMBOL_COUNT " << symbols.size() << std::endl;
	ss << "enum TERMINAL_SYMBOL" << std::endl;
	ss << "{\n";
	int i = 0;
	for(i = 0; i < symbols.size(); ++i)
	{
		symbol* s = symbols[i];
		if(s->type == ST_NONTERMINAL) break;

		ss << "	" << s->name << " = " << s->index << "," << std::endl;
	}
	ss << "	TERMINAL_SYMBOL_COUNT = " << i << std::endl;
	ss << "};\n";
	ss << std::endl;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4442(%rip), %rsi      # 0xd7c7
movl $0x15, %edx
movq %rbx, %rdi
callq 0x32b0
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x3160
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x4406(%rip), %rsi      # 0xd7dd
movl $0x14, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x43e0(%rip), %rsi      # 0xd7f2
movl $0x2, %edx
movq %rbx, %rdi
callq 0x32b0
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x94e5
xorl %r15d, %r15d
movq (%rax,%r15,8), %r12
cmpl $0x2, 0x48(%r12)
je 0x94e8
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x4200(%rip), %rsi      # 0xd64f
callq 0x32b0
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x32b0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x4393(%rip), %rsi      # 0xd80b
callq 0x32b0
movl (%r12), %esi
movq %r13, %rdi
callq 0x33b0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x437c(%rip), %rsi      # 0xd817
callq 0x32b0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
incq %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x9430
jmp 0x94e8
xorl %r15d, %r15d
leaq 0x4306(%rip), %rsi      # 0xd7f5
movl $0x19, %edx
movq %rbx, %rdi
callq 0x32b0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x33b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x42d7(%rip), %rsi      # 0xd80f
movl $0x3, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/eva23511[P]OS-Virtual-Memory-Management/main.cpp
// Function: ParseRandFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> ParseRandFile(string filename) {
    ifstream rand_file(filename);
    
    if (!rand_file.is_open()) {
        printf("Could not open rand file: %s\n", filename.c_str());
        exit (EXIT_FAILURE);
    }
    
    int num;
    vector<int> randoms;
    
    rand_file >> num;
    while (rand_file >> num) {
        randoms.push_back(num);
    }
    
    rand_file.close();
    return randoms;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0x21f0
leaq -0x1b0(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x2bb4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x228(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x20e0
leaq -0x228(%rbp), %r14
leaq -0x1c(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x20e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2b8b
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2b7e
movl -0x1c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2b4c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x401e
jmp 0x2b4c
leaq -0x228(%rbp), %rdi
callq 0x2050
leaq -0x228(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rsi
leaq 0x34ad(%rip), %rdi      # 0x606b
xorl %eax, %eax
callq 0x2030
movl $0x1, %edi
callq 0x2160
jmp 0x2bd1
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2be8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2150
leaq -0x228(%rbp), %rdi
callq 0x2080
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/eva23511[P]OS-Virtual-Memory-Management/main.cpp
// Function: GetPager(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>, int)
Pager * GetPager(string algo, vector<int> randoms, int num_frames) {
    if (algo == "f") {
        return new FifoPager();
    } else if (algo == "r") {
        return new RandomPager(randoms);
    } else if (algo == "c") {
        return new ClockPager();
    } else if (algo == "e") {
        return new NruPager(a_option);
    } else if (algo == "a") {
        return new AgingPager(a_option, num_frames);
    } else if (algo == "w") {
        return new WorkingSetPager(a_option);
    }
    
    printf("Wrong Pager Specification: %s\n", algo.c_str());
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3384(%rip), %rsi      # 0x6044
callq 0x2090
testl %eax, %eax
je 0x2d60
leaq 0x3372(%rip), %rsi      # 0x6046
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x2d7a
leaq 0x3515(%rip), %rsi      # 0x6200
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x2db6
leaq 0x347a(%rip), %rsi      # 0x617c
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x2dcd
leaq 0x332f(%rip), %rsi      # 0x6048
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x2dea
leaq 0x331a(%rip), %rsi      # 0x604a
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
jne 0x2e16
movl $0x18, %edi
callq 0x2140
movq %rax, %rbx
movl 0x641d(%rip), %esi      # 0x9170
movq %rax, %rdi
callq 0x4c58
jmp 0x2e08
movl $0x10, %edi
callq 0x2140
movq %rax, %rbx
movq %rax, %rdi
callq 0x4768
jmp 0x2e08
movl $0x28, %edi
callq 0x2140
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x3a54
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x47b8
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2e08
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x2150
jmp 0x2e08
movl $0x10, %edi
callq 0x2140
movq %rax, %rbx
movq %rax, %rdi
callq 0x4846
jmp 0x2e08
movl $0x18, %edi
callq 0x2140
movq %rax, %rbx
movl 0x6390(%rip), %esi      # 0x9170
movq %rax, %rdi
callq 0x48e0
jmp 0x2e08
movl $0x28, %edi
callq 0x2140
movq %rax, %rbx
movl 0x6373(%rip), %esi      # 0x9170
movq %rax, %rdi
movl %r14d, %edx
callq 0x4a58
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rsi
leaq 0x322c(%rip), %rdi      # 0x604c
xorl %eax, %eax
callq 0x2030
movl $0x1, %edi
callq 0x2160
jmp 0x2e5b
jmp 0x2e35
movq %rax, %r14
movl $0x18, %esi
jmp 0x2e6d
jmp 0x2e65
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2e5e
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x2150
jmp 0x2e5e
movq %rax, %r14
movl $0x28, %esi
jmp 0x2e6d
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/eva23511[P]OS-Virtual-Memory-Management/main.cpp
// Function: PrintFrameTable()
void PrintFrameTable() {
    printf("FT:");
    for (Frame * f : frame_table) {
        if (f->pid != -1) {
            printf(" %d:%d", f->pid, f->vpage);
        } else {
            printf(" *");
        }
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x2bc6(%rip), %rdi      # 0x60d8
xorl %eax, %eax
callq 0x2030
movq 0x5c58(%rip), %r15      # 0x9178
movq 0x5c59(%rip), %r12      # 0x9180
cmpq %r12, %r15
je 0x3567
leaq 0x2bb0(%rip), %rbx      # 0x60e3
leaq 0x2ba2(%rip), %r14      # 0x60dc
movq (%r15), %rax
movl 0x4(%rax), %esi
cmpl $-0x1, %esi
je 0x3554
movl 0x8(%rax), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
jmp 0x355e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
addq $0x8, %r15
cmpq %r12, %r15
jne 0x353a
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2190