LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: first_list_rhs_t
bitset_t*
first_list_rhs_t(list_rhs_t const* list) {
	if (!list)
		{ return (NULL_BITSET); }
	bitset_t* select_set = new_bitset();
	while (list) {
		if (IS_TERMINAL(list->symbol_rhs)) {
			ADD_BITSET(select_set, GET_INDEX(list->symbol_rhs));
			break;
		}
		else {
			UNION_BITSET(select_set, list->symbol_rhs->first);
			if (!list->symbol_rhs->nullable)
				{ break; }
		}
		list = list->next;
	}
	return (select_set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5781
movq %rdi, %r14
callq 0x22cc
movq %rax, %rbx
testq %r14, %r14
je 0x57af
movq 0x8(%r14), %rax
cmpl $0x2d, 0x8(%rax)
je 0x5785
movq 0x20(%rax), %rdx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x25dd
movq 0x8(%r14), %rax
cmpb $0x1, 0x18(%rax)
jne 0x57af
movq (%r14), %r14
jmp 0x5755
xorl %ebx, %ebx
jmp 0x57af
movq (%rax), %rcx
movl 0x4(%rbx), %eax
cmpq %rax, %rcx
jae 0x57a4
pushq $0x1
popq %rax
shlq %cl, %rax
movq 0x8(%rbx), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x57af
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x23b9
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: match_symbol_production
list_rhs_t const*
match_symbol_production(list_rhs_t const* list, symbol_t const* symbol) {
	if (!list)
		{ return (NULL); }
	while (list) {
		if (list->symbol_rhs == symbol)
			{ return (list); }
		list = list->next;
	}
	return (NULL);
}

// Assembly:
testq %rdi, %rdi
je 0x57ea
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
testq %rax, %rax
je 0x57ed
cmpq %rsi, 0x8(%rax)
je 0x57ef
movq (%rax), %rax
jmp 0x57da
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: stack_production_lhs
vector_t*
stack_production_lhs(cfg_t const* cfg, symbol_t* nter) {
	if (!cfg)
		{ return (NULL); }
	vector_t* stack = new_vector();
	int i;
	while ((i = IT_NEXT(nter->prod_lst)) != IT_NULL)
		{ PUSH_BACK_VECTOR(stack, AT_VECTOR(cfg->productions, i)); }
	IT_RESET(nter->prod_lst);
	return (stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5851
movq %rsi, %r14
movq %rdi, %r15
callq 0x28e4
movq %rax, %rbx
movq 0x30(%r14), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x5836
movq 0x10(%rbx), %rsi
movq (%r15), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rdx
movq %rbx, %rdi
callq 0x29d6
jmp 0x580e
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x5853
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x584c
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
jmp 0x5853
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: cfg_not_realizable
int
cfg_not_realizable(cfg_t const* cfg) {
	if (!cfg)
		{ return (ERROR); }

	precompute_realizable(cfg);

	int exit_status = DONE;
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal) - 1; ++i) {
		symbol_t* symbol = AT_VECTOR(cfg->non_terminal, i);
		if (symbol->realizable)
			{ continue; }

		if ((is_empty_bitset(symbol->first)) && (!symbol->nullable))
			{ symbol->realizable = false; }
		else {
			bitset_t* nter_seen = new_bitset();
			nter_not_derive(cfg, symbol, nter_seen);
			del_bitset(nter_seen);
		}

		if (!symbol->realizable) {
			errorf(0, "Non terminal %s derive no string at all.",
									symbol->name);
			exit_status = ERROR;
		}
	}
	return (exit_status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5b3a
movq %rdi, %rbx
xorl %eax, %eax
movq (%rbx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x5ab0
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rcx
leaq 0x10(%rcx), %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x5aa2
movq 0x8(%rdx), %rsi
cmpl $0x2d, 0x8(%rsi)
je 0x5a8c
xorl %edx, %edx
jmp 0x5aa4
movb $0x1, %dl
movq 0x8(%rcx), %rcx
movb %dl, 0x19(%rcx)
incq %rax
jmp 0x5a78
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r14
jae 0x5b3e
movq (%rax), %rax
movq (%rax,%r14,8), %r12
cmpb $0x0, 0x19(%r12)
jne 0x5b32
movq 0x20(%r12), %rdi
callq 0x253c
testb %al, %al
je 0x5aeb
cmpb $0x0, 0x18(%r12)
je 0x5b13
callq 0x22cc
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x5b50
movq %r13, %rdi
callq 0x2311
testb $0x1, 0x19(%r12)
je 0x5b19
jmp 0x5b32
movb $0x0, 0x19(%r12)
movq 0x10(%r12), %rdx
xorl %edi, %edi
leaq 0x4c56(%rip), %rsi      # 0xa77d
xorl %eax, %eax
callq 0x3b9c
pushq $-0x1
popq %r15
incq %r14
jmp 0x5ab6
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: nter_not_derive
static bool
nter_not_derive(cfg_t const* cfg, symbol_t* symbol, bitset_t* nter_seen) {
	if (IS_PRESENT(nter_seen, GET_INDEX(symbol)) || symbol->realizable)
		{ return (symbol->realizable);  }

	ADD_BITSET(nter_seen, GET_INDEX(symbol));

	vector_t* stack_prod = stack_production_lhs(cfg, symbol);
	for (size_t i = 0; i < SIZE_VECTOR(stack_prod); ++i) {
		production_t* crt_prod = (production_t*)AT_VECTOR(stack_prod, i);
		list_rhs_t* list = crt_prod->rhs_element;

		bool seq_real = true;
		while (list) {
			symbol_t* crt_symbol = list->symbol_rhs;
			if (IS_NON_TERMINAL(crt_symbol))
				{ seq_real &= nter_not_derive(cfg, crt_symbol, nter_seen); }
			list = list->next;
		}

		if (seq_real) {
			symbol->realizable = seq_real;
			break;
		}
	}
	del_vector(stack_prod);
	return (symbol->realizable);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
testq %rdx, %rdx
je 0x5b90
movq (%r15), %rax
movl 0x4(%rbx), %ecx
cmpq %rcx, %rax
jae 0x5b90
movq 0x8(%rbx), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jb 0x5b97
cmpb $0x1, 0x19(%r15)
jne 0x5ba0
addq $0x19, %r15
jmp 0x5c40
movq (%r15), %rcx
movl 0x4(%rbx), %eax
cmpq %rax, %rcx
jae 0x5bbf
pushq $0x1
popq %rax
shlq %cl, %rax
movq 0x8(%rbx), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x5bca
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x23b9
leaq 0x19(%r15), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x57f1
movq %rax, %r15
xorl %r13d, %r13d
cmpq 0x10(%r15), %r13
jae 0x5c34
movq (%r15), %rax
movq (%rax,%r13,8), %r12
addq $0x10, %r12
movb $0x1, %r14b
movq (%r12), %r12
testq %r12, %r12
je 0x5c24
movq 0x8(%r12), %rsi
cmpl $0x27, 0x8(%rsi)
jne 0x5bf8
movq -0x38(%rbp), %rdi
movq %rbx, %rdx
callq 0x5b50
testb %r14b, %r14b
setne %r14b
andb %al, %r14b
jmp 0x5bf8
incq %r13
testb $0x1, %r14b
je 0x5be4
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
movq %r15, %rdi
callq 0x2986
movq -0x30(%rbp), %r15
movb (%r15), %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: disjoint_select_set
bool
disjoint_select_set(cfg_t const* cfg, symbol_t* nter) {
	if (!cfg)
		{ return (true); }
	bool disjoint = true;
	vector_t* stack_prod = stack_production_lhs(cfg, nter);
	while (!EMPTY_VECTOR(stack_prod)) {
		production_t* prod = BACK_VECTOR(stack_prod);
		for (size_t j = 0; j < SIZE_VECTOR(stack_prod) - 1; ++j) {
			production_t* tmp_p = AT_VECTOR(stack_prod, j);
			if (!is_disjoint_bitset(prod->select_set, tmp_p->select_set)) {
				disjoint = false;
				break;
			}
		}
		if (!disjoint)
			{ break; }

		POP_BACK_VECTOR(stack_prod);	
	}

	del_vector(stack_prod);
	return (disjoint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5cc6
callq 0x57f1
movq %rax, %rbx
movq 0x10(%rbx), %rax
testq %rax, %rax
sete %r14b
je 0x5cbc
movq (%rbx), %rcx
movq -0x8(%rcx,%rax,8), %r15
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
decq %rax
cmpq %rax, %r12
jae 0x5cab
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x18(%r15), %rdi
movq 0x18(%rax), %rsi
callq 0x2800
incq %r12
testb %al, %al
jne 0x5c82
jmp 0x5cbc
movq 0x10(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
callq 0x2a66
jmp 0x5c6a
movq %rbx, %rdi
callq 0x2986
jmp 0x5cc9
movb $0x1, %r14b
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_set_op.c
// Function: detect_nullable
void
detect_nullable(cfg_t* cfg) {
	if (!cfg)
		{ return; }
	bool change;
	do {
		change = false;
		for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
			production_t* prod = (production_t*)
						AT_VECTOR(cfg->productions, i);
			if (!(prod->can_get_rid) && production_is_nullable(prod)) {
				change = prod->symbol_lhs->nullable = true;
				prod->can_get_rid = true;
			}
		}
	} while (change);
}

// Assembly:
testq %rdi, %rdi
je 0x5d3f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
cmpq 0x10(%rax), %r15
jae 0x5d28
movq (%rax), %rax
movq (%rax,%r15,8), %r14
cmpb $0x0, 0x20(%r14)
jne 0x5d23
movq %r14, %rdi
callq 0x5727
testb %al, %al
je 0x5d23
movq 0x8(%r14), %rax
movb $0x1, %r12b
movb %r12b, 0x18(%rax)
movb %r12b, 0x20(%r14)
incq %r15
jmp 0x5cf1
xorl %r15d, %r15d
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x5cf1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_set_op.c
// Function: compute_first
void
compute_first(cfg_t* cfg) {
	if (!cfg)
		{ return; }
	bool change;
	do {
		change = false;
		for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
			production_t* prod = (production_t*)AT_VECTOR(cfg->productions, i);
			bitset_t* first = first_production(prod);
			if (!is_subset_bitset(prod->select_set, first)) {
				if (!prod->symbol_lhs->first)
					{ prod->symbol_lhs->first = new_bitset(); }
				if (!prod->select_set)
					{ prod->select_set = new_bitset(); }
				UNION_BITSET(prod->symbol_lhs->first, first);
				UNION_BITSET(prod->select_set, first);
				change = true;
			}
			del_bitset(first);
		}
	} while (change);
}

// Assembly:
testq %rdi, %rdi
je 0x5e07
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %rax
cmpq 0x10(%rax), %r12
jae 0x5de6
movq (%rax), %rax
movq (%rax,%r12,8), %r15
movq %r15, %rdi
callq 0x57b7
movq %rax, %r14
movq 0x18(%r15), %rdi
movq %rax, %rsi
callq 0x278f
testb %al, %al
jne 0x5dd6
movq 0x8(%r15), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5da3
callq 0x22cc
movq 0x8(%r15), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, 0x18(%r15)
jne 0x5db3
callq 0x22cc
movq %rax, 0x18(%r15)
movq 0x8(%r15), %rax
movq 0x20(%rax), %rsi
xorl %edi, %edi
movq %r14, %rdx
callq 0x25dd
movq 0x18(%r15), %rsi
xorl %edi, %edi
movq %r14, %rdx
callq 0x25dd
movb $0x1, %r13b
movq %r14, %rdi
callq 0x2311
incq %r12
jmp 0x5d60
xorl %r12d, %r12d
testb $0x1, %r13b
movl $0x0, %r13d
jne 0x5d60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_set_op.c
// Function: compute_follow
void
compute_follow(cfg_t* cfg) {
	if (!cfg)
		{ return; }
	bool change;
	do {
		change = false;
		for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal); ++i) {
			if (follow_symbol(AT_VECTOR(cfg->non_terminal, i), cfg))
				{ change = true; }
		}
	} while (change);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x38(%rbp)
testq %rdi, %rdi
je 0x5fd5
xorl %ecx, %ecx
xorl %edx, %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rax), %rdx
jae 0x5fb0
movq %rcx, -0x48(%rbp)
movq (%rax), %rax
movq %rdx, -0x40(%rbp)
movq (%rax,%rdx,8), %r14
xorl %ecx, %ecx
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq 0x10(%rax), %rcx
jae 0x5fc2
movq (%rax), %rax
movq %rcx, -0x50(%rbp)
movq (%rax,%rcx,8), %rbx
movq 0x10(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x57ce
testq %rax, %rax
je 0x5fa4
movq (%rax), %r15
movq %r15, %r12
testq %r12, %r12
je 0x5ef7
movq 0x8(%r12), %r13
cmpl $0x2d, 0x8(%r13)
je 0x5f36
movq 0x28(%r14), %rdi
movq 0x20(%r13), %rsi
callq 0x278f
testb %al, %al
je 0x5ec2
movq 0x8(%r12), %rax
cmpb $0x0, 0x18(%rax)
jne 0x5ef1
jmp 0x5e75
movq 0x28(%r14), %rsi
testq %rsi, %rsi
jne 0x5ed7
callq 0x22cc
movq %rax, %rsi
movq %rax, 0x28(%r14)
movq 0x20(%r13), %rdx
xorl %edi, %edi
callq 0x25dd
movq 0x8(%r12), %rax
cmpb $0x1, 0x18(%rax)
jne 0x5f99
movq (%r12), %r12
jmp 0x5e8f
movq 0x28(%r14), %rdi
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rsi
callq 0x278f
testb %al, %al
jne 0x5e75
movq 0x28(%r14), %rsi
testq %rsi, %rsi
jne 0x5f25
callq 0x22cc
movq %rax, %rsi
movq %rax, 0x28(%r14)
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rdx
xorl %edi, %edi
callq 0x25dd
jmp 0x5f99
movq (%r13), %r12
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x5f66
movl 0x4(%rdi), %eax
cmpq %rax, %r12
jae 0x5f75
movq 0x8(%rdi), %rcx
movq %r12, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %r12, %rcx
jb 0x5e75
jmp 0x5f75
callq 0x22cc
movq %rax, %rdi
movq %rax, 0x28(%r14)
movl 0x4(%rax), %eax
cmpq %r12, %rax
jbe 0x5f91
pushq $0x1
popq %rax
movl %r12d, %ecx
shlq %cl, %rax
movq 0x8(%rdi), %rcx
shrq $0x6, %r12
orq %rax, (%rcx,%r12,8)
jmp 0x5f99
movq %r12, %rsi
callq 0x23b9
movb $0x1, %al
movq %rax, -0x30(%rbp)
jmp 0x5e75
movq -0x50(%rbp), %rcx
incq %rcx
jmp 0x5e55
xorl %edx, %edx
testb $0x1, %cl
movl $0x0, %ecx
jne 0x5e2a
jmp 0x5fd5
movq -0x30(%rbp), %rcx
orb -0x48(%rbp), %cl
movq -0x40(%rbp), %rdx
incq %rdx
jmp 0x5e2a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/ll.c
// Function: is_ll1
bool
is_ll1(cfg_t const* cfg) {
	bool disjoint = true;
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal) - 1; ++i) {
		symbol_t* nter = (symbol_t*)AT_VECTOR(cfg->non_terminal, i);
		if (nter->nullable) {
			disjoint = is_disjoint_bitset(nter->first, nter->follow);
			if (!disjoint)
				{ break; }
		}
		disjoint = disjoint_select_set(cfg, nter);
		if (!disjoint)
			{ break; }
	}
	return (disjoint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rcx, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r12
decq %r12
cmpq %r12, %rcx
jae 0x6039
movq (%rax), %rax
movq (%rax,%r15,8), %r14
cmpb $0x1, 0x18(%r14)
jne 0x6026
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rsi
callq 0x2800
testb %al, %al
je 0x6039
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c52
leaq 0x1(%r15), %rcx
testb %al, %al
jne 0x5ff4
cmpq %r12, %r15
setae %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/ll.c
// Function: build_ll1_table
vector_t*
build_ll1_table(cfg_t const* cfg) {
	vector_t* ll_table = new_vector();

	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal) - 1; ++i) {
		symbol_t* nter = AT_VECTOR(cfg->non_terminal, i);
		PUSH_BACK_VECTOR(ll_table, NULL_TRANS_LST);

		int j;
		while ((j = IT_NEXT(nter->prod_lst)) != IT_NULL) {
			production_t* prod = AT_VECTOR(cfg->productions, j);
			int k;
			while ((k = IT_NEXT(prod->select_set)) != IT_NULL) {
				trans_list_t* lst = new_trans_list(((symbol_t*)
									AT_VECTOR(cfg->terminal, k))->index,
									j, BACK_VECTOR(ll_table));
				BACK_VECTOR(ll_table) = lst;
			}

			IT_RESET(prod->select_set);

			if (!prod->can_get_rid)
				{ continue; }
			while ((k = IT_NEXT(prod->symbol_lhs->follow)) != IT_NULL) {
				trans_list_t* lst = new_trans_list(((symbol_t*)
								AT_VECTOR(cfg->terminal, k))->index,
								j, BACK_VECTOR(ll_table));
				lst->next = BACK_VECTOR(ll_table);
				BACK_VECTOR(ll_table) = lst;
			}
			IT_RESET(prod->symbol_lhs->follow);
		}
		IT_RESET(nter->prod_lst);
	}
	return (ll_table);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
callq 0x28e4
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r15
jae 0x61b1
movq (%rax), %rax
movq %r15, -0x30(%rbp)
movq (%rax,%r15,8), %r13
movq 0x10(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x29d6
movq 0x30(%r13), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x618c
movl %eax, %r15d
movq (%rbx), %rax
movq (%rax), %rax
movslq %r15d, %rcx
movq (%rax,%rcx,8), %r12
movq 0x18(%r12), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x60f3
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movl (%rax), %edi
movq (%r14), %rax
movq 0x10(%r14), %rcx
movq -0x8(%rax,%rcx,8), %rdx
movl %r15d, %esi
callq 0x378a
movq (%r14), %rcx
movq 0x10(%r14), %rdx
movq %rax, -0x8(%rcx,%rdx,8)
jmp 0x60b3
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x610d
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x610a
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
cmpb $0x1, 0x20(%r12)
jne 0x6091
movq 0x8(%r12), %rax
movq 0x28(%rax), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x6165
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movl (%rax), %edi
movq (%r14), %rax
movq 0x10(%r14), %rcx
movq -0x8(%rax,%rcx,8), %rdx
movl %r15d, %esi
callq 0x378a
movq (%r14), %rcx
movq 0x10(%r14), %rdx
movq -0x8(%rcx,%rdx,8), %rsi
movq %rsi, (%rax)
movq %rax, -0x8(%rcx,%rdx,8)
jmp 0x6119
movq 0x8(%r12), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x6091
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x6184
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
jmp 0x6091
movq 0x30(%r13), %rax
testq %rax, %rax
movq -0x30(%rbp), %r15
je 0x61a9
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x61a6
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
incq %r15
jmp 0x6064
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_lr1_state
void
del_lr1_state(lr1_state_t* state) {
	if (state) {
		del_bitset(state->items);
		del_trans_list(state->shift_lst);
		del_trans_list(state->goto_lst);
		del_trans_list(state->reduces);
		del_bitset(state->equiv_state);
	}
	FREE(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x61fe
movq (%rbx), %rdi
callq 0x2311
movq 0x10(%rbx), %rdi
callq 0x384a
movq 0x18(%rbx), %rdi
callq 0x384a
movq 0x20(%rbx), %rdi
callq 0x384a
movq 0x40(%rbx), %rdi
callq 0x2311
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: cmp_lr0_state
int
cmp_lr0_state(bitset_t* s1, bitset_t* s2) {
	if (count_elt_bitset(s1) != count_elt_bitset(s2))
		{ return (1); }

	int back = IT_BACK(s1);
	IT_RESET(s1);

	int eq = 0;
	int i;

	while ((i = IT_NEXT(s1)) != IT_NULL) {
		lr1_item_t* lr1 = (lr1_item_t*)AT_VECTOR(record_lr1_item, i);
		if (check_exist_lr0_item(s2, lr1) == -1) {
			eq = 1;
			break;
		}
	}

	IT_SET(s1, back);
	return (eq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x284d
movq %rax, %r15
movq %r14, %rdi
callq 0x284d
cmpq %rax, %r15
jne 0x62c2
xorl %eax, %eax
cmpb $0x1, 0x54(%rbx)
jne 0x6246
movl 0x4(%rbx), %eax
decl %eax
movl 0x50(%rbx), %r15d
movl %eax, 0x50(%rbx)
movq %rbx, %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x62e1
xorl %ecx, %ecx
cmpb $0x1, 0x54(%r14)
jne 0x626d
movl 0x4(%r14), %ecx
decl %ecx
movq 0x16c3c(%rip), %rdx     # 0x1ceb0
movq (%rdx), %rdx
cltq
movq (%rdx,%rax,8), %r13
movl 0x50(%r14), %r12d
movl %ecx, 0x50(%r14)
movq %r14, %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x62c7
movq 0x16c17(%rip), %rcx     # 0x1ceb0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rax
movq 0x8(%r13), %rcx
movq (%rax), %rdx
cmpq (%rcx), %rdx
jne 0x6285
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0x6285
movl %r12d, 0x50(%r14)
jmp 0x624d
pushq $0x1
popq %rax
jmp 0x62d2
movl %r12d, 0x50(%r14)
pushq $0x1
popq %rax
movl %r15d, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x62ce
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: new_lr1_item_record
static size_t
new_lr1_item_record(lr1_item_t* item) {
	if (!item)
		{ return (ERROR); }

	int index = get_index_vector(record_lr1_item, item, &cmp_lr1_item);
	if (index != -1) {
		del_lr1_item(item);
		return (index);
	}

	item->index = SIZE_VECTOR(record_lr1_item);
	PUSH_BACK_VECTOR(record_lr1_item, item);

	return (GET_INDEX(item));
}

// Assembly:
testq %rdi, %rdi
je 0x640f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x16ac5(%rip), %rdi     # 0x1ceb0
leaq 0x150c(%rip), %rdx      # 0x78fe
movq %rbx, %rsi
callq 0x2af6
cmpl $-0x1, %eax
je 0x6413
movl %eax, %r14d
movq %rbx, %rdi
callq 0x789d
movslq %r14d, %rax
jmp 0x642c
pushq $-0x1
popq %rax
retq
movq 0x16a96(%rip), %rdi     # 0x1ceb0
movq 0x10(%rdi), %rsi
movq %rsi, (%rbx)
movq %rbx, %rdx
callq 0x29d6
movq (%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: merge_lr1_state
bool
merge_lr1_state(lr1_state_t* st1, lr1_state_t* st2) {
	if (!st1 || !st2)
		{ return (false); }

	if (st1->hash_items != st2->hash_items
			|| cmp_lr0_state(st1->items, st2->items))
		{ return (false); }

	bitset_t* new_item = new_bitset();
	int i;

	while ((i = IT_NEXT(st1->items)) != IT_NULL) {
		lr1_item_t* st1_item = (lr1_item_t*)AT_VECTOR(record_lr1_item, i);
		int j;
		while ((j = IT_NEXT(st2->items)) != IT_NULL) {
			lr1_item_t* st2_item = (lr1_item_t*)AT_VECTOR(record_lr1_item, j);
			if (!cmp_lr0_item(CORE(st1_item), CORE(st2_item))) {
				int index_new_item = merge_lr1_item(st1_item, st2_item);
				if (index_new_item != ERROR)
					{ ADD_BITSET(new_item, (size_t)index_new_item); }
				break;
			}
		}
		IT_RESET(st2->items);
	}
	IT_RESET(st1->items);

	if (eq_bitset(st1->items, new_item)) {
		del_bitset(new_item);
		return (false);
	}

	del_bitset(st1->items);
	st1->items = new_item;

	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x646e
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x646e
movq (%rbx), %rdi
movq (%r15), %rsi
callq 0x620c
testl %eax, %eax
je 0x6483
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x22cc
movq %rax, %r14
pushq $0x1
popq %r13
movq (%rbx), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x6541
movq 0x16a09(%rip), %rcx     # 0x1ceb0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %r12
movq (%r15), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x6520
movq 0x169ec(%rip), %rcx     # 0x1ceb0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rsi
movq 0x8(%r12), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %rdx
cmpq (%rcx), %rdx
jne 0x64b0
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0x64b0
movq %r12, %rdi
callq 0x6586
cmpl $-0x1, %eax
je 0x6520
movslq %eax, %rcx
movl 0x4(%r14), %eax
cmpq %rax, %rcx
jae 0x6515
movq %r13, %rax
shlq %cl, %rax
movq 0x8(%r14), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x6520
movq %r14, %rdi
movq %rcx, %rsi
callq 0x23b9
movq (%r15), %rax
testq %rax, %rax
je 0x648f
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x6539
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
jmp 0x648f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6559
xorl %eax, %eax
cmpb $0x1, 0x54(%rdi)
jne 0x6556
movl 0x4(%rdi), %eax
decl %eax
movl %eax, 0x50(%rdi)
movq %r14, %rsi
callq 0x2566
movl %eax, %r15d
testb %al, %al
je 0x6572
movq %r14, %rdi
callq 0x2311
jmp 0x657d
movq (%rbx), %rdi
callq 0x2311
movq %r14, (%rbx)
xorb $0x1, %r15b
jmp 0x6471
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: merge_lr1_item
static int
merge_lr1_item(lr1_item_t const* llr, lr1_item_t const* rlr) {
	if (cmp_lr0_item(CORE(llr), CORE(rlr)))
		{ return (ERROR); }

	if (is_subset_bitset(llr->lookahead, rlr->lookahead))
		{ return (GET_INDEX(llr)); }
	else if (is_subset_bitset(rlr->lookahead, llr->lookahead))
		{ return (GET_INDEX(rlr)); }

	bitset_t* new_look = dup_bitset(llr->lookahead);
	UNION_BITSET(new_look, rlr->lookahead);

	size_t index = new_lr1_item(PROD(CORE(llr)), DOT(CORE(llr)), new_look);

	del_bitset(new_look);
	return (index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
movq (%rcx), %rsi
pushq $-0x1
popq %rax
cmpq (%rdx), %rsi
jne 0x6617
movq 0x8(%rcx), %rcx
cmpq 0x8(%rdx), %rcx
jne 0x6617
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x10(%r14), %rsi
callq 0x278f
testb %al, %al
je 0x65c8
movl (%rbx), %eax
jmp 0x6617
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x278f
testb %al, %al
je 0x65de
movl (%r14), %eax
jmp 0x6617
movq 0x10(%rbx), %rdi
callq 0x233f
movq %rax, %r15
movq 0x10(%r14), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0x25dd
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r15, %rdx
callq 0x63a8
movl %eax, %ebx
movq %r15, %rdi
callq 0x2311
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: goto_lr
bitset_t*
goto_lr(cfg_t const* cfg, bitset_t* item_set, symbol_t const* match_symbol) {
	if (!item_set || !match_symbol)
		{ return (NULL_BITSET); }

	bitset_t* goto_lr_state = new_bitset();

	int i = 0;
	while ((i = IT_NEXT(item_set)) != IT_NULL) {
		lr1_item_t* crt_item = (lr1_item_t*)AT_VECTOR(record_lr1_item, i);
		if (DOT(CORE(crt_item))
					&& (DOT(CORE(crt_item))->symbol_rhs == match_symbol)) {

			int index_item = new_lr1_item(PROD(CORE(crt_item)),
						DOT(CORE(crt_item))->next, crt_item->lookahead);

			if (index_item != ERROR)
				{ ADD_BITSET(goto_lr_state, (size_t)index_item); }
		}
	}

	IT_RESET(item_set);

	if (is_empty_bitset(goto_lr_state)) {
		del_bitset(goto_lr_state);
		return (NULL_BITSET);
	}

	return (closure(cfg, goto_lr_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x6df1
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x22cc
movq %rax, %r15
pushq $0x1
popq %r13
movq %r14, %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x6dca
movq 0x16143(%rip), %rcx     # 0x1ceb0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x6d59
cmpq %r12, 0x8(%rdx)
jne 0x6d59
movq (%rcx), %rdi
movq (%rdx), %rsi
movq 0x10(%rax), %rdx
callq 0x63a8
cmpl $-0x1, %eax
je 0x6d59
movslq %eax, %rcx
movl 0x4(%r15), %eax
cmpq %rax, %rcx
jae 0x6dbd
movq %r13, %rax
shlq %cl, %rax
movq 0x8(%r15), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x6d59
movq %r15, %rdi
movq %rcx, %rsi
callq 0x23b9
jmp 0x6d59
xorl %eax, %eax
cmpb $0x1, 0x54(%r14)
jne 0x6dd9
movl 0x4(%r14), %eax
decl %eax
movl %eax, 0x50(%r14)
movq %r15, %rdi
callq 0x253c
testb %al, %al
je 0x6e02
movq %r15, %rdi
callq 0x2311
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6622
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: new_lr1_state
static lr1_state_t*
new_lr1_state(bitset_t* item) {
	lr1_state_t* state = NEW(lr1_state_t, 1);
	if (!state)
		{ return (NULL); }

	memset(state, 0, sizeof(lr1_state_t));

	state->items = item;
	state->hash_items = hash_lr1_item(item);
	state->first_reach = true;

	return (state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x48
popq %rdi
callq 0x36ef
movq %rax, %rbx
testq %rax, %rax
je 0x7161
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x7169
movq %rax, 0x8(%rbx)
movb $0x1, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: hash_lr1_item
static size_t
hash_lr1_item(bitset_t* item_set) {
	if (!item_set)
		{ return (0); }

	size_t hash = 0;
	int i;

	while ((i = IT_NEXT(item_set)) != IT_NULL) {
		lr1_item_t* crt_item = (lr1_item_t*)AT_VECTOR(record_lr1_item, i);
		hash += hash_lr0_item(PROD(CORE(crt_item)), DOT(CORE(crt_item)));
	}

	IT_RESET(item_set);
	return (hash % HASH_LR);
}

// Assembly:
testq %rdi, %rdi
je 0x71e6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x32
popq %r15
movq %rbx, %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x71c0
movq 0x15d1a(%rip), %rcx     # 0x1ceb0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq (%rdx), %rax
testq %rcx, %rcx
je 0x71b6
addq 0x10(%rcx), %rax
xorl %edx, %edx
divq %r15
addq %rdx, %r14
jmp 0x7182
xorl %eax, %eax
cmpb $0x1, 0x54(%rbx)
jne 0x71cd
movl 0x4(%rbx), %eax
decl %eax
movl %eax, 0x50(%rbx)
movq %r14, %rax
xorl %edx, %edx
divq %r15
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: compute_reduce_op
void 
compute_reduce_op(cfg_t const* cfg, vector_t* lr1_states) {
	if (!cfg || !lr1_states)
		{ return; }

	for (size_t i = 0; i < SIZE_VECTOR(lr1_states); ++i) {
		lr1_state_t* state = (lr1_state_t*)AT_VECTOR(lr1_states, i);
		int j;
		while ((j = IT_NEXT(state->items)) != IT_NULL) {
			lr1_item_t* item = (lr1_item_t*)AT_VECTOR(record_lr1_item, j);
			if (CORE(item)->is_final)
				{ add_reduce_lr1(cfg, state, item, i); }
		}
		IT_RESET(state->items);
	}
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x753e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x4000, %r13d          # imm = 0x4000
xorl %r15d, %r15d
movq %rsi, -0x38(%rbp)
movq %rdi, -0x40(%rbp)
cmpq 0x10(%rsi), %r15
jae 0x7530
movq (%rsi), %rax
movq (%rax,%r15,8), %r12
movq %r15, -0x48(%rbp)
movq (%r12), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x750b
movq 0x15a7e(%rip), %rcx     # 0x1ceb0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %r14
movq 0x8(%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0x7419
movq 0x10(%r14), %rbx
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x7474
movq 0x8(%r14), %rcx
movq (%rcx), %rcx
movl (%rcx), %esi
orl %r13d, %esi
movl %eax, %edi
movq %r15, %rdx
callq 0x378a
movq %rax, %r15
jmp 0x744c
testq %rbx, %rbx
je 0x7489
xorl %eax, %eax
cmpb $0x1, 0x54(%rbx)
jne 0x7486
movl 0x4(%rbx), %eax
decl %eax
movl %eax, 0x50(%rbx)
movq %r15, -0x30(%rbp)
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdx
pushq $0x1
popq %rcx
callq 0x71e9
testb %al, %al
movq -0x48(%rbp), %r15
je 0x74c1
xorl %edi, %edi
leaq 0x334c(%rip), %rsi      # 0xa803
movq %r15, %rdx
xorl %eax, %eax
callq 0x3d00
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
pushq $0x2
popq %rcx
callq 0x71e9
testb %al, %al
je 0x74e9
xorl %edi, %edi
leaq 0x333e(%rip), %rsi      # 0xa81d
movq %r15, %rdx
xorl %eax, %eax
callq 0x3d00
movq 0x20(%r12), %rdi
movq -0x30(%rbp), %rsi
testq %rdi, %rdi
je 0x7501
callq 0x37f2
jmp 0x7419
movq %rsi, 0x20(%r12)
jmp 0x7419
movq (%r12), %rax
testq %rax, %rax
movq -0x38(%rbp), %rsi
je 0x7528
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x7525
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
incq %r15
jmp 0x7404
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_lr0_item
void
print_lr0_item(lr0_item_t* lr0_item) {
	printf("%s -> ", PROD(lr0_item)->symbol_lhs->name);
	list_rhs_t* list = PROD(lr0_item)->rhs_element;
	while (list) {
		if (list == DOT(lr0_item))
			{ printf(". "); }
		printf("%s", list->symbol_rhs->name);
		if (list->next)
			{ printf(" "); }
		list = list->next;
	}
	if (lr0_item->is_final) {
		if (PROD(lr0_item)->rhs_element)
			{ printf(" "); }
		printf(".");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x2b3e(%rip), %rdi      # 0xa0a0
xorl %eax, %eax
callq 0x20a0
movq (%rbx), %r13
addq $0x10, %r13
leaq 0x3249(%rip), %r14      # 0xa7c0
leaq 0x2a1b(%rip), %r15      # 0x9f99
pushq $0x20
popq %r12
movq (%r13), %r13
testq %r13, %r13
je 0x75be
cmpq 0x8(%rbx), %r13
jne 0x759b
movq %r14, %rdi
xorl %eax, %eax
callq 0x20a0
movq 0x8(%r13), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20a0
cmpq $0x0, (%r13)
je 0x7582
movl %r12d, %edi
callq 0x2040
jmp 0x7582
cmpb $0x1, 0x10(%rbx)
jne 0x75ec
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x75d6
pushq $0x20
popq %rdi
callq 0x2040
pushq $0x2e
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_lr1_item
void
print_lr1_item(cfg_t const* cfg, lr1_item_t* lr1_item) {
	print_lr0_item(CORE(lr1_item));
	printf(", ");
	if (is_empty_bitset(lr1_item->lookahead))
		{ printf("???"); }
	else {
		printf("[");
		int j;
		bool first = true;
		while ((j = IT_NEXT(lr1_item->lookahead)) != IT_NULL) {
			symbol_t* ter = (symbol_t*)AT_VECTOR(cfg->terminal, j);
			if (!first)
				{ printf(", "); }
			printf("%s", ter->name);
			first = false;
		}
		IT_RESET(lr1_item->lookahead);
		printf("]");
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
callq 0x753f
leaq 0x3527(%rip), %rdi      # 0xab46
xorl %eax, %eax
callq 0x20a0
movq 0x10(%rbx), %rdi
callq 0x253c
testb %al, %al
je 0x764f
leaq 0x3189(%rip), %rdi      # 0xa7c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
pushq $0x5b
popq %rdi
callq 0x2040
movb $0x1, %r13b
leaq 0x2938(%rip), %r15      # 0x9f99
movq 0x10(%rbx), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x76a4
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %r12
testb $0x1, %r13b
jne 0x7690
leaq 0x34bd(%rip), %rdi      # 0xab46
xorl %eax, %eax
callq 0x20a0
movq 0x10(%r12), %rsi
xorl %r13d, %r13d
movq %r15, %rdi
xorl %eax, %eax
callq 0x20a0
jmp 0x7661
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x76bd
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x76ba
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
pushq $0x5d
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_state
void
print_state(cfg_t const* cfg, bitset_t* item_set) {
	int back = IT_BACK(item_set);
	IT_RESET(item_set);

	int i;
	while ((i = IT_NEXT(item_set)) != IT_NULL) {
		lr1_item_t* crt_item = (lr1_item_t*)AT_VECTOR(record_lr1_item, i);
		print_lr1_item(cfg, crt_item);
		puts("");
	}
	IT_SET(item_set, back);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
cmpb $0x1, 0x54(%rsi)
jne 0x76f1
movl 0x4(%rbx), %eax
decl %eax
movl 0x50(%rbx), %r12d
movl %eax, 0x50(%rbx)
pushq $0xa
popq %r15
movq %rbx, %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x772b
movq 0x157a0(%rip), %rcx     # 0x1ceb0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x75fb
movl %r15d, %edi
callq 0x2040
jmp 0x76fc
movl %r12d, 0x50(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_report
void
print_report(cfg_t const* cfg, vector_t const* lr1_states) {
	for (size_t i = 0; i < SIZE_VECTOR(lr1_states); ++i) {
		printf("===== State %zu =====\n", i);
		lr1_state_t* state = AT_VECTOR(lr1_states, i);
		if (state->accept)
			{ printf("(Accept): "); }
		print_state(cfg, state->items);

		print_move(cfg, state->shift_lst, _SHIFT);
		print_move(cfg, state->goto_lst, _GOTO);

		trans_list_t* list = NULL;
		list = state->reduces;
		while (list) {
			printf("TOKEN(%s) => REDUCE(%d).\n",
				((symbol_t*)AT_VECTOR(cfg->terminal, list->input))->name,
				(_REDUCE ^ list->state) + 1);
			list = list->next;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4000, %r15d          # imm = 0x4000
leaq 0x3090(%rip), %r13      # 0xa7e9
xorl %r12d, %r12d
movq %rsi, -0x30(%rbp)
cmpq 0x10(%rbx), %r12
jae 0x7802
leaq 0x3056(%rip), %rdi      # 0xa7c7
movq %r12, %rsi
xorl %eax, %eax
callq 0x20a0
movq (%rbx), %rax
movq (%rax,%r12,8), %rbx
cmpb $0x1, 0x29(%rbx)
jne 0x7796
leaq 0x304f(%rip), %rdi      # 0xa7de
xorl %eax, %eax
callq 0x20a0
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x76d3
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl $0x1000, %edx           # imm = 0x1000
callq 0x7811
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movl $0x2000, %edx           # imm = 0x2000
callq 0x7811
addq $0x20, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x77f6
movq 0x10(%r14), %rax
movq (%rax), %rax
movslq 0x8(%rbx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
movl 0xc(%rbx), %edx
xorl %r15d, %edx
incl %edx
movq %r13, %rdi
xorl %eax, %eax
callq 0x20a0
jmp 0x77c7
incq %r12
movq -0x30(%rbp), %rbx
jmp 0x7760
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_move
static void
print_move(cfg_t const* cfg, trans_list_t* list, int kind) {
	char const* pattern = (kind == _SHIFT) ? "SHIFT" : "GOTO";
	vector_t const* src_vect = (kind == _SHIFT)
							? cfg->terminal : cfg->non_terminal;
	while (list) {
		if (kind & list->input) {
			printf("%s(%s)", pattern, ((symbol_t*)
				AT_VECTOR(src_vect, list->input ^ kind))->name);
		}
		printf(" into state %d.\n", list->state);
		list = list->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
xorl %eax, %eax
cmpl $0x1000, %edx           # imm = 0x1000
leaq 0x3005(%rip), %rcx      # 0xa838
leaq 0x3004(%rip), %r15      # 0xa83e
cmoveq %rcx, %r15
sete %al
movq 0x8(%rdi,%rax,8), %r13
leaq 0x2ffd(%rip), %r12      # 0xa84a
testq %r14, %r14
je 0x788e
movl 0x8(%r14), %eax
testl %ebx, %eax
je 0x787b
movq (%r13), %rcx
xorl %ebx, %eax
cltq
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdx
leaq 0x2fd2(%rip), %rdi      # 0xa843
movq %r15, %rsi
xorl %eax, %eax
callq 0x20a0
movl 0xc(%r14), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x20a0
movq (%r14), %r14
jmp 0x784d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_lr1_item
static void
del_lr1_item(lr1_item_t* item) {
	if (item) { 
		del_bitset(item->lookahead);
//		del_vector(item->non_kernel_look);
	}
	FREE(item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x78b4
movq 0x10(%rbx), %rdi
callq 0x2311
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_kernel
static void
del_kernel(kernel_t* kernel) {
	if (kernel) {
		del_bitset(kernel->kernel_item);
		if (!kernel->ref_lr0)
			{ del_vector(kernel->non_lr0_kernel_item); }
		del_bitset(kernel->final_state);
	}
	FREE(kernel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x78f0
movq (%rbx), %rdi
callq 0x2311
cmpb $0x0, 0x10(%rbx)
jne 0x78e7
movq 0x18(%rbx), %rdi
callq 0x2986
movq 0x20(%rbx), %rdi
callq 0x2311
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: new_lr0_item
static lr0_item_t*
new_lr0_item(production_t const* prod, list_rhs_t const* dot_pos) {
	if (!prod)
		{ return (NULL); }

	size_t hash = hash_lr0_item(prod, dot_pos);
	if (!record_lr0_item[hash])
		{ record_lr0_item[hash] = new_vector(); }

	for (size_t i = 0; i < SIZE_VECTOR(record_lr0_item[hash]); ++i) {
		lr0_item_t* target = (lr0_item_t*)AT_VECTOR(record_lr0_item[hash], i);
		if ((target->prod == prod) && (target->dot_pos == dot_pos))
			{ return (target); }
	}

	lr0_item_t* item = NEW(lr0_item_t, 1);
	if (!item)
		{ return (NULL); }

	memset(item, 0, sizeof(lr0_item_t));
	item->prod = prod;
	item->dot_pos = dot_pos;

	if (!DOT(item))
		{ item->is_final = true; }

	PUSH_BACK_VECTOR(record_lr0_item[hash], item);
	return (item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x79d6
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rsi, %rsi
je 0x794d
addq 0x10(%rbx), %rax
pushq $0x32
popq %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
movl %r15d, %eax
leaq 0x1555e(%rip), %r13     # 0x1cec0
movq (%r13,%rax,8), %rax
testq %rax, %rax
jne 0x7976
callq 0x28e4
movq %rax, (%r13,%r15,8)
movq 0x10(%rax), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x799a
movq (%rax), %rsi
movq (%rsi,%rdx,8), %r12
cmpq %r14, (%r12)
jne 0x7995
cmpq %rbx, 0x8(%r12)
je 0x79d9
incq %rdx
jmp 0x797c
pushq $0x20
popq %rdi
callq 0x36ef
testq %rax, %rax
je 0x79d6
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
testq %rbx, %rbx
jne 0x79c3
movb $0x1, 0x10(%r12)
movq (%r13,%r15,8), %rdi
movq 0x10(%rdi), %rsi
movq %r12, %rdx
callq 0x29d6
jmp 0x79d9
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: new_lr1_item_lr0
static lr1_item_t*
new_lr1_item_lr0(lr0_item_t* lr0_item, bitset_t const* lookahead) {
	if (!lr0_item)
		{ return (NULL); }
	if (!record_lr1_item)
		{ record_lr1_item = new_vector(); }
	lr1_item_t* item = NEW(lr1_item_t, 1);
	if (!item)
		{ return (NULL); }
	memset(item, 0, sizeof(lr1_item_t));
	item->lookahead = dup_bitset(lookahead);
	item->core = lr0_item;
	return (item);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7a43
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x154a8(%rip)     # 0x1ceb0
jne 0x7a16
callq 0x28e4
movq %rax, 0x1549a(%rip)     # 0x1ceb0
pushq $0x18
popq %rdi
callq 0x36ef
testq %rax, %rax
je 0x7a43
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x233f
movq %rax, 0x10(%r15)
movq %rbx, 0x8(%r15)
jmp 0x7a46
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: compute_look
static bitset_t*
compute_look(lr0_item_t const* item, bitset_t* before) {
	bitset_t* target_first = first_list_rhs_t(DOT(item)->next);
	if (target_first == NULL_BITSET)
		{ target_first = dup_bitset(before); }
	else if (list_is_nullable(DOT(item)->next))
		{ UNION_BITSET(target_first, before); }
	return (target_first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq (%rax), %rdi
callq 0x573e
testq %rax, %rax
je 0x7abd
movq %rax, %r14
movq 0x8(%r15), %rax
movq (%rax), %rdi
callq 0x56fc
testb %al, %al
je 0x7aaf
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25dd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x233f
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: propagate_look_lr1_symbol
static bool
propagate_look_lr1_symbol(kernel_t* kernel, vector_t* vect_look,
							symbol_t* symbol, bitset_t* base_look) {
	bool change = false;
	for (size_t i = 0; i < SIZE_VECTOR(kernel->non_lr0_kernel_item); ++i) {
		bitset_t* crt_look = (bitset_t*)AT_VECTOR(vect_look, i);
		lr0_item_t const* crt_item = (lr0_item_t const*)
								AT_VECTOR(kernel->non_lr0_kernel_item, i);

		if (LHS(PROD(crt_item)) == symbol) {
			if (!is_subset_bitset(crt_look, base_look))
				{ change = true; }
			UNION_BITSET(crt_look, base_look);
		}
	}
	return (change);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, %r12
xorl %ebx, %ebx
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %r13
movq 0x18(%r12), %rax
cmpq 0x10(%rax), %rbx
jae 0x7b4b
movq (%rax), %rax
movq (%rax,%rbx,8), %rax
movq (%rax), %rax
cmpq %r14, 0x8(%rax)
jne 0x7b46
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax,%rbx,8), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x278f
xorb $0x1, %al
movq -0x30(%rbp), %rcx
orb %al, %cl
movq %rcx, -0x30(%rbp)
xorl %edi, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x25dd
incq %rbx
jmp 0x7afc
movq -0x30(%rbp), %rax
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/gen_ll.c
// Function: gen_ll_useful_macro
void
gen_ll_useful_macro(int filde, cfg_t const* cfg) {
	dprintf(filde, DEFINE(ERROR_SLOT, 0) NL);
	dprintf(filde, DEFINE(START_SYMBOL,));
	production_t* start_prod = BACK_VECTOR(cfg->productions);
	gen_nter_symbol(filde, cfg,
			start_prod->rhs_element->symbol_rhs->index, true);
	dprintf(filde, NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x2ce8(%rip), %rsi      # 0xa85b
xorl %eax, %eax
callq 0x20f0
leaq 0x2cf0(%rip), %rsi      # 0xa871
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
movq (%rax), %rcx
movq 0x10(%rax), %rax
movq -0x8(%rcx,%rax,8), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
pushq $0x1
popq %rcx
movl %ebx, %edi
movq %r14, %rsi
callq 0x8106
leaq 0x2dc2(%rip), %rsi      # 0xa97a
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0