LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: new_production
production_t*
new_production(symbol_t* lhs, cfg_t const* cfg) {
	production_t* prod = NEW(production_t, 1);

	if (!prod)
		{ return (NULL); }
	memset(prod, 0, sizeof(production_t));

	prod->symbol_lhs = lhs;
	prod->index = SIZE_VECTOR(cfg->productions);
	PUSH_BACK_VECTOR(cfg->productions, prod);

	return (prod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x30, %edi
callq 0x3b0a
testq %rax, %rax
je 0x58e8
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq %r15, 0x8(%rax)
movq (%r14), %rdi
movq 0x10(%rdi), %rsi
movq %rsi, (%rax)
movq %rax, %rdx
callq 0x2bf1
jmp 0x58ea
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5929
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5920
movq (%rdi), %r14
callq 0x21d0
movq %r14, %rdi
testq %r14, %r14
jne 0x5910
movq 0x18(%rbx), %rdi
callq 0x248a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x59a7
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x3b0a
testq %rax, %rax
je 0x59a7
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x1, 0x10(%rax)
movq %r14, 0x8(%rax)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x599a
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x59a1
movq 0x10(%rax), %rsi
movq %rdx, %rcx
incq %rsi
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x5986
movq %rsi, 0x10(%rax)
jmp 0x59a1
addq $0x10, %rbx
movq %rbx, %rcx
movq %rax, (%rcx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x5a0b
movq %rsi, %r15
movq %rdi, %r14
movl $0x18, %edi
callq 0x3b0a
testq %rax, %rax
je 0x5a0b
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x1, 0x10(%rax)
movq %r15, 0x8(%rax)
movq 0x10(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%r14)
xorl %ebx, %ebx
testq %rcx, %rcx
je 0x5a0b
incq 0x10(%rcx)
movq (%rcx), %rcx
jmp 0x59fd
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x5a45
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x5a45
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq 0x8(%rcx), %rdx
movq (%rcx), %rsi
cmpl $0x2d, 0x8(%rdx)
cmoveq %rdx, %rax
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x5a2c
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: preprocess_literal
int
preprocess_literal(cfg_t const* cfg) {
	if (!cfg)
		{ return (ERROR); }

	int is_error = DONE;
	for (size_t i = 0; i < SIZE_VECTOR(cfg->terminal); ++i) {
		symbol_t* literal = (symbol_t*)AT_VECTOR(cfg->terminal, i);
		if (literal->kind == T_LITERAL) {
			symbol_t* ter = (symbol_t*)AT_VECTOR(cfg->terminal,
										literal->terminal_alias);
			if (!ter->prec) {
				literal->share_prec = true;
				ter->prec = literal->prec;
			}

			if (ter->prec != literal->prec) {
				errorf(0, "The terminal %s has %s alias with different"
							" precedence.", ter->name, literal->name);
				literal->share_prec = false;
				is_error = ERROR;
			}
		}
	}

	if (is_error == ERROR)
		{ 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 && (prod->mimic_sym->kind == T_LITERAL)) {
			prod->mimic_sym = (symbol_t*)AT_VECTOR(cfg->terminal,
											prod->mimic_sym->terminal_alias);
		}
		list_rhs_t* list = prod->rhs_element;
		while (list) {
			if (list->symbol_rhs->kind == T_LITERAL) {
				list->symbol_rhs = (symbol_t*)AT_VECTOR(cfg->terminal,
										list->symbol_rhs->terminal_alias);
			}
			list = list->next;
		}
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x5b4f
movq %rdi, %r14
movq 0x10(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x0, 0x10(%rax)
je 0x5ae5
leaq 0x4c26(%rip), %r15      # 0xa6a1
xorl %ecx, %ecx
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
cmpl $0x28, 0x8(%r13)
jne 0x5ad2
movslq 0x18(%r13), %rdx
movq (%rax,%rdx,8), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5aaa
movb $0x1, 0x1c(%r13)
movq 0x20(%r13), %rdx
movq %rdx, 0x20(%rax)
movq 0x20(%rax), %rdx
cmpq 0x20(%r13), %rdx
je 0x5ad2
movq 0x10(%rax), %rdx
movq 0x10(%r13), %rcx
xorl %edi, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4020
movb $0x0, 0x1c(%r13)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incq %r12
movq 0x10(%r14), %rax
cmpq 0x10(%rax), %r12
jb 0x5a80
cmpl $-0x1, %ecx
sete %cl
testb %cl, %cl
jne 0x5b4f
movq (%r14), %rdx
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x5b4d
movq (%rdx), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq 0x28(%rdi), %r8
testq %r8, %r8
je 0x5b1d
cmpl $0x28, 0x8(%r8)
jne 0x5b1d
movq (%rax), %r9
movslq 0x18(%r8), %r8
movq (%r9,%r8,8), %r8
movq %r8, 0x28(%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x5b45
movq 0x8(%rdi), %r8
cmpl $0x28, 0x8(%r8)
jne 0x5b40
movq (%rax), %r9
movslq 0x18(%r8), %r8
movq (%r9,%r8,8), %r8
movq %r8, 0x8(%rdi)
movq (%rdi), %rdi
jmp 0x5b21
incq %rsi
cmpq %rcx, %rsi
jne 0x5afa
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x5c1e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
cmpq $0x0, 0x10(%rax)
je 0x5c0d
leaq 0x4b4a(%rip), %r14      # 0xa6d9
leaq 0x4b7a(%rip), %r15      # 0xa710
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
cmpq $0x0, 0x28(%r13)
je 0x5c01
testq %r13, %r13
je 0x5bd3
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x5bd3
xorl %ecx, %ecx
movq 0x8(%rax), %rdx
movq (%rax), %rsi
cmpl $0x2d, 0x8(%rdx)
cmoveq %rdx, %rcx
movq %rsi, %rax
testq %rsi, %rsi
jne 0x5bb7
testq %rcx, %rcx
jne 0x5be6
movq (%r13), %rdx
incq %rdx
xorl %edi, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x22b9
movq 0x28(%r13), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5c01
movq 0x10(%rax), %rdx
xorl %edi, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x22b9
incq %r12
movq (%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x5b99
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb $0x1, %al
testq %rdi, %rdi
je 0x5c4c
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
cmpl $0x2d, 0x8(%rcx)
je 0x5c49
cmpb $0x1, 0x18(%rcx)
jne 0x5c49
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x5c2f
jmp 0x5c4b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5cc5
movq %rdi, %r14
callq 0x243c
movq %rax, %rbx
movq 0x8(%r14), %rax
cmpl $0x2d, 0x8(%rax)
je 0x5cc9
movq 0x20(%rax), %rdx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x27c9
movq 0x8(%r14), %rax
cmpb $0x1, 0x18(%rax)
jne 0x5cf5
movq (%r14), %r14
testq %r14, %r14
jne 0x5c99
jmp 0x5cf5
xorl %ebx, %ebx
jmp 0x5cf5
movq (%rax), %rcx
movl 0x4(%rbx), %eax
cmpq %rax, %rcx
jae 0x5cea
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rbx), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x5cf5
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2568
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5d32
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
cmpq %rsi, 0x8(%rax)
je 0x5d30
movq (%rax), %rax
testq %rax, %rax
jne 0x5d20
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5d95
movq %rsi, %r14
movq %rdi, %r15
callq 0x2afc
movq %rax, %rbx
movq 0x30(%r14), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x5d7a
movq 0x10(%rbx), %rsi
movq (%r15), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rdx
movq %rbx, %rdi
callq 0x2bf1
jmp 0x5d52
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x5d97
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x5d90
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
jmp 0x5d97
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x60d0
movq %rdi, %rbx
movq (%rdi), %rcx
cmpq $0x0, 0x10(%rcx)
je 0x6031
xorl %eax, %eax
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x10(%rcx), %rsi
movb $0x1, %dl
testq %rsi, %rsi
je 0x601b
movq 0x8(%rsi), %rdi
movl 0x8(%rdi), %edi
cmpl $0x2d, %edi
jne 0x6014
movq (%rsi), %rsi
jmp 0x6016
xorl %edx, %edx
cmpl $0x2d, %edi
je 0x5ffe
movq 0x8(%rcx), %rcx
andb $0x1, %dl
movb %dl, 0x19(%rcx)
incq %rax
movq (%rbx), %rcx
cmpq 0x10(%rcx), %rax
jb 0x5ff1
movq 0x8(%rbx), %rax
xorl %r15d, %r15d
cmpq $0x1, 0x10(%rax)
je 0x60d6
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rax), %rax
movq (%rax,%r14,8), %r12
cmpb $0x0, 0x19(%r12)
jne 0x60b7
movq 0x20(%r12), %rdi
callq 0x26e5
testb %al, %al
je 0x606e
cmpb $0x0, 0x18(%r12)
je 0x608e
callq 0x243c
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x60e8
movq %r13, %rdi
callq 0x248a
jmp 0x6094
movb $0x0, 0x19(%r12)
cmpb $0x0, 0x19(%r12)
jne 0x60b7
movq 0x10(%r12), %rdx
xorl %edi, %edi
leaq 0x46ff(%rip), %rsi      # 0xa7a9
xorl %eax, %eax
callq 0x4020
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incq %r14
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r14
jb 0x6049
jmp 0x60d6
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
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_O1/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, %r14
testq %rdx, %rdx
je 0x6127
movq (%r15), %rax
movl 0x4(%rbx), %ecx
cmpq %rcx, %rax
jae 0x6127
movq 0x8(%rbx), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jb 0x612e
cmpb $0x1, 0x19(%r15)
jne 0x6137
addq $0x19, %r15
jmp 0x61e1
movq (%r15), %rcx
movl 0x4(%rbx), %eax
cmpq %rax, %rcx
jae 0x6158
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rbx), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x6163
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2568
leaq 0x19(%r15), %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d35
movq %rax, %rdi
cmpq $0x0, 0x10(%rax)
je 0x61d8
xorl %r13d, %r13d
movq %rdi, -0x38(%rbp)
movq (%rdi), %rax
movq (%rax,%r13,8), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x61d1
movb $0x1, %r15b
movq 0x8(%r12), %rsi
cmpl $0x27, 0x8(%rsi)
jne 0x61b3
movq %r14, %rdi
movq %rbx, %rdx
callq 0x60e8
andb %al, %r15b
movq (%r12), %r12
testq %r12, %r12
jne 0x619a
testb $0x1, %r15b
movq -0x38(%rbp), %rdi
jne 0x61d1
incq %r13
cmpq 0x10(%rdi), %r13
jb 0x6187
jmp 0x61d8
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
callq 0x2b9e
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6284
callq 0x5d35
movq %rax, %r14
movq 0x10(%rax), %rax
movb $0x1, %bl
testq %rax, %rax
je 0x627a
xorl %r15d, %r15d
cmpq $0x1, 0x10(%r14)
je 0x625d
movq (%r14), %rcx
movq -0x8(%rcx,%rax,8), %r12
xorl %r13d, %r13d
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movq 0x18(%r12), %rdi
movq 0x18(%rax), %rsi
callq 0x2a05
movzbl %bl, %ebx
testb %al, %al
cmovel %r15d, %ebx
je 0x625d
incq %r13
movq 0x10(%r14), %rax
decq %rax
cmpq %rax, %r13
jb 0x622e
testb $0x1, %bl
je 0x627a
movq 0x10(%r14), %rsi
decq %rsi
movq %r14, %rdi
callq 0x2c7d
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0x621c
movq %r14, %rdi
callq 0x2b9e
jmp 0x6286
movb $0x1, %bl
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x6302
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x62fa
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r14
cmpb $0x0, 0x20(%r14)
jne 0x62e8
movq %r14, %rdi
callq 0x5c4d
testb %al, %al
je 0x62e8
movq 0x8(%r14), %rax
movb $0x1, %r15b
movb %r15b, 0x18(%rax)
movb %r15b, 0x20(%r14)
incq %r12
movq (%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x62bf
testb $0x1, %r15b
jne 0x62af
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x63ce
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x63c0
xorl %r13d, %r13d
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r15
movq %r15, %rdi
callq 0x5cfd
movq %rax, %r14
movq 0x18(%r15), %rdi
movq %rax, %rsi
callq 0x298e
testb %al, %al
jne 0x639e
movq 0x8(%r15), %rax
cmpq $0x0, 0x20(%rax)
jne 0x636b
callq 0x243c
movq 0x8(%r15), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, 0x18(%r15)
jne 0x637b
callq 0x243c
movq %rax, 0x18(%r15)
movq 0x8(%r15), %rax
movq 0x20(%rax), %rsi
xorl %edi, %edi
movq %r14, %rdx
callq 0x27c9
movq 0x18(%r15), %rsi
xorl %edi, %edi
movq %r14, %rdx
callq 0x27c9
movb $0x1, %r13b
movq %r14, %rdi
callq 0x248a
incq %r12
movq (%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x6331
testb $0x1, %r13b
jne 0x631d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x65d8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x50(%rbp)
movq 0x8(%rdi), %rax
cmpq $0x0, 0x10(%rax)
je 0x65ca
xorl %edx, %edx
xorl %esi, %esi
movq (%rdi), %rcx
cmpq $0x0, 0x10(%rcx)
je 0x65af
movl %esi, -0x34(%rbp)
movq (%rax), %rax
movq %rdx, -0x48(%rbp)
movq (%rax,%rdx,8), %r14
movq $0x0, -0x30(%rbp)
xorl %edx, %edx
movq (%rcx), %rax
movq %rdx, -0x58(%rbp)
movq (%rax,%rdx,8), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x5d14
testq %rax, %rax
je 0x6580
movq (%rax), %r13
testq %r13, %r13
je 0x64b3
movq %r13, %r15
movq 0x8(%r15), %rbx
cmpl $0x2d, 0x8(%rbx)
je 0x64f9
movq 0x28(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x298e
xorl %ecx, %ecx
testb %al, %al
jne 0x649a
cmpq $0x0, 0x28(%r14)
jne 0x6486
callq 0x243c
movq %rax, 0x28(%r14)
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdx
xorl %edi, %edi
callq 0x27c9
movl $0x1, %ecx
movq 0x8(%r15), %rax
movb 0x18(%rax), %al
testb %al, %al
cmovel %ecx, %r12d
cmpb $0x1, %al
jne 0x6524
movq (%r15), %r15
testq %r15, %r15
jne 0x6455
movq 0x28(%r14), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rsi
callq 0x298e
testb %al, %al
jne 0x6578
cmpq $0x0, 0x28(%r14)
jne 0x64e0
callq 0x243c
movq %rax, 0x28(%r14)
movq 0x28(%r14), %rsi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdx
xorl %edi, %edi
callq 0x27c9
jmp 0x6572
movq (%rbx), %r12
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x653c
movl 0x4(%rax), %ecx
cmpq %rcx, %r12
jae 0x6545
movq 0x8(%rax), %rax
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r12, %rax
jb 0x6578
jmp 0x6545
testl %r12d, %r12d
movq -0x30(%rbp), %rcx
movzbl %cl, %ecx
movl $0x1, %eax
cmovnel %eax, %ecx
movq %rcx, -0x30(%rbp)
jmp 0x6578
callq 0x243c
movq %rax, 0x28(%r14)
movq 0x28(%r14), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %r12
jae 0x656a
movl $0x1, %eax
movl %r12d, %ecx
shlq %cl, %rax
movq 0x8(%rdi), %rcx
shrq $0x6, %r12
orq %rax, (%rcx,%r12,8)
jmp 0x6572
movq %r12, %rsi
callq 0x2568
movb $0x1, %al
movq %rax, -0x30(%rbp)
movq %r13, %rdi
jmp 0x6439
movq -0x58(%rbp), %rdx
incq %rdx
movq -0x50(%rbp), %rdi
movq (%rdi), %rcx
cmpq 0x10(%rcx), %rdx
jb 0x6426
testb $0x1, -0x30(%rbp)
movl -0x34(%rbp), %esi
movzbl %sil, %esi
movl $0x1, %eax
cmovnel %eax, %esi
movq -0x48(%rbp), %rdx
incq %rdx
movq 0x8(%rdi), %rax
cmpq 0x10(%rax), %rdx
jb 0x6400
testb $0x1, %sil
jne 0x63ed
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq 0x8(%rdi), %rcx
movb $0x1, %al
cmpq $0x1, 0x10(%rcx)
je 0x6640
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rcx), %rax
movq (%rax,%r15,8), %r14
cmpb $0x1, 0x18(%r14)
jne 0x6618
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rsi
callq 0x2a05
testb %al, %al
je 0x6627
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61f3
movl %eax, %ecx
jmp 0x6629
xorl %ecx, %ecx
testb %cl, %cl
je 0x6640
incq %r15
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rdx
decq %rdx
cmpq %rdx, %r15
jb 0x65f9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
callq 0x2afc
movq %rax, %r14
movq 0x8(%rbx), %rax
cmpq $0x1, 0x10(%rax)
je 0x67c5
xorl %edx, %edx
movq (%rax), %rax
movq %rdx, -0x30(%rbp)
movq (%rax,%rdx,8), %r13
movq 0x10(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2bf1
movq 0x30(%r13), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x6791
movl %eax, %r15d
movq (%rbx), %rax
movq (%rax), %rax
movslq %r15d, %rcx
movq (%rax,%rcx,8), %r12
movq 0x18(%r12), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x66f0
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 0x3bab
movq (%r14), %rcx
movq 0x10(%r14), %rdx
movq %rax, -0x8(%rcx,%rdx,8)
jmp 0x66b0
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x670a
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x6707
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
cmpb $0x1, 0x20(%r12)
jne 0x677c
movq 0x8(%r12), %rax
movq 0x28(%rax), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x675e
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 0x3bab
movq (%r14), %rcx
movq 0x10(%r14), %rdx
movq -0x8(%rcx,%rdx,8), %rsi
movq %rsi, (%rax)
movq %rax, -0x8(%rcx,%rdx,8)
jmp 0x6712
movq 0x8(%r12), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x677c
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x6779
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
movq 0x30(%r13), %rdi
callq 0x28eb
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0x66a3
movq 0x30(%r13), %rax
testq %rax, %rax
movq -0x30(%rbp), %rdx
je 0x67ae
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x67ab
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
incq %rdx
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %rdx
jb 0x6675
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_O1/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 0x6812
movq (%rbx), %rdi
callq 0x248a
movq 0x10(%rbx), %rdi
callq 0x3c76
movq 0x18(%rbx), %rdi
callq 0x3c76
movq 0x20(%rbx), %rdi
callq 0x3c76
movq 0x40(%rbx), %rdi
callq 0x248a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/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 0x2a59
movq %rax, %r12
movq %r14, %rdi
callq 0x2a59
movl $0x1, %r15d
cmpq %rax, %r12
jne 0x691f
movl 0x50(%rbx), %eax
movl %eax, -0x2c(%rbp)
testq %rbx, %rbx
je 0x686e
xorl %eax, %eax
cmpb $0x1, 0x54(%rbx)
jne 0x686b
movl 0x4(%rbx), %eax
decl %eax
movl %eax, 0x50(%rbx)
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x6919
movq 0x16617(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %r13
movl 0x50(%r14), %eax
movl %eax, -0x30(%rbp)
testq %r14, %r14
je 0x68b1
xorl %eax, %eax
cmpb $0x1, 0x54(%r14)
jne 0x68ad
movl 0x4(%r14), %eax
decl %eax
movl %eax, 0x50(%r14)
movq %rbx, %r12
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x68fd
movq 0x165d3(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%r13), %rdx
movq (%rcx), %rsi
cmpq (%rdx), %rsi
je 0x68eb
xorl %ecx, %ecx
jmp 0x68f6
movq 0x8(%rcx), %rcx
cmpq 0x8(%rdx), %rcx
sete %cl
testb %cl, %cl
cmovnel %eax, %ebx
je 0x68b9
movl -0x30(%rbp), %eax
movl %eax, 0x50(%r14)
cmpl $-0x1, %ebx
movl $0x1, %eax
cmovel %eax, %r15d
movq %r12, %rbx
jne 0x6871
movl -0x2c(%rbp), %eax
movl %eax, 0x50(%rbx)
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_O1/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 0x6a66
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x16467(%rip), %rdi     # 0x1cea0
leaq 0x16e4(%rip), %rdx      # 0x8124
movq %rbx, %rsi
callq 0x2d0a
cmpl $-0x1, %eax
je 0x6a6e
movl %eax, %r14d
movq 0x10(%rbx), %rdi
callq 0x248a
movq %rbx, %rdi
callq 0x21d0
movslq %r14d, %rax
jmp 0x6a87
movq $-0x1, %rax
retq
movq 0x1642b(%rip), %rdi     # 0x1cea0
movq 0x10(%rdi), %rsi
movq %rsi, (%rbx)
movq %rbx, %rdx
callq 0x2bf1
movq (%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ac9
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x6ac9
movq (%rbx), %rdi
movq (%r15), %rsi
callq 0x6820
testl %eax, %eax
je 0x6ade
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x243c
movq %rax, %r14
movq (%rbx), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x6baf
movq 0x163a2(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %r12
movq (%r15), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x6b8e
movq 0x16385(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rsi
movq 0x8(%r12), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %rdx
cmpq (%rcx), %rdx
je 0x6b3a
xorl %r13d, %r13d
jmp 0x6b46
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
sete %r13b
testb %r13b, %r13b
je 0x6b07
movq %r12, %rdi
callq 0x6bf4
cmpl $-0x1, %eax
je 0x6b85
movslq %eax, %rcx
movl 0x4(%r14), %eax
cmpq %rax, %rcx
jae 0x6b7a
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%r14), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x6b85
movq %r14, %rdi
movq %rcx, %rsi
callq 0x2568
testb %r13b, %r13b
je 0x6b07
movq (%r15), %rax
testq %rax, %rax
je 0x6ae6
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x6ba7
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
jmp 0x6ae6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6bc7
xorl %eax, %eax
cmpb $0x1, 0x54(%rdi)
jne 0x6bc4
movl 0x4(%rdi), %eax
decl %eax
movl %eax, 0x50(%rdi)
movq %r14, %rsi
callq 0x2726
movl %eax, %r15d
testb %al, %al
je 0x6be0
movq %r14, %rdi
callq 0x248a
jmp 0x6beb
movq (%rbx), %rdi
callq 0x248a
movq %r14, (%rbx)
xorb $0x1, %r15b
jmp 0x6acc
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq (%rdx), %rsi
jne 0x6c87
movq 0x8(%rcx), %rcx
cmpq 0x8(%rdx), %rcx
jne 0x6c87
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x10(%r14), %rsi
callq 0x298e
testb %al, %al
je 0x6c38
movl (%rbx), %eax
jmp 0x6c87
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x298e
testb %al, %al
je 0x6c4e
movl (%r14), %eax
jmp 0x6c87
movq 0x10(%rbx), %rdi
callq 0x24b8
movq %rax, %r15
movq 0x10(%r14), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0x27c9
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r15, %rdx
callq 0x69f6
movl %eax, %ebx
movq %r15, %rdi
callq 0x248a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x74e0
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x243c
movq %rax, %r15
movq %r14, %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x74b9
movq 0x15a46(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x7446
cmpq %r12, 0x8(%rdx)
jne 0x7446
movq (%rcx), %rdi
movq (%rdx), %rsi
movq 0x10(%rax), %rdx
callq 0x69f6
cmpl $-0x1, %eax
je 0x7446
movslq %eax, %rcx
movl 0x4(%r15), %eax
cmpq %rax, %rcx
jae 0x74ac
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%r15), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x7446
movq %r15, %rdi
movq %rcx, %rsi
callq 0x2568
jmp 0x7446
xorl %eax, %eax
cmpb $0x1, 0x54(%r14)
jne 0x74c8
movl 0x4(%r14), %eax
decl %eax
movl %eax, 0x50(%r14)
movq %r15, %rdi
callq 0x26e5
testb %al, %al
je 0x74eb
movq %r15, %rdi
callq 0x248a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6c92
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x48, %edi
callq 0x3b0a
testq %rax, %rax
je 0x7896
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x40(%rax)
movq %r14, (%rax)
movq %r14, %rdi
callq 0x78a0
movq %rax, 0x8(%rbx)
movb $0x1, 0x38(%rbx)
jmp 0x7898
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x7943
movq %rdi, %rbx
callq 0x28eb
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpl $-0x1, %eax
je 0x7930
movabsq $-0x5c28f5c28f5c28f5, %r12 # imm = 0xA3D70A3D70A3D70B
movq 0x155c8(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq (%rcx), %rcx
testq %rax, %rax
je 0x78f8
addq 0x10(%rax), %rcx
movq %rcx, %rax
shrq %rax
mulq %r12
shrq $0x4, %rdx
imulq $0x32, %rdx, %rax
subq %rax, %rcx
addq %rcx, %r14
movq %rbx, %rdi
callq 0x28eb
cmpl $-0x1, %eax
jne 0x78d1
movq %r14, %rax
shrq %rax
mulq %r12
shrq $0x4, %rdx
imulq $0x32, %rdx, %rax
subq %rax, %r14
cmpb $0x1, 0x54(%rbx)
jne 0x793d
movl 0x4(%rbx), %r15d
decl %r15d
movl %r15d, 0x50(%rbx)
jmp 0x7946
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7d4e
cmpq $0x0, 0x10(%rsi)
je 0x7d4e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x4000, %ebx           # imm = 0x4000
xorl %r13d, %r13d
movq %rsi, -0x38(%rbp)
movq %rdi, -0x40(%rbp)
movq (%rsi), %rax
movq (%rax,%r13,8), %r12
movq (%r12), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x7d16
movq %r13, -0x48(%rbp)
movq 0x1527f(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %r14
movq 0x8(%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0x7d04
movq 0x10(%r14), %r13
movq %r13, %rdi
callq 0x28eb
xorl %r15d, %r15d
cmpl $-0x1, %eax
je 0x7c6e
movq 0x8(%r14), %rcx
movq (%rcx), %rcx
movl (%rcx), %esi
orl %ebx, %esi
movl %eax, %edi
movq %r15, %rdx
callq 0x3bab
movq %rax, %r15
movq %r13, %rdi
callq 0x28eb
jmp 0x7c47
testq %r13, %r13
je 0x7c86
xorl %eax, %eax
cmpb $0x1, 0x54(%r13)
jne 0x7c82
movl 0x4(%r13), %eax
decl %eax
movl %eax, 0x50(%r13)
movq %r15, -0x30(%rbp)
movq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdx
movl $0x1, %ecx
callq 0x7952
testb %al, %al
movq -0x48(%rbp), %r13
je 0x7cc0
xorl %edi, %edi
leaq 0x2b5f(%rip), %rsi      # 0xa815
movq %r13, %rdx
xorl %eax, %eax
callq 0x22b9
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x2, %ecx
callq 0x7952
testb %al, %al
je 0x7cea
xorl %edi, %edi
leaq 0x2b4f(%rip), %rsi      # 0xa82f
movq %r13, %rdx
xorl %eax, %eax
callq 0x22b9
movq 0x20(%r12), %rdi
movq -0x30(%rbp), %rsi
testq %rdi, %rdi
je 0x7cff
callq 0x3c1e
jmp 0x7d04
movq %rsi, 0x20(%r12)
movq (%r12), %rdi
callq 0x28eb
cmpl $-0x1, %eax
jne 0x7c1a
movq (%r12), %rax
testq %rax, %rax
movq -0x38(%rbp), %rsi
je 0x7d33
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x7d30
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
incq %r13
cmpq 0x10(%rsi), %r13
jb 0x7bfd
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x235d(%rip), %rdi      # 0xa0cc
xorl %eax, %eax
callq 0x20a0
movq (%rbx), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x7dcd
leaq 0x2a49(%rip), %r14      # 0xa7d2
leaq 0x2222(%rip), %r15      # 0x9fb2
cmpq 0x8(%rbx), %r12
jne 0x7da0
movq %r14, %rdi
xorl %eax, %eax
callq 0x20a0
movq 0x8(%r12), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20a0
cmpq $0x0, (%r12)
je 0x7dc4
movl $0x20, %edi
callq 0x2040
movq (%r12), %r12
testq %r12, %r12
jne 0x7d90
cmpb $0x1, 0x10(%rbx)
jne 0x7df9
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x7de7
movl $0x20, %edi
callq 0x2040
movl $0x2e, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7d4f
leaq 0x2d32(%rip), %rdi      # 0xab58
xorl %eax, %eax
callq 0x20a0
movq 0x10(%rbx), %rdi
callq 0x26e5
testb %al, %al
je 0x7e56
leaq 0x2994(%rip), %rdi      # 0xa7d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
movl $0x5b, %edi
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x7eb9
movb $0x1, %r13b
leaq 0x213a(%rip), %r15      # 0x9fb2
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %r12
testb $0x1, %r13b
jne 0x7e99
leaq 0x2cc6(%rip), %rdi      # 0xab58
xorl %eax, %eax
callq 0x20a0
movq 0x10(%r12), %rsi
xorl %r13d, %r13d
movq %r15, %rdi
xorl %eax, %eax
callq 0x20a0
movq 0x10(%rbx), %rdi
callq 0x28eb
cmpl $-0x1, %eax
jne 0x7e78
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x7ed2
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x7ecf
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
movl $0x5d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x50(%rsi), %r15d
testq %rsi, %rsi
je 0x7f37
xorl %eax, %eax
cmpb $0x1, 0x54(%rbx)
jne 0x7f10
movl 0x4(%rbx), %eax
decl %eax
movl %eax, 0x50(%rbx)
jmp 0x7f37
movq 0x14f84(%rip), %rcx     # 0x1cea0
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x7e02
movl $0xa, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x28eb
cmpl $-0x1, %eax
jne 0x7f15
movl %r15d, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq