LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/willprice[P]parallel-cpp-workshop/map.cpp
// Function: main
int main(int argc, char **argv)
{
    auto a = std::vector<int>( { 1, 2, 3, 4, 5 } );
    auto b = std::vector<int>( { 6, 7, 8, 9, 10 } );

    print_vector(map_fn(sum, a, b));
    print_vector(map_fn(difference, a, b));
    print_vector(map_fn(multiply, a, b));

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movups 0xdab(%rip), %xmm0      # 0x2004
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x50(%rsp), %rdi
pushq $0x5
popq %rbx
leaq 0x10(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1390
movups 0xd91(%rip), %xmm0      # 0x2018
movaps %xmm0, (%r14)
movl $0xa, 0x10(%r14)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdx
callq 0x1390
leaq -0x75(%rip), %rsi       # 0x123c
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x143c
leaq 0x10(%rsp), %rdi
callq 0x13c6
leaq 0x10(%rsp), %rdi
callq 0x157a
leaq -0x9a(%rip), %rsi       # 0x1246
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x143c
leaq 0x10(%rsp), %rdi
callq 0x13c6
leaq 0x10(%rsp), %rdi
callq 0x157a
leaq -0xcf(%rip), %rsi       # 0x1240
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x143c
leaq 0x10(%rsp), %rdi
callq 0x13c6
leaq 0x10(%rsp), %rdi
callq 0x157a
leaq 0x30(%rsp), %rdi
callq 0x157a
leaq 0x50(%rsp), %rdi
callq 0x157a
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x135d
jmp 0x136c
jmp 0x135d
jmp 0x136c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x157a
jmp 0x136f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x157a
leaq 0x50(%rsp), %rdi
callq 0x157a
movq %rbx, %rdi
callq 0x1100
movq %rax, %rbx
jmp 0x1379
// File: /workspace/github_cpp_makefile_star2_O2/willprice[P]parallel-cpp-workshop/map.cpp
// Function: void print_vector<int>(std::vector<int, std::allocator<int>> const&)
void print_vector(const std::vector<T> &values)
{
    std::cout << "[";

    for (const T &value : values)
    {
        std::cout << " " << value;
    }

    std::cout << " ]" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x2c00(%rip), %rbx      # 0x3fd8
leaq 0xc7e(%rip), %rsi       # 0x205d
movq %rbx, %rdi
callq 0x10a0
movq (%r14), %r15
movq 0x8(%r14), %r12
leaq 0xc6a(%rip), %r14       # 0x205f
cmpq %r12, %r15
je 0x1416
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10a0
movl (%r15), %esi
movq %rax, %rdi
callq 0x10f0
addq $0x4, %r15
jmp 0x13f5
movq 0x2bbb(%rip), %rdi      # 0x3fd8
leaq 0xc3d(%rip), %rsi       # 0x2061
callq 0x10a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/willprice[P]parallel-cpp-workshop/map.cpp
// Function: auto map_fn<int (*)(int, int), int>(int (*)(int, int), std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
auto map_fn(Fn fn, std::vector<T> &xs, std::vector<T> &ys)
{
    int len = std::min(xs.size(), ys.size());
    auto result = std::vector<T>(len);

    for (int i = 0; i < len; i++) {
      result[i] = fn(xs[i], ys[i]);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x2, %rax
movq 0x8(%rcx), %rcx
subq (%r14), %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movslq %ecx, %r13
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r13, %rsi
callq 0x14fc
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpq %rbp, %r13
je 0x14b2
movq (%r15), %rax
movl (%rax,%rbp,4), %edi
movq (%r14), %rax
movl (%rax,%rbp,4), %esi
callq *%r12
movq 0x10(%rsp), %rcx
movl %eax, (%rcx,%rbp,4)
incq %rbp
jmp 0x1491
leaq 0x10(%rsp), %rdi
movaps (%rdi), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x157a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x157a
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/kiven-li[P]xbytes/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	if(argc < 2)
	{
		std::cout << "x-bytes: need rule file name." << std::endl;
		return 1;
	}

    xbytes::xbytes x;
    x.make_parser(argv[1]);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x6d8, %rsp            # imm = 0x6D8
cmpl $0x1, %edi
jg 0x257d
movq 0xca74(%rip), %rdi      # 0xefd8
leaq 0x7a99(%rip), %rsi      # 0xa004
callq 0x2220
movq %rax, %rdi
callq 0x2110
pushq $0x1
popq %rax
jmp 0x25c4
movq %rsi, %rbx
leaq -0x6e0(%rbp), %rdi
callq 0x26d0
movq 0x8(%rbx), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x25f4
leaq -0x6e0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2a6a
leaq -0x30(%rbp), %rdi
callq 0x2100
leaq -0x6e0(%rbp), %rdi
callq 0x28b6
xorl %eax, %eax
addq $0x6d8, %rsp            # imm = 0x6D8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2100
jmp 0x25df
movq %rax, %rbx
leaq -0x6e0(%rbp), %rdi
callq 0x28b6
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::~xbytes()
xbytes::~xbytes()
{
	for(int i = 0; i < symbols.size(); ++i)
	{
		delete symbols[i];
	}
	for(int i = 0; i < rules.size(); ++i)
	{
		delete rules[i];
	}
	for(int i = 0; i < states.size(); ++i)
	{
		for(int j = 0; j < states[i]->terms.size(); ++j)
		{
			delete states[i]->terms[j];
		}
		delete states[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %r14d, %r14d
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x290c
movq (%rax,%r14,8), %rbx
testq %rbx, %rbx
je 0x28fa
movq %rbx, %rdi
callq 0x6fb4
movl $0xa8, %esi
movq %rbx, %rdi
callq 0x2240
incq %r14
jmp 0x28d5
leaq 0x20(%r15), %rax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
movq 0x20(%r15), %rax
movq 0x28(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x294e
movq (%rax,%r14,8), %rbx
testq %rbx, %rbx
je 0x293c
movq %rbx, %rdi
callq 0x6f72
movl $0xa8, %esi
movq %rbx, %rdi
callq 0x2240
incq %r14
jmp 0x2917
leaq 0x38(%r15), %r12
xorl %ebx, %ebx
pushq $0x30
popq %r13
movq %r15, -0x40(%rbp)
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x29cd
xorl %r14d, %r14d
movq (%rax,%rbx,8), %r15
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x29b1
movq (%rax,%r14,8), %r15
testq %r15, %r15
je 0x299d
leaq 0x10(%r15), %rdi
callq 0x8154
movq %r15, %rdi
movq %r13, %rsi
callq 0x2240
incq %r14
movq (%r12), %rax
jmp 0x2973
movq %r15, %rdi
callq 0x6ff6
movq %r15, %rdi
pushq $0x70
popq %rsi
callq 0x2240
incq %rbx
movq -0x40(%rbp), %r15
jmp 0x295c
leaq 0x698(%r15), %rdi
callq 0x7024
leaq 0x678(%r15), %rdi
callq 0x2100
leaq 0x658(%r15), %rdi
callq 0x2100
leaq 0x638(%r15), %rdi
callq 0x2100
leaq 0x618(%r15), %rdi
callq 0x2100
leaq 0x160(%r15), %rdi
callq 0x6f72
leaq 0xb8(%r15), %rdi
callq 0x6fb4
leaq 0x90(%r15), %rdi
callq 0x2100
leaq 0x70(%r15), %rdi
callq 0x2100
addq $0x50, %r15
movq %r15, %rdi
callq 0x2100
movq %r12, %rdi
callq 0x8192
movq -0x30(%rbp), %rdi
callq 0x8116
movq -0x38(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8154
// File: /workspace/github_cpp_makefile_star2_O2/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::error_on_line(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void xbytes::error_on_line(const char* line, const string& error, int space)
{
	std::cout << "ERROR:" << std::endl;
	std::cout << "  line: " << line_count+1 << std::endl;
	std::cout << "  info: Don't parse program file, There is an error:[[" << std::endl;
	std::cout << line << std::endl;
	for(int i = 0; i < space; ++i)
	{
		std::cout << ' ';
	}
	std::cout << "^" << std::endl;
	std::cout << "  " << error << "]]" << std::endl;

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq 0xba5f(%rip), %r14      # 0xefd8
leaq 0x700b(%rip), %rsi      # 0xa58b
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
leaq 0x6ffb(%rip), %rsi      # 0xa592
movq %r14, %rdi
callq 0x2220
movl 0x60c(%r13), %esi
incl %esi
movq %rax, %rdi
callq 0x2370
movq %rax, %rdi
callq 0x2110
leaq 0x6fdc(%rip), %rsi      # 0xa59b
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movq %rax, %rdi
callq 0x2110
xorl %r12d, %r12d
testl %r15d, %r15d
cmovgl %r15d, %r12d
pushq $0x20
popq %r15
subl $0x1, %r12d
jb 0x3603
movq %r14, %rdi
movl %r15d, %esi
callq 0x2270
jmp 0x35f0
movq 0xb9ce(%rip), %r14      # 0xefd8
leaq 0x6fc1(%rip), %rsi      # 0xa5d2
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
leaq 0x6fac(%rip), %rsi      # 0xa5d4
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2200
leaq 0x6f95(%rip), %rsi      # 0xa5d7
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r15
andq $0x0, 0x10(%r15)
leaq -0x60(%rbp), %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r15)
movaps %xmm0, (%r12)
xorl %r13d, %r13d
leaq -0x48(%rbp), %r14
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x36c9
movq (%rax,%r13,8), %rax
movq %rax, -0x48(%rbp)
cmpl $0x1, 0x48(%rax)
movq %r15, %rdi
je 0x36bc
movq %r12, %rdi
movq %r14, %rsi
callq 0x7050
incq %r13
jmp 0x3694
xorl %ecx, %ecx
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
cmpq %rcx, %rsi
jbe 0x36f6
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rbx), %rax
movq (%rax,%rcx,8), %rdx
movl %ecx, (%rdx)
incq %rcx
jmp 0x36cb
xorl %ecx, %ecx
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
cmpq %rcx, %rsi
jbe 0x3734
movq -0x38(%rbp), %rsi
subq -0x40(%rbp), %rsi
shrq $0x3, %rsi
addl %ecx, %esi
movq (%rdx,%rcx,8), %rdx
movslq %esi, %rsi
movq %rdx, (%rax,%rsi,8)
movq 0x8(%rbx), %rax
movq (%rax,%rsi,8), %rdx
movl %esi, (%rdx)
incq %rcx
jmp 0x36f8
leaq -0x60(%rbp), %rdi
callq 0x8154
leaq -0x40(%rbp), %rdi
callq 0x8154
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x8154
leaq -0x40(%rbp), %rdi
callq 0x8154
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
xorl %edx, %edx
movq 0x698(%rbx), %rax
movq 0x6a0(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rdx, %rcx
jbe 0x37ff
movq %rdx, -0x30(%rbp)
movq %rdx, %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %r15
movl (%rax,%rcx), %r12d
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0x37f6
addq %r13, %rsi
movq %rbx, %rdi
callq 0x5784
testq %rax, %rax
je 0x37ed
movl %r12d, 0xa4(%rax)
movq -0x30(%rbp), %rcx
movl %ecx, 0xa0(%rax)
incq %r14
addq $0x20, %r13
jmp 0x37b8
movq -0x30(%rbp), %rdx
incq %rdx
jmp 0x3785
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
je 0x3875
movq (%rax,%rdx,8), %rsi
cmpq $0x0, 0xa0(%rsi)
je 0x383b
incq %rdx
jmp 0x3823
movq 0x30(%rsi), %rdi
movq 0x38(%rsi), %r8
subq %rdi, %r8
sarq $0x3, %r8
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x3836
movq (%rdi,%r9,8), %r10
cmpl $0x1, 0x48(%r10)
jne 0x3867
cmpl $0x0, 0xa0(%r10)
jns 0x386c
incq %r9
jmp 0x384d
movq %r10, 0xa0(%rsi)
jmp 0x3836
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x389f
movq (%rax,%rdx,8), %rsi
movb $0x0, 0x68(%rsi)
incq %rdx
jmp 0x388d
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rcx, %rdx
jne 0x38c6
xorl %edx, %edx
testb $0x1, %sil
movl $0x0, %esi
jne 0x38b2
jmp 0x3909
movq (%rax,%rdx,8), %r9
movq 0x8(%r9), %rdi
cmpb $0x0, 0x68(%rdi)
jne 0x3904
movq 0x30(%r9), %r8
movq 0x38(%r9), %r9
subq %r8, %r9
je 0x38fd
sarq $0x3, %r9
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x38fd
movq (%r8,%r10,8), %r11
incq %r10
cmpb $0x0, 0x68(%r11)
jne 0x38e8
jmp 0x3904
movb $0x1, 0x68(%rdi)
movb $0x1, %sil
incq %rdx
jmp 0x38b2
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x3956
movq (%rsi,%r14), %rdi
cmpl $0x1, 0x48(%rdi)
jne 0x394d
addq %r14, %rsi
addq $0x70, %rdi
callq 0x7050
incq %r15
addq $0x8, %r14
jmp 0x3923
xorl %r14d, %r14d
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x39c8
movq (%rcx,%r14,8), %r15
movq 0x30(%r15), %rcx
cmpq %rcx, 0x38(%r15)
je 0x39d6
xorl %r12d, %r12d
movl %eax, %r13d
movq 0x8(%r15), %rsi
addq $0x70, %rsi
movq (%rcx), %rdx
addq $0x70, %rdx
callq 0x4ac6
addl %r13d, %eax
movq 0x30(%r15), %rcx
movq 0x38(%r15), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
decq %rdx
cmpq %r12, %rdx
jbe 0x39d6
movq (%rcx,%r12,8), %rdx
cmpb $0x1, 0x68(%rdx)
jne 0x39d6
leaq (%rcx,%r12,8), %rcx
addq $0x8, %rcx
incq %r12
jmp 0x3980
xorl %r14d, %r14d
testl %eax, %eax
movl $0x0, %eax
jne 0x395b
jmp 0x39db
incq %r14
jmp 0x395b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r14
movq %r14, %rdi
movq %rsi, -0x38(%rbp)
callq 0x4b66
movq %r14, %rdi
callq 0x6ff6
xorl %edx, %edx
leaq 0x6560(%rip), %r15      # 0xa199
xorl %esi, %esi
movq -0x38(%rbp), %rcx
movq 0x38(%rcx), %rax
movq 0x40(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rdx, %rcx
jbe 0x3d18
movq (%rax,%rdx,8), %r12
cmpb $0x0, 0x68(%r12)
jne 0x3d3c
movl %esi, -0x2c(%rbp)
movq %rdx, -0x40(%rbp)
xorl %ebx, %ebx
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x3d29
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 0x3d10
movq (%rcx,%rax,8), %r13
leaq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x7074
testb %al, %al
jne 0x3d10
leaq -0xb0(%rbp), %rdi
movq -0x38(%rbp), %r14
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x4c04
movq %r14, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x4d2e
movl %eax, %r14d
movl -0xb0(%rbp), %ecx
movq %r12, %rsi
movq %r13, %rdx
callq 0x4e40
addl -0x2c(%rbp), %r14d
addl %eax, %r14d
leaq -0xb0(%rbp), %rdi
callq 0x6ff6
movl %r14d, -0x2c(%rbp)
incq %rbx
jmp 0x3c70
xorl %edx, %edx
testl %esi, %esi
movl $0x0, %esi
jne 0x3c3b
jmp 0x3d44
movl -0x2c(%rbp), %esi
testl %esi, %esi
movq -0x40(%rbp), %rdx
jne 0x3d3c
movb $0x1, 0x68(%r12)
xorl %esi, %esi
incq %rdx
jmp 0x3c3b
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x6ff6
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rsi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x4b2b
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
leaq (%rdx,%r12,8), %rsi
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x4b1b
movq (%rsi), %rdi
leaq 0x1(%rdx), %r8
cmpq (%rax,%rdx,8), %rdi
movq %r8, %rdx
jne 0x4b04
jmp 0x4b26
incl %r15d
movq %r14, %rdi
callq 0x7050
incq %r12
jmp 0x4add
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
andl $0x0, 0x28(%rdi)
movq %rsi, %r14
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
andl $0x0, (%rdi)
pushq $0x30
popq %rdi
callq 0x2230
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
movq (%r14), %rcx
movq %rcx, (%rax)
callq 0x7084
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e86
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d2e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6ff6
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
andl $0x0, 0x28(%rdi)
movq %rsi, -0x30(%rbp)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
leaq -0x50(%rbp), %r13
xorl %r12d, %r12d
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x4cd1
movq (%rax,%r12,8), %rsi
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x4cef
movslq 0x8(%rsi), %rax
movq 0x30(%rdx), %rcx
movq 0x38(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x4ccc
cmpq %r14, (%rcx,%rax,8)
jne 0x4ccc
andq $0x0, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%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 0x718a
movq %rbx, %rsi
leaq -0x60(%rbp), %rdx
callq 0x5204
movq %r13, %rdi
callq 0x8154
incq %r12
jmp 0x4c52
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x4e86
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x54a5(%rip), %rdi      # 0xa19b
leaq 0x54ab(%rip), %rsi      # 0xa1a8
leaq 0x54af(%rip), %rcx      # 0xa1b3
movl $0x20e, %edx            # imm = 0x20E
callq 0x2160
movq %rax, %r14
jmp 0x4d1e
movq %rax, %r14
movq %r13, %rdi
callq 0x8154
movq %rbx, %rdi
callq 0x6ff6
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, -0x40(%rbp)
movq 0x38(%rdi), %r14
movq %rdi, -0x30(%rbp)
movq 0x40(%rdi), %r13
subq %r14, %r13
movq %r13, -0x38(%rbp)
sarq $0x3, %r13
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x4db9
movq (%r14,%r15,8), %r12
movq %r12, %rsi
movq %rbx, %rdx
callq 0x50a6
incq %r15
testb %al, %al
je 0x4d64
movl (%r12), %eax
movl %eax, (%rbx)
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x50f6
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x4e30
movq %r12, %rsi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5158
movq -0x38(%rbp), %rax
shrq $0x3, %rax
movl %eax, (%rbx)
pushq $0x70
popq %rdi
callq 0x2230
movq %rax, %r15
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)
movq %rax, 0x38(%r15)
movq %rax, 0x40(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x58(%r15)
leaq -0x48(%rbp), %r12
movq %r15, (%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x70a8
movb $0x0, 0x68(%r15)
movq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x70f0
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
subq %r14, %r15
movq 0x8(%rdx), %r12
movq 0x10(%rdx), %rax
subq %r12, %rax
cmpq %rax, %r15
jne 0x5144
sarq $0x3, %r15
xorl %r13d, %r13d
cmpq %r13, %r15
sete %bl
je 0x5146
movq (%r14,%r13,8), %rsi
movq (%r12,%r13,8), %rdx
callq 0x51b0
incq %r13
testb %al, %al
jne 0x5126
jmp 0x5146
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x51a4
movq (%rax,%r12,8), %rsi
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
addq $0x10, %rsi
addq $0x10, %rdx
callq 0x4ac6
addl %eax, %r15d
incq %r12
jmp 0x516f
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5200
movl 0x8(%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0x5200
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rsi
subq %rcx, %rsi
movq 0x10(%rdx), %rdi
movq 0x18(%rdx), %rax
subq %rdi, %rax
cmpq %rax, %rsi
jne 0x5200
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rsi
xorl %edx, %edx
cmpq %rdx, %rsi
sete %al
je 0x51fe
movq (%rcx,%rdx,8), %r8
leaq 0x1(%rdx), %r9
cmpq (%rdi,%rdx,8), %r8
movq %r9, %rdx
je 0x51e5
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
leaq 0x8(%rsi), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r13
subq %r12, %r13
sarq $0x3, %r13
movq (%rdx), %r14
movq %rdx, -0x30(%rbp)
movl 0x8(%rdx), %eax
movl %eax, -0x34(%rbp)
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x5267
movq (%r12,%rbx,8), %r15
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x51b0
testb %al, %al
jne 0x52aa
cmpq %r14, (%r15)
jne 0x5262
movl -0x34(%rbp), %eax
cmpl %eax, 0x8(%r15)
je 0x52bb
incq %rbx
jmp 0x523b
pushq $0x30
popq %rdi
callq 0x2230
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
leaq -0x48(%rbp), %r12
movq %rax, (%r12)
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x725e
movb $0x0, 0x28(%r15)
movq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x7084
pushq $0x1
popq %rax
jmp 0x52ac
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r15
movq -0x30(%rbp), %rdx
addq $0x10, %rdx
movq %r15, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ac6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5583
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdx), %r13
movq %r13, %rsi
callq 0x5784
movq %rax, -0x30(%rbp)
testq %rax, %rax
jne 0x5531
movl $0xa8, %edi
callq 0x2230
movq %rax, %r12
movq %rax, %rdi
callq 0x6ed0
leaq -0x30(%rbp), %rax
movq %r12, (%rax)
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
addq $0x8, %r15
shrq $0x3, %rax
movl %eax, (%r12)
leaq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0x2130
leaq 0x28(%rbx), %rsi
leaq 0x28(%r12), %rdi
callq 0x2130
movq 0x8(%r12), %rax
movb (%rax), %al
addb $-0x61, %al
xorl %ecx, %ecx
cmpb $0x1a, %al
adcl $0x1, %ecx
movl %ecx, 0x48(%r12)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xa0(%r12)
movq %r15, %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x7050
movq (%r15), %rax
testq %rax, %rax
je 0x5592
cmpq $0x0, 0x8(%r14)
je 0x5557
leaq 0x30(%r14), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7050
addq $0x48, %r14
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x733e
jmp 0x556b
movq %rax, 0x8(%r14)
leaq 0x28(%rbx), %rsi
addq $0x10, %r14
movq %r14, %rdi
callq 0x2130
andq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
andq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movb %cl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f50(%rip), %rdi      # 0xa4e9
leaq 0x4c08(%rip), %rsi      # 0xa1a8
leaq 0x4f4d(%rip), %rcx      # 0xa4f4
movl $0x45a, %edx            # imm = 0x45A
callq 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::add_rule(xbytes::rule&)
void xbytes::add_rule(rule& r)
{
	//create new rule
	rule* rr = new rule();
	rr->index = rules.size();
	rr->left = r.left;
	rr->left_alias = r.left_alias;
	rr->rights = r.rights;
	rr->right_alias = r.right_alias;
	rr->code = r.code;
	make_string_rule(*rr);
	rules.push_back(rr);

	//attach rule with left symbol
	rr->left->rules.push_back(rr);

	//set start rule
	if(rr->left->name == "program")
	{
		start = rr;

		symbol* s = new symbol();
		s->index = symbols.size();
		s->name = ACCEPT_TERMINAL;
		s->type = ST_TERMINAL;
		s->associativity = AT_NONE;
		s->precedence = -1;
		symbols.push_back(s);
		rr->rights.push_back(s);
		rr->right_alias.push_back("");
	}
	
	//clear global rule
	r.left = NULL;
	r.left_alias.clear();
	r.rights.clear();	
	r.right_alias.clear();
	r.code.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0xa8, %edi
callq 0x2230
movq %rax, %r13
movq %rax, %rdi
callq 0x6f1a
leaq -0x38(%rbp), %r12
movq %r13, (%r12)
leaq 0x20(%r15), %r14
movq 0x28(%r15), %rax
subq 0x20(%r15), %rax
shrq $0x3, %rax
movl %eax, (%r13)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r13)
leaq 0x10(%rbx), %rsi
leaq 0x10(%r13), %rdi
callq 0x2130
leaq 0x30(%rbx), %rsi
leaq 0x30(%r13), %rdi
callq 0x718a
leaq 0x48(%rbx), %rsi
leaq 0x48(%r13), %rdi
movq %rsi, -0x40(%rbp)
callq 0x737a
leaq 0x60(%rbx), %rsi
leaq 0x60(%r13), %rdi
callq 0x2130
movq %r13, %rsi
callq 0x57da
movq %r14, %rdi
movq %r12, %rsi
callq 0x744e
movq (%r12), %rax
movq 0x8(%rax), %rdi
addq $0x50, %rdi
movq %r12, %rsi
callq 0x744e
movq (%r12), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
leaq 0x4eb3(%rip), %rsi      # 0xa527
callq 0x7074
testb %al, %al
je 0x572d
movq -0x38(%rbp), %rax
movq %rax, (%r15)
movl $0xa8, %edi
callq 0x2230
movq %rax, %r12
movq %rax, %rdi
callq 0x6ed0
leaq -0x48(%rbp), %r14
movq %r12, (%r14)
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
addq $0x8, %r15
shrq $0x3, %rax
movl %eax, (%r12)
leaq 0x8(%r12), %rdi
leaq 0x4ad5(%rip), %rsi      # 0xa199
callq 0x23b0
movl $0x1, 0x48(%r12)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xa0(%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x7050
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq %r14, %rsi
callq 0x7050
movq -0x38(%rbp), %r14
leaq 0x4f4b(%rip), %rsi      # 0xa650
leaq -0x68(%rbp), %r15
leaq -0x29(%rbp), %rdx
movq %r15, %rdi
callq 0x25f4
addq $0x48, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x9448
leaq -0x68(%rbp), %rdi
callq 0x2100
andq $0x0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax)
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x574c
movq %rax, 0x38(%rbx)
movq -0x40(%rbp), %rdi
callq 0x7472
andq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rax
movb $0x0, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x57ce
movq (%rax,%r12,8), %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0x751e
incq %r12
testb %al, %al
je 0x579a
movq 0x8(%r14), %rax
movq -0x8(%rax,%r12,8), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::make_string_rule(xbytes::rule&)
void xbytes::make_string_rule(rule& r)
{
	r.str_rule.clear();

	r.str_rule = r.left->name;
	if(r.left_alias.size() > 0)
	{
		r.str_rule += "(" + r.left_alias + ")";
	}
	r.str_rule += " ->";
	
	assert(r.rights.size() == r.right_alias.size());

	for(int j = 0; j < r.rights.size(); ++j)
	{
		r.str_rule += " " + r.rights[j]->name;
		if(r.right_alias[j].size() > 0)
		{
			r.str_rule += "(" + r.right_alias[j] + ")";
		}
	}
	r.str_rule += ".";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
leaq 0x80(%rsi), %rbx
andq $0x0, 0x88(%rsi)
movq 0x80(%rsi), %rax
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x2130
cmpq $0x0, 0x18(%r14)
movq %r14, -0x30(%rbp)
je 0x586e
leaq 0x10(%r14), %rdx
leaq 0x4d02(%rip), %rsi      # 0xa52f
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x74a8
leaq 0x4c42(%rip), %rdx      # 0xa482
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x747f
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x23c0
leaq -0x50(%rbp), %rdi
callq 0x2100
leaq -0x70(%rbp), %rdi
callq 0x2100
movq -0x30(%rbp), %r14
leaq 0x4cbc(%rip), %rsi      # 0xa531
movq %rbx, %rdi
callq 0x23a0
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movq 0x50(%r14), %rsi
subq 0x48(%r14), %rsi
sarq $0x5, %rsi
cmpq %rsi, %rdx
jne 0x5978
xorl %r15d, %r15d
leaq -0x50(%rbp), %r12
xorl %r13d, %r13d
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x595a
movq (%rax,%r13,8), %rdx
addq $0x8, %rdx
movq %r12, %rdi
leaq 0x4d05(%rip), %rsi      # 0xa5d5
callq 0x74a8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23c0
movq %r12, %rdi
callq 0x2100
movq -0x30(%rbp), %rcx
movq 0x48(%rcx), %rdx
cmpq $0x0, 0x8(%rdx,%r15)
je 0x5946
movq %rbx, %r14
addq %r15, %rdx
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
leaq 0x4c23(%rip), %rsi      # 0xa52f
callq 0x74a8
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x4b64(%rip), %rdx      # 0xa482
callq 0x747f
movq %r14, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x23c0
movq %r12, %rdi
callq 0x2100
leaq -0x70(%rbp), %rdi
callq 0x2100
movq -0x30(%rbp), %rcx
incq %r13
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rcx
addq $0x20, %r15
jmp 0x58ae
leaq 0x47a0(%rip), %rsi      # 0xa101
movq %rbx, %rdi
callq 0x23a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4bb6(%rip), %rdi      # 0xa535
leaq 0x4822(%rip), %rsi      # 0xa1a8
leaq 0x4bd0(%rip), %rcx      # 0xa55d
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x2160
jmp 0x599b
jmp 0x59a9
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2100
jmp 0x59ac
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x59b9
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5a0a
movq %rbx, %rdi
callq 0x5c20
movq %rbx, %rdi
callq 0x5cf8
movq %rbx, %rdi
callq 0x5dea
movq %rbx, %rdi
callq 0x5ee6
movq %rbx, %rdi
callq 0x61b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x64a4
// File: /workspace/github_cpp_makefile_star2_O2/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 0x93a0(%rip), %r14      # 0xefd8
leaq 0x4a12(%rip), %rsi      # 0xa651
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
xorl %r15d, %r15d
leaq 0x493f(%rip), %r12      # 0xa598
leaq 0x4a13(%rip), %r13      # 0xa673
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x5ce8
movq %r14, %rdi
movl %r15d, %esi
callq 0x2370
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq 0x20(%rbx), %rcx
movq (%rcx,%r15,8), %rsi
subq $-0x80, %rsi
movq %rax, %rdi
callq 0x2200
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpq $0x0, 0x68(%rax)
je 0x5cd8
movq %r14, %rdi
leaq 0x49bc(%rip), %rsi      # 0xa670
callq 0x2220
movq 0x20(%rbx), %rcx
movq (%rcx,%r15,8), %rsi
addq $0x60, %rsi
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq %r14, %rdi
callq 0x2110
incq %r15
jmp 0x5c60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq 0x92c8(%rip), %r14      # 0xefd8
leaq 0x495f(%rip), %rsi      # 0xa676
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
xorl %r15d, %r15d
leaq 0x4ae6(%rip), %r12      # 0xa817
movq %rbx, -0x30(%rbp)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x5dc8
movq (%rax,%r15,8), %r13
cmpl $0x1, 0x48(%r13)
je 0x5dc0
leaq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x2200
movq %rax, %rdi
leaq 0x4907(%rip), %rsi      # 0xa671
callq 0x2220
xorl %ebx, %ebx
movq 0x70(%r13), %rax
movq 0x78(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x5da5
movq (%rax,%rbx,8), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x2200
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
incq %rbx
jmp 0x5d71
movq %r14, %rdi
leaq 0x4829(%rip), %rsi      # 0xa5d8
callq 0x2220
movq %rax, %rdi
callq 0x2110
movq -0x30(%rbp), %rbx
incq %r15
jmp 0x5d35
movq 0x9209(%rip), %rdi      # 0xefd8
callq 0x2110
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq 0x91d6(%rip), %r14      # 0xefd8
leaq 0x4891(%rip), %rsi      # 0xa69a
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
xorl %r15d, %r15d
leaq 0x49f4(%rip), %r12      # 0xa817
movq %rbx, -0x30(%rbp)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x5ec4
movq (%rax,%r15,8), %r13
cmpl $0x1, 0x48(%r13)
je 0x5ebc
leaq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x2200
movq %rax, %rdi
leaq 0x4811(%rip), %rsi      # 0xa671
callq 0x2220
xorl %ebx, %ebx
movq 0x88(%r13), %rax
movq 0x90(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x5ea1
movq (%rax,%rbx,8), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x2200
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
incq %rbx
jmp 0x5e67
movq %r14, %rdi
leaq 0x472d(%rip), %rsi      # 0xa5d8
callq 0x2220
movq %rax, %rdi
callq 0x2110
movq -0x30(%rbp), %rbx
incq %r15
jmp 0x5e27
movq 0x910d(%rip), %rdi      # 0xefd8
callq 0x2110
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movq 0x8b1c(%rip), %rdi      # 0xefd8
leaq 0x42b0(%rip), %rsi      # 0xa773
callq 0x2220
movq %rax, %rdi
callq 0x2110
xorl %r15d, %r15d
leaq 0x40fb(%rip), %r13      # 0xa5d5
movq 0x6a0(%rbx), %rax
subq 0x698(%rbx), %rax
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0x65c1
movq 0x8adc(%rip), %r14      # 0xefd8
movq %r14, %rdi
leaq 0x4295(%rip), %rsi      # 0xa79b
callq 0x2220
movq %rax, %rdi
movl %r15d, %esi
callq 0x2370
movq 0x698(%rbx), %rax
movq %r15, -0x30(%rbp)
shlq $0x5, %r15
movl (%rax,%r15), %eax
cmpl $0x2, %eax
leaq 0x4287(%rip), %rsi      # 0xa7ba
leaq 0x4276(%rip), %rcx      # 0xa7b0
cmoveq %rcx, %rsi
cmpl $0x1, %eax
leaq 0x425f(%rip), %rax      # 0xa7a7
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x2220
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x698(%rbx), %rax
movq 0x8(%rax,%r15), %rsi
movq 0x10(%rax,%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0x659a
addq %r12, %rsi
movq 0x8a57(%rip), %rdi      # 0xefd8
callq 0x2200
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
incq %r14
addq $0x20, %r12
jmp 0x655a
movq 0x8a37(%rip), %rdi      # 0xefd8
leaq 0x421c(%rip), %rsi      # 0xa7c4
callq 0x2220
movq %rax, %rdi
callq 0x2110
movq -0x30(%rbp), %r15
incq %r15
jmp 0x64da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq