LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: del_production
void
del_production(production_t* prod) {
	if (prod) {
		list_rhs_t* it_list = prod->rhs_element;
		while (it_list) {
			list_rhs_t* next = it_list->next;
			FREE(it_list);
			it_list = next;
		}
		del_bitset(prod->select_set);
	}
	FREE(prod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6981
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6974
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1190
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x694f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1300
movq -0x8(%rbp), %rdi
callq 0x1190
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: add_symbol_rhs
int
add_symbol_rhs(production_t* prod, symbol_t* symbol) {
	if (!prod)
		{ return (ERROR); }

	list_rhs_t* new_list = NEW(list_rhs_t, 1);
	if (!new_list)
		{ return (ERROR); }

	memset(new_list, 0, sizeof(list_rhs_t));
	new_list->pos = 1;
	new_list->symbol_rhs = symbol;

	if (!prod->rhs_element)
		{ prod->rhs_element = new_list; }
	else {
		list_rhs_t* crt_rhs = prod->rhs_element;
		while (crt_rhs->next) {
			crt_rhs = crt_rhs->next;
			++(new_list->pos);
		}
		crt_rhs->next = new_list;
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x69b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6a5a
movl $0x18, %edi
callq 0x38b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x69d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6a5a
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x20(%rbp), %rax
movq $0x1, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x6a15
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x6a53
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6a48
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x6a21
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: add_symbol_rhs_front
int
add_symbol_rhs_front(production_t* prod, symbol_t* symbol) {
	if (!prod)
		{ return (ERROR); }

	list_rhs_t* new_list = NEW(list_rhs_t, 1);
	if (!new_list)
		{ return (ERROR); }

	memset(new_list, 0, sizeof(list_rhs_t));
	new_list->pos = 1;
	new_list->symbol_rhs = symbol;

	new_list->next = prod->rhs_element;
	prod->rhs_element = new_list;

	new_list = new_list->next;
	while (new_list) {
		++(new_list->pos);
		new_list = new_list->next;
	}

	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6a93
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b2a
movl $0x18, %edi
callq 0x38b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6ab1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b2a
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x20(%rbp), %rax
movq $0x1, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6b23
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6aff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: last_symbol_in_prod
symbol_t*
last_symbol_in_prod(production_t const* prod) {
	if (!prod)
		{ return (NULL); }
	symbol_t* last_ter = NULL;
	list_rhs_t* list = prod->rhs_element;
	while (list) {	
		if (IS_TERMINAL(list->symbol_rhs))
			{ last_ter = list->symbol_rhs; }
		list = list->next;
	}
	return (last_ter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6b59
movq $0x0, -0x8(%rbp)
jmp 0x6ba3
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6b9b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x6b8e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6b6d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: check_mimic_prod
int
check_mimic_prod(cfg_t const* cfg) {
	if (!cfg)
		{ return (ERROR); }
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
		production_t* prod = (production_t*)AT_VECTOR(cfg->productions, i);
		if (prod->mimic_sym) {
			if (!last_symbol_in_prod(prod)) {
				warnf(0, "The production %zu contain no terminal"
							" for the $MIMIC.", GET_INDEX(prod) + 1);
			}
			if (!prod->mimic_sym->prec) {
				warnf(0, "The precedence is not defined for the terminal %s.",
							prod->mimic_sym->name);
			}
		}
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6dcf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6e82
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x6e7b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6e68
movq -0x20(%rbp), %rdi
callq 0x6b40
cmpq $0x0, %rax
jne 0x6e39
movq -0x20(%rbp), %rax
movq (%rax), %rdx
addq $0x1, %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x5c5b(%rip), %rsi      # 0xca8d
movb $0x0, %al
callq 0x43c0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x6e66
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x5c65(%rip), %rsi      # 0xcac4
movb $0x0, %al
callq 0x43c0
jmp 0x6e68
jmp 0x6e6a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6dd7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: list_is_nullable
bool
list_is_nullable(list_rhs_t const* list) {
	if (!list)
		{ return (true); }
	while (list) {
		if (list->symbol_rhs->kind == T_TERMINAL)
			{ return (false); }
		else if (!list->symbol_rhs->nullable)
			{ return (false); }
		list = list->next;
	}
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6ea5
movb $0x1, -0x1(%rbp)
jmp 0x6ee9
jmp 0x6ea7
cmpq $0x0, -0x10(%rbp)
je 0x6ee5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x6ec2
movb $0x0, -0x1(%rbp)
jmp 0x6ee9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x18(%rax)
jne 0x6ed6
movb $0x0, -0x1(%rbp)
jmp 0x6ee9
jmp 0x6ed8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6ea7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6f50
movq $0x0, -0x8(%rbp)
jmp 0x7018
callq 0x1290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7010
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x6fd7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x6f9f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x1420
jmp 0x6fd5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x7010
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdx
xorl %edi, %edi
callq 0x1890
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x18(%rax)
jne 0x6ffe
jmp 0x7010
jmp 0x7000
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6f59
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x708d
movq $0x0, -0x8(%rbp)
jmp 0x70c3
jmp 0x708f
cmpq $0x0, -0x10(%rbp)
je 0x70bb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x70ae
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x70c3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x708f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x70f4
movq $0x0, -0x8(%rbp)
jmp 0x718f
callq 0x1ee0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1aa0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x7137
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x2070
jmp 0x70fd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x7144
jmp 0x7187
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
testb $0x1, 0x54(%rax)
jne 0x7168
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x7184
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x758f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7675
movq -0x10(%rbp), %rdi
callq 0x7680
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x766f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x19(%rax)
je 0x75e7
jmp 0x765e
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x16a0
testb $0x1, %al
jne 0x75fa
jmp 0x760e
movq -0x28(%rbp), %rax
testb $0x1, 0x18(%rax)
jne 0x760e
movq -0x28(%rbp), %rax
movb $0x0, 0x19(%rax)
jmp 0x7631
callq 0x1290
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7720
movq -0x30(%rbp), %rdi
callq 0x1300
movq -0x28(%rbp), %rax
testb $0x1, 0x19(%rax)
jne 0x765c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x550f(%rip), %rsi      # 0xcb5d
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x765e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x75a7
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: precompute_realizable
static void
precompute_realizable(cfg_t const* cfg) {
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
		production_t* crt_prod = (production_t*)AT_VECTOR(cfg->productions, i);
		list_rhs_t* list = crt_prod->rhs_element;
		bool whole_ter = true;
		while (list) {
			symbol_t* crt_symbol = list->symbol_rhs;
			if (!IS_TERMINAL(crt_symbol)) {
				whole_ter = false;
				break;
			}
			list = list->next;
		}
		LHS(crt_prod)->realizable = whole_ter;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7719
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x76f7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x2d, 0x8(%rax)
je 0x76ea
movb $0x0, -0x21(%rbp)
jmp 0x76f7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x76c7
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
andb $0x1, %cl
movb %cl, 0x19(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7690
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7910
movb $0x1, -0x1(%rbp)
jmp 0x79eb
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x70d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x793e
jmp 0x79da
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x79b8
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x1d20
testb $0x1, %al
jne 0x79a8
movb $0x0, -0x19(%rbp)
jmp 0x79b8
jmp 0x79aa
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x7961
testb $0x1, -0x19(%rbp)
jne 0x79c0
jmp 0x79da
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
subq $0x1, %rsi
callq 0x21a0
jmp 0x7925
movq -0x28(%rbp), %rdi
callq 0x1ff0
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7a15
jmp 0x7a93
jmp 0x7a17
movb $0x0, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7a8b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0x7a7b
movq -0x20(%rbp), %rdi
callq 0x6ef0
testb $0x1, %al
jne 0x7a63
jmp 0x7a7b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x18(%rax)
movb $0x1, -0x9(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x7a7d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7a23
jmp 0x7a8d
testb $0x1, -0x9(%rbp)
jne 0x7a17
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7ab8
jmp 0x7ba5
jmp 0x7aba
movb $0x0, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7b99
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7030
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x1c00
testb $0x1, %al
jne 0x7b7f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x7b36
callq 0x1290
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x7b51
callq 0x1290
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
xorl %edi, %edi
callq 0x1890
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rdx
xorl %edi, %edi
callq 0x1890
movb $0x1, -0x9(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1300
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7ac6
jmp 0x7b9b
testb $0x1, -0x9(%rbp)
jne 0x7aba
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7bc5
jmp 0x7c22
jmp 0x7bc7
movb $0x0, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7c1a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
callq 0x7c30
cmpl $0x0, %eax
je 0x7c0a
movb $0x1, -0x9(%rbp)
jmp 0x7c0c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7bd3
jmp 0x7c1c
testb $0x1, -0x9(%rbp)
jne 0x7bc7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_set_op.c
// Function: follow_symbol
static int
follow_symbol(symbol_t* non_ter, cfg_t* cfg) {
	bool change = false;
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
		production_t* prod = AT_VECTOR(cfg->productions, i);
		list_rhs_t const* list = prod->rhs_element;
		while ((list = match_symbol_production(list, non_ter))) {
			list = list->next;
			if (follow_symbol_rhs(prod, non_ter, list))
				{ change = true; }
		}
	}
	return (change);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7cd0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7070
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7cbd
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7ce0
cmpl $0x0, %eax
je 0x7cbb
movb $0x1, -0x11(%rbp)
jmp 0x7c7f
jmp 0x7cbf
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7c4c
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_set_op.c
// Function: follow_symbol_rhs
static int
follow_symbol_rhs(production_t const* prod, symbol_t* non_ter,
						list_rhs_t const* list) {
	while (list) {
		if (IS_TERMINAL(list->symbol_rhs)) {
			return (follow_terminal(non_ter,
					list->symbol_rhs->index));
		}
		else {
			bool change = follow_non_terminal(non_ter,
							list->symbol_rhs);
			if (!list->symbol_rhs->nullable)
				{ return (change); }
		}
		list = list->next;
	}	
	if (!is_subset_bitset(non_ter->follow, prod->symbol_lhs->follow)) {
		if (!non_ter->follow)
			{ non_ter->follow = new_bitset(); }
		UNION_BITSET(non_ter->follow, prod->symbol_lhs->follow);
		return (true);
	}
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7d6b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x7d25
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x7de0
movl %eax, -0x4(%rbp)
jmp 0x7dce
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7ee0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x18(%rax)
jne 0x7d5c
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x7dce
jmp 0x7d5e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7cf4
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rsi
callq 0x1c00
testb $0x1, %al
jne 0x7dc7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x7da3
callq 0x1290
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdx
xorl %edi, %edi
callq 0x1890
movl $0x1, -0x4(%rbp)
jmp 0x7dce
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_set_op.c
// Function: follow_terminal
static int
follow_terminal(symbol_t* non_ter, size_t ter_index) {
	if (!IS_PRESENT(non_ter->follow, ter_index)) {
		if (!non_ter->follow)
			{ non_ter->follow = new_bitset(); }
		ADD_BITSET(non_ter->follow, ter_index);
		return (true);
	}
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7e0f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x7e1b
xorl %eax, %eax
testb $0x1, %al
jne 0x7ec6
jmp 0x7e4f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x7ec6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x7e6a
callq 0x1290
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x7e91
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1420
jmp 0x7ebd
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x4(%rbp)
jmp 0x7ecd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_set_op.c
// Function: follow_non_terminal
static int
follow_non_terminal(symbol_t* non_ter, symbol_t const* nter_right) {
	if (!is_subset_bitset(non_ter->follow, nter_right->first)) {
		if (!non_ter->follow)
			{ non_ter->follow = new_bitset(); }
		UNION_BITSET(non_ter->follow, nter_right->first);
		return (true);
	}
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1c00
testb $0x1, %al
jne 0x7f44
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x7f24
callq 0x1290
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
xorl %edi, %edi
callq 0x1890
movl $0x1, -0x4(%rbp)
jmp 0x7f4b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x8003
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x7fd6
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x1d20
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x7fd4
jmp 0x8003
jmp 0x7fd6
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x78f0
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x7ff0
jmp 0x8003
jmp 0x7ff2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7f78
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8333
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1300
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3be0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3be0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3be0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1300
movq -0x8(%rbp), %rdi
callq 0x1190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1df0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1df0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0x838e
movl $0x1, -0x4(%rbp)
jmp 0x842f
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x83a1
jmp 0x83d4
movq -0x10(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0x83bd
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x83d1
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x841f
movq 0x179bd(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8440
cmpl $-0x1, %eax
jne 0x841d
movl $0x1, -0x20(%rbp)
jmp 0x841f
jmp 0x83db
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: check_exist_lr0_item
static int
check_exist_lr0_item(bitset_t* state_item, lr1_item_t* item) {
	int back = IT_BACK(state_item);
	IT_RESET(state_item);

	int find = -1;
	int i;

	while ((i = IT_NEXT(state_item)) != IT_NULL) {
		lr1_item_t* crt_item = (lr1_item_t*)AT_VECTOR(record_lr1_item, i);
		if (!cmp_lr0_item(CORE(crt_item), CORE(item))) {
			find = i;
			break;
		}
	}

	IT_SET(state_item, back);
	return (find);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8463
jmp 0x8496
movq -0x8(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0x847f
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8493
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x8(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x84e8
movq 0x178fb(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x89e0
cmpl $0x0, %eax
jne 0x84e6
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x84e8
jmp 0x849d
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_record_item
static void
del_record_item(void) {
	foreach_vector(record_lr1_item, &del_lr1_item);
	del_vector(record_lr1_item);

	for (size_t i = 0; i < HASH_LR; ++i) {
		if (!record_lr0_item[i])
			{ continue; }
		foreach_vector(record_lr0_item[i], &free);
		del_vector(record_lr0_item[i]);
	
		record_lr0_item[i] = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x17861(%rip), %rdi     # 0x1fdb0
leaq 0x1eba(%rip), %rsi      # 0xa410
callq 0x23a0
movq 0x1784e(%rip), %rdi     # 0x1fdb0
callq 0x1ff0
movq $0x0, -0x8(%rbp)
cmpq $0x32, -0x8(%rbp)
jae 0x85da
movq -0x8(%rbp), %rcx
leaq 0x1783f(%rip), %rax     # 0x1fdc0
cmpq $0x0, (%rax,%rcx,8)
jne 0x858a
jmp 0x85cc
movq -0x8(%rbp), %rcx
leaq 0x1782b(%rip), %rax     # 0x1fdc0
movq (%rax,%rcx,8), %rdi
movq 0x8a28(%rip), %rsi      # 0x10fc8
callq 0x23a0
movq -0x8(%rbp), %rcx
leaq 0x17810(%rip), %rax     # 0x1fdc0
movq (%rax,%rcx,8), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rcx
leaq 0x177fc(%rip), %rax     # 0x1fdc0
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x856f
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_record_kernel
static void
del_record_kernel(void) {
	for (size_t i = 0; i < HASH_LR; ++i) {
		if (!record_lr0_item[i])
			{ continue; }
		foreach_vector(record_kernel[i], &del_kernel);
		del_vector(record_kernel[i]);

		record_kernel[i] = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x32, -0x8(%rbp)
jae 0x865b
movq -0x8(%rbp), %rcx
leaq 0x177be(%rip), %rax     # 0x1fdc0
cmpq $0x0, (%rax,%rcx,8)
jne 0x860b
jmp 0x864d
movq -0x8(%rbp), %rcx
leaq 0x1793a(%rip), %rax     # 0x1ff50
movq (%rax,%rcx,8), %rdi
leaq 0x1e1f(%rip), %rsi      # 0xa440
callq 0x23a0
movq -0x8(%rbp), %rcx
leaq 0x1791f(%rip), %rax     # 0x1ff50
movq (%rax,%rcx,8), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rcx
leaq 0x1790b(%rip), %rax     # 0x1ff50
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x85f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x86cd
movq $-0x1, -0x8(%rbp)
jmp 0x8738
movq 0x176dc(%rip), %rdi     # 0x1fdb0
movq -0x10(%rbp), %rsi
leaq 0x1dc1(%rip), %rdx      # 0xa4a0
callq 0x22e0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x8700
movq -0x10(%rbp), %rdi
callq 0xa410
movslq -0x14(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8738
movq 0x176a9(%rip), %rax     # 0x1fdb0
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x17697(%rip), %rdi     # 0x1fdb0
movq 0x17690(%rip), %rax     # 0x1fdb0
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x2070
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: new_lr1_item_ptr
static inline lr1_item_t*
new_lr1_item_ptr(production_t const* prod,
					list_rhs_t const* dot_pos, bitset_t const* lookahead) {
	lr0_item_t* lr0_item = new_lr0_item(prod, dot_pos);
	if (!lr0_item)
		{ return (NULL); }
	return (new_lr1_item_lr0(lr0_item, lookahead));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa4f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8786
movq $0x0, -0x8(%rbp)
jmp 0x8797
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa660
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x89e0
cmpl $0x0, %eax
je 0x8a66
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8b13
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1c00
testb $0x1, %al
jne 0x8a81
jmp 0x8a90
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x8b13
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1c00
testb $0x1, %al
jne 0x8aab
jmp 0x8ab7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x8b13
jmp 0x8ab9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %edi, %edi
callq 0x1890
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x8670
cltq
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1300
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: closure
bitset_t*
closure(cfg_t const* cfg, bitset_t* item_set) {
	if (!cfg || !item_set)
		{ return (NULL_BITSET); }

	vector_t* list_kernel = split_same_derivation(item_set);
	bool is_kernel_disjoint = true;

	size_t size_kernel;
	if ((size_kernel = SIZE_VECTOR(list_kernel))) {
		for (size_t i = 0; i < size_kernel - 1; ++i) {
			kernel_t* crt_kernel = (kernel_t*)AT_VECTOR(list_kernel, i);
			kernel_t* next_kernel = (kernel_t*)AT_VECTOR(list_kernel, i + 1);

			if (!is_disjoint_bitset(crt_kernel->rprefix->first,
								next_kernel->rprefix->first)) {
				is_kernel_disjoint = false;
				break;	
			}
		}

		for (size_t i = 0; i < size_kernel; ++i) {
			kernel_t* crt_kernel = (kernel_t*)AT_VECTOR(list_kernel, i);
			UNION_BITSET(item_set, include_new_item(cfg, crt_kernel));
		}
	}
	
	if (!is_kernel_disjoint)
		{ merge_same_lr0_item(item_set);  }

	del_vector(list_kernel);
	return (item_set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8b3e
cmpq $0x0, -0x18(%rbp)
jne 0x8b4b
movq $0x0, -0x8(%rbp)
jmp 0x8c61
movq -0x18(%rbp), %rdi
callq 0x8c70
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8c41
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x8be9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rsi
callq 0x1d20
testb $0x1, %al
jne 0x8bd9
movb $0x0, -0x21(%rbp)
jmp 0x8be9
jmp 0x8bdb
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8b7a
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x8c3f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x8e20
movq -0x60(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0x1890
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x8bf1
jmp 0x8c41
testb $0x1, -0x21(%rbp)
jne 0x8c50
movq -0x18(%rbp), %rdi
callq 0x8fa0
movq -0x20(%rbp), %rdi
callq 0x1ff0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: split_same_derivation
static vector_t*
split_same_derivation(bitset_t* item_set) {
	bitset_t* symbol_seen = new_bitset();
	vector_t* kernel_lst = new_vector();

	int i;
	while ((i = IT_NEXT(item_set)) != IT_NULL) {
		lr1_item_t* crt_item = (lr1_item_t*)AT_VECTOR(record_lr1_item, i);
		if (CORE(crt_item)->is_final
				|| !IS_NON_TERMINAL(DOT(CORE(crt_item))->symbol_rhs))
			{ continue; }

		symbol_t* leftmost = DOT(CORE(crt_item))->symbol_rhs;
		if (IS_PRESENT(symbol_seen, leftmost->index))
			{ continue; }

		ADD_BITSET(symbol_seen, leftmost->index);
		kernel_t* crt_kernel = split_specific(item_set, leftmost);

		PUSH_BACK_VECTOR(kernel_lst, crt_kernel);
	}

	IT_RESET(item_set);
	del_bitset(symbol_seen);

	return (kernel_lst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1290
movq %rax, -0x10(%rbp)
callq 0x1ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x8dce
movq 0x17106(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x10(%rax)
jne 0x8cdd
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x27, 0x8(%rax)
je 0x8cdf
jmp 0x8c8e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8d0d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x8d15
xorl %eax, %eax
testb $0x1, %al
jne 0x8d4b
jmp 0x8d50
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x8d50
jmp 0x8c8e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x8d75
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x1420
jmp 0x8da3
movq -0x30(%rbp), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa740
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x2070
jmp 0x8c8e
cmpq $0x0, -0x8(%rbp)
jne 0x8dd7
jmp 0x8e0a
movq -0x8(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0x8df3
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8e07
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x8(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rdi
callq 0x1300
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: include_new_item
static bitset_t*
include_new_item(cfg_t const* cfg, kernel_t* kernel) {
	if (kernel->final_state)
		{ return (kernel->final_state); }

	closure_non_kernel_item(cfg, kernel);
	vector_t* vect_look = propagate_look_lr1(kernel);

	kernel->final_state = new_bitset();
	UNION_BITSET(kernel->final_state, kernel->kernel_item);

	for (size_t i = 0; i < SIZE_VECTOR(kernel->non_lr0_kernel_item); ++i) {
		bitset_t* lr1_look = (bitset_t*)AT_VECTOR(vect_look, i);
		lr0_item_t* lr0_item = (lr0_item_t*)
									AT_VECTOR(kernel->non_lr0_kernel_item, i);
	
		lr1_item_t* add_item = new_lr1_item_lr0(lr0_item, lr1_look);

		if (!add_item)
			{ return (NULL_BITSET); }

		int index = new_lr1_item_record(add_item);
		if (index != ERROR)
			{ ADD_BITSET(kernel->final_state, (size_t)index); }
	}

	foreach_vector(vect_look, &del_bitset);
	del_vector(vect_look);

	return (kernel->final_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8e4c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f96
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaa80
movq -0x18(%rbp), %rdi
callq 0xac20
movq %rax, -0x20(%rbp)
callq 0x1290
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
xorl %edi, %edi
callq 0x1890
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x8f71
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa660
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x8ef9
movq $0x0, -0x8(%rbp)
jmp 0x8f96
movq -0x40(%rbp), %rdi
callq 0x86b0
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
je 0x8f5e
movslq -0x44(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x8f32
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x44(%rbp), %rsi
callq 0x1420
jmp 0x8f5e
movslq -0x44(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x44(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x8f60
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8e94
movq -0x20(%rbp), %rdi
leaq -0x7c7c(%rip), %rsi     # 0x1300
callq 0x23a0
movq -0x20(%rbp), %rdi
callq 0x1ff0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq