LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: merge_same_lr0_item
static void
merge_same_lr0_item(bitset_t* item_set) {
	int i;
	while ((i = IT_NEXT(item_set)) != IT_NULL) {
		lr1_item_t* target_item = AT_VECTOR(record_lr1_item, i);
		int j;

		int back = IT_BACK(item_set);
		while ((j = IT_NEXT(item_set)) != IT_NULL) {
			lr1_item_t* old_item = AT_VECTOR(record_lr1_item, j);
			if (!cmp_lr0_item(CORE(target_item), CORE(old_item))) {
				int new_index = merge_lr1_item(target_item, old_item);

				OFF_BITSET(item_set, (size_t)i);
				OFF_BITSET(item_set, (size_t)j);

				if (new_index != -1)
					{ ADD_BITSET(item_set, (size_t)new_index); }
				break;
			}
		}

		IT_SET(item_set, back);
	}
	IT_RESET(item_set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1aa0
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x9119
movq 0x16de8(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x910a
movq 0x16db3(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x89e0
cmpl $0x0, %eax
jne 0x9105
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8a30
movl %eax, -0x2c(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x904c
jmp 0x9078
movslq -0xc(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
xorq $-0x1, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
shrq $0x6, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x908a
jmp 0x90b6
movslq -0x1c(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
xorq $-0x1, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shrq $0x6, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
cmpl $-0x1, -0x2c(%rbp)
je 0x9103
movslq -0x2c(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x90db
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1420
jmp 0x9103
movslq -0x2c(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x910a
jmp 0x8fe1
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
jmp 0x8fac
cmpq $0x0, -0x8(%rbp)
jne 0x9122
jmp 0x9155
movq -0x8(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0x913e
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x9152
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x8(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x30(%rbp)
movl -0x30(%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: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9182
cmpq $0x0, -0x20(%rbp)
jne 0x918f
movq $0x0, -0x8(%rbp)
jmp 0x92e0
callq 0x1290
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
je 0x9271
movq 0x16bf5(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x926c
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x926c
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x8670
movl %eax, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
je 0x926a
movslq -0x3c(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x9242
movq -0x28(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x1420
jmp 0x926a
movslq -0x3c(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x926c
jmp 0x919f
cmpq $0x0, -0x18(%rbp)
jne 0x927a
jmp 0x92ad
movq -0x18(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0x9296
movq -0x18(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x92aa
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x18(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq -0x28(%rbp), %rdi
callq 0x16a0
testb $0x1, %al
jne 0x92bc
jmp 0x92cf
movq -0x28(%rbp), %rdi
callq 0x1300
movq $0x0, -0x8(%rbp)
jmp 0x92e0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8b20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x48, %edi
callq 0x38b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x968b
movq $0x0, -0x8(%rbp)
jmp 0x96ca
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x10b0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x98d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x38(%rax)
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/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x98f0
movq $0x0, -0x8(%rbp)
jmp 0x9995
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x9947
movq 0x164a0(%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
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xa700
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x98f8
cmpq $0x0, -0x10(%rbp)
jne 0x9950
jmp 0x9983
movq -0x10(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0x996c
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9980
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rax
movl $0x32, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: handle_accept_conflict
static bool
handle_accept_conflict(cfg_t const* cfg, trans_list_t** reduce_list) {
	bool reach_end = false;
	bool once = false;

	while (!reach_end) {
		trans_list_t* reset_list = (*reduce_list);
		while (reset_list) {
			symbol_t* shift_sym = (symbol_t*)AT_VECTOR(cfg->terminal,
												reset_list->input);
			if (shift_sym->is_eof) {
				del_node_trans_list(reduce_list, reset_list);
				once = true;
				break;
			}

			reset_list = reset_list->next;
		}
		if (!reset_list)
			{ reach_end = true; }
	}
	return (once);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movb -0x11(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9d93
jmp 0x9df7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9dea
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x9ddd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3b40
movb $0x1, -0x12(%rbp)
jmp 0x9dea
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9d9e
cmpq $0x0, -0x20(%rbp)
jne 0x9df5
movb $0x1, -0x11(%rbp)
jmp 0x9d88
movb -0x12(%rbp), %al
andb $0x1, %al
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: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9e2e
cmpq $0x0, -0x10(%rbp)
jne 0x9e33
jmp 0x9f0b
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9f0b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1aa0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x9eaf
movq 0x15f35(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x10(%rax)
je 0x9ead
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x9f20
jmp 0x9e60
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9ebb
jmp 0x9efa
movq -0x20(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x54(%rax)
jne 0x9edd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x9ef7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9e3b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x24fe(%rip), %rdi      # 0xc480
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9ffa
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9fbb
leaq 0x2bd2(%rip), %rdi      # 0xcb86
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x2394(%rip), %rdi      # 0xc362
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9fed
leaq 0x2385(%rip), %rdi      # 0xc36b
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9f98
movq -0x8(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0xa02e
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xa020
leaq 0x2352(%rip), %rdi      # 0xc36b
movb $0x0, %al
callq 0x1090
leaq 0x26aa(%rip), %rdi      # 0xc6d1
movb $0x0, %al
callq 0x1090
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: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9f60
leaq 0x2ea8(%rip), %rdi      # 0xcf0c
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x16a0
testb $0x1, %al
jne 0xa07e
jmp 0xa091
leaq 0x2b04(%rip), %rdi      # 0xcb89
movb $0x0, %al
callq 0x1090
jmp 0xa15d
leaq 0x2e25(%rip), %rdi      # 0xcebd
movb $0x0, %al
callq 0x1090
movb $0x1, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1aa0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0xa0ff
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xa0e3
leaq 0x2e30(%rip), %rdi      # 0xcf0c
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x2270(%rip), %rdi      # 0xc362
movb $0x0, %al
callq 0x1090
movb $0x0, -0x15(%rbp)
jmp 0xa0a3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xa10c
jmp 0xa14f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
testb $0x1, 0x54(%rax)
jne 0xa130
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xa14c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0x1fb1(%rip), %rdi      # 0xc107
movb $0x0, %al
callq 0x1090
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: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa193
jmp 0xa1c6
movq -0x10(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0xa1af
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xa1c3
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
je 0xa208
movq 0x15bd2(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa040
leaq 0x2a4b(%rip), %rdi      # 0xcc4c
callq 0x1050
jmp 0xa1c6
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_report
void
print_report(cfg_t const* cfg, vector_t const* lr1_states) {
	for (size_t i = 0; i < SIZE_VECTOR(lr1_states); ++i) {
		printf("===== State %zu =====\n", i);
		lr1_state_t* state = AT_VECTOR(lr1_states, i);
		if (state->accept)
			{ printf("(Accept): "); }
		print_state(cfg, state->items);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa337
movq -0x18(%rbp), %rsi
leaq 0x2938(%rip), %rdi      # 0xcb8d
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x29(%rax)
je 0xa287
leaq 0x2924(%rip), %rdi      # 0xcba4
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0xa170
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0xa340
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0xa340
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa324
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movl 0xc(%rax), %edx
xorl $0x4000, %edx           # imm = 0x4000
addl $0x1, %edx
leaq 0x289f(%rip), %rdi      # 0xcbaf
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa2d7
jmp 0xa326
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa238
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_move
static void
print_move(cfg_t const* cfg, trans_list_t* list, int kind) {
	char const* pattern = (kind == _SHIFT) ? "SHIFT" : "GOTO";
	vector_t const* src_vect = (kind == _SHIFT)
							? cfg->terminal : cfg->non_terminal;
	while (list) {
		if (kind & list->input) {
			printf("%s(%s)", pattern, ((symbol_t*)
				AT_VECTOR(src_vect, list->input ^ kind))->name);
		}
		printf(" into state %d.\n", list->state);
		list = list->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %edx
leaq 0x28a7(%rip), %rax      # 0xcc04
leaq 0x289a(%rip), %rcx      # 0xcbfe
cmpl $0x1000, %edx           # imm = 0x1000
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jne 0xa389
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa395
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa403
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
andl 0x8(%rcx), %eax
cmpl $0x0, %eax
je 0xa3e1
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
xorl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
leaq 0x282f(%rip), %rdi      # 0xcc09
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x2821(%rip), %rdi      # 0xcc10
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa39d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_lr1_item
static void
del_lr1_item(lr1_item_t* item) {
	if (item) { 
		del_bitset(item->lookahead);
//		del_vector(item->non_kernel_look);
	}
	FREE(item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa430
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1300
movq -0x8(%rbp), %rdi
callq 0x1190
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_kernel
static void
del_kernel(kernel_t* kernel) {
	if (kernel) {
		del_bitset(kernel->kernel_item);
		if (!kernel->ref_lr0)
			{ del_vector(kernel->non_lr0_kernel_item); }
		del_bitset(kernel->final_state);
	}
	FREE(kernel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa483
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1300
movq -0x8(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0xa476
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rax
movq 0x20(%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: new_lr0_item
static lr0_item_t*
new_lr0_item(production_t const* prod, list_rhs_t const* dot_pos) {
	if (!prod)
		{ return (NULL); }

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa514
movq $0x0, -0x8(%rbp)
jmp 0xa653
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa700
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x1588e(%rip), %rax     # 0x1fdc0
cmpq $0x0, (%rax,%rcx,8)
jne 0xa550
callq 0x1ee0
movq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq 0x15874(%rip), %rax     # 0x1fdc0
movq %rdx, (%rax,%rcx,8)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
leaq 0x15859(%rip), %rcx     # 0x1fdc0
movq (%rcx,%rdx,8), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa5c7
movq -0x20(%rbp), %rcx
leaq 0x15844(%rip), %rax     # 0x1fdc0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xa5b7
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xa5b7
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa653
jmp 0xa5b9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa558
movl $0x20, %edi
callq 0x38b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xa5e6
movq $0x0, -0x8(%rbp)
jmp 0xa653
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10b0
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa620
movq -0x38(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x20(%rbp), %rcx
leaq 0x15795(%rip), %rax     # 0x1fdc0
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rcx
leaq 0x15786(%rip), %rax     # 0x1fdc0
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x2070
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%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: new_lr1_item_lr0
static lr1_item_t*
new_lr1_item_lr0(lr0_item_t* lr0_item, bitset_t const* lookahead) {
	if (!lr0_item)
		{ return (NULL); }
	if (!record_lr1_item)
		{ record_lr1_item = new_vector(); }
	lr1_item_t* item = NEW(lr1_item_t, 1);
	if (!item)
		{ return (NULL); }
	memset(item, 0, sizeof(lr1_item_t));
	item->lookahead = dup_bitset(lookahead);
	item->core = lr0_item;
	return (item);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa681
movq $0x0, -0x8(%rbp)
jmp 0xa6ee
cmpq $0x0, 0x15727(%rip)     # 0x1fdb0
jne 0xa697
callq 0x1ee0
movq %rax, 0x15719(%rip)     # 0x1fdb0
movl $0x18, %edi
callq 0x38b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa6b6
movq $0x0, -0x8(%rbp)
jmp 0xa6ee
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
callq 0x1350
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: hash_lr0_item
static inline int
hash_lr0_item(production_t const* prod, list_rhs_t const* dot_pos) {
	size_t hash = prod->index;
	if (dot_pos)
		{ hash += dot_pos->pos; }
	return (hash % HASH_LR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa72e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x32, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: split_specific
static kernel_t*
split_specific(bitset_t* item_set, symbol_t* symbol) {
	int back = IT_BACK(item_set);
	IT_RESET(item_set);
	
	bitset_t* cprefix = new_bitset();
	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)
			{ continue; }
		else if (DOT(CORE(crt_item))->symbol_rhs == symbol)
			{ ADD_BITSET(cprefix, (size_t)i); }
	}

	IT_SET(item_set, back);
	return (new_kernel(cprefix, symbol, hash_lr1_item(cprefix)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 0xa763
jmp 0xa796
movq -0x8(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0xa77f
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0xa793
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x8(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
callq 0x1290
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0xa83e
movq 0x155f5(%rip), %rax     # 0x1fdb0
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x10(%rax)
je 0xa7da
jmp 0xa79f
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xa837
movslq -0x24(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0xa80f
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x1420
jmp 0xa837
movslq -0x24(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0xa839
jmp 0xa79f
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x98d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0xa880
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: compute_look
static bitset_t*
compute_look(lr0_item_t const* item, bitset_t* before) {
	bitset_t* target_first = first_list_rhs_t(DOT(item)->next);
	if (target_first == NULL_BITSET)
		{ target_first = dup_bitset(before); }
	else if (list_is_nullable(DOT(item)->next))
		{ UNION_BITSET(target_first, before); }
	return (target_first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x6f30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xae3a
movq -0x10(%rbp), %rdi
callq 0x1350
movq %rax, -0x18(%rbp)
jmp 0xae61
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x6e90
testb $0x1, %al
jne 0xae50
jmp 0xae5f
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %edi, %edi
callq 0x1890
jmp 0xae61
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: propagate_look_lr1_symbol
static bool
propagate_look_lr1_symbol(kernel_t* kernel, vector_t* vect_look,
							symbol_t* symbol, bitset_t* base_look) {
	bool change = false;
	for (size_t i = 0; i < SIZE_VECTOR(kernel->non_lr0_kernel_item); ++i) {
		bitset_t* crt_look = (bitset_t*)AT_VECTOR(vect_look, i);
		lr0_item_t const* crt_item = (lr0_item_t const*)
								AT_VECTOR(kernel->non_lr0_kernel_item, i);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xaf18
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xaf05
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c00
testb $0x1, %al
jne 0xaef6
movb $0x1, -0x21(%rbp)
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %edi, %edi
callq 0x1890
jmp 0xaf07
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xae94
movb -0x21(%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/lr.c
// Function: add_reduce
static void
add_reduce(cfg_t const* cfg, lr1_state_t* state, lr1_item_t* item,
										bitset_t* src_symbol, size_t index) {
	int i;
	trans_list_t* reduce_list = NULL;

	while ((i = IT_NEXT(src_symbol)) != IT_NULL) {
		trans_list_t* next = new_trans_list(i,
								REDUCE(PROD(CORE(item))->index), reduce_list);
//		next->next = reduce_list;
		reduce_list = next;
	}

	IT_RESET(src_symbol);		
	detect_error(cfg, state, reduce_list, index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1aa0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
je 0xaf95
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
orq $0x4000, %rax           # imm = 0x4000
movl %eax, %esi
movq -0x38(%rbp), %rdx
callq 0x39f0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xaf54
cmpq $0x0, -0x20(%rbp)
jne 0xaf9e
jmp 0xafd1
movq -0x20(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0xafba
movq -0x20(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0xafce
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x20(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xaff0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: detect_error
static void
detect_error(cfg_t const* cfg, lr1_state_t* state,
							trans_list_t* reduce_list, size_t index) {

	if (check_conflict(cfg, state, &reduce_list, SHIFT_REDUCE))
		{ warnf(0, "Shift/Reduce (state %zu).", index); }
	if (check_conflict(cfg, state, &reduce_list, REDUCE_REDUCE))
		{ warnf(0, "Reduce/Reduce (state %zu).", index); }

	if (!state->reduces)
		{ state->reduces = reduce_list; }
	else
		{ append_trans_list(state->reduces, reduce_list); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x99a0
testb $0x1, %al
jne 0xb024
jmp 0xb03a
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x1b96(%rip), %rsi      # 0xcbc9
movb $0x0, %al
callq 0x43c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movl $0x2, %ecx
callq 0x99a0
testb $0x1, %al
jne 0xb056
jmp 0xb06c
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x1b7e(%rip), %rsi      # 0xcbe3
movb $0x0, %al
callq 0x43c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xb085
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xb096
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_ll.c
// Function: gen_ll_useful_macro
void
gen_ll_useful_macro(int filde, cfg_t const* cfg) {
	dprintf(filde, DEFINE(ERROR_SLOT, 0) NL);
	dprintf(filde, DEFINE(START_SYMBOL,));
	production_t* start_prod = BACK_VECTOR(cfg->productions);
	gen_nter_symbol(filde, cfg,
			start_prod->rhs_element->symbol_rhs->index, true);
	dprintf(filde, NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1b68(%rip), %rsi      # 0xcc21
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x1b6d(%rip), %rsi      # 0xcc37
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
movl $0x1, %ecx
callq 0xb7b0
movl -0x4(%rbp), %edi
leaq 0x1c24(%rip), %rsi      # 0xcd40
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_ll.c
// Function: gen_ll_table
void
gen_ll_table(int filde, cfg_t const* cfg,
				vector_t const* ll_table, char const* header) {
	dprintf(filde, STATIC SP INT NL);
	gen_verbatim_file(filde, header);
	dprintf(filde, "_ll_table[" MACRO_NTER "]["
				MACRO_TOKEN "] = " BEG_BLOCK NL);

	for (size_t i = 0; i < SIZE_VECTOR(ll_table); ++i) {
		trans_list_t* list = AT_VECTOR(ll_table, i);
		if (list)
			{ dprintf(filde, TAB); }
		while (list) {
			dprintf(filde, "[");
			gen_nter_symbol(filde, cfg, i, true);
			dprintf(filde, "][" TOKEN_PREFIX SEP "%s]=", ((symbol_t*)
				AT_VECTOR(cfg->terminal, list->input))->name);
			gen_nproduction(filde, cfg, list->state);
			dprintf(filde, COMMA SP);
			list = list->next;
		}
		write(filde, NL, 1);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1afc(%rip), %rsi      # 0xcc4d
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x4150
movl -0x4(%rbp), %edi
leaq 0x1aeb(%rip), %rsi      # 0xcc59
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb273
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xb1ba
movl -0x4(%rbp), %edi
leaq 0x1a98(%rip), %rsi      # 0xcc4b
movb $0x0, %al
callq 0x10d0
jmp 0xb1bc
cmpq $0x0, -0x30(%rbp)
je 0xb24e
movl -0x4(%rbp), %edi
leaq 0x1cec(%rip), %rsi      # 0xcebd
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0xb7b0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
leaq 0x1a6f(%rip), %rsi      # 0xcc81
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rax
movslq 0xc(%rax), %rdx
callq 0xba00
movl -0x4(%rbp), %edi
leaq 0x1cd5(%rip), %rsi      # 0xcf0c
movb $0x0, %al
callq 0x10d0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xb1bc
movl -0x4(%rbp), %edi
leaq 0x1bb6(%rip), %rsi      # 0xce0e
movl $0x1, %edx
callq 0x1070
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb17d
movl -0x4(%rbp), %edi
leaq 0x1a0d(%rip), %rsi      # 0xcc8a
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_lr.c
// Function: gen_action_enum
void
gen_action_enum(int filde) {
	dprintf(filde, ENUM SP BEG_BLOCK NL);
	dprintf(filde, TAB "_SHIFT"  TAB "= 0x1000" COMMA NL);
	dprintf(filde, TAB "_REDUCE" TAB "= 0x2000" COMMA NL);
	dprintf(filde, TAB "_GOTO"   TAB "= 0x4000" COMMA NL);
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x19ea(%rip), %rsi      # 0xcc8f
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19e1(%rip), %rsi      # 0xcc97
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19e3(%rip), %rsi      # 0xccaa
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19e6(%rip), %rsi      # 0xccbe
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19a1(%rip), %rsi      # 0xcc8a
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_lr.c
// Function: gen_lr_useful_macro
void
gen_lr_useful_macro(int filde) {
	dprintf(filde, DEFINE(SHIFT(x),(x | _SHIFT)) NL);
	dprintf(filde, DEFINE(REDUCE(x),(x | _REDUCE)) NL);
	dprintf(filde, DEFINE(GOTO(x),(x | _GOTO)) NL);
	dprintf(filde, DEFINE(ACCEPT, (~0)) NL NL);
	dprintf(filde, DEFINE(LR_START_STATE, 0) NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x19bb(%rip), %rsi      # 0xccd0
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19c9(%rip), %rsi      # 0xccef
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19d9(%rip), %rsi      # 0xcd10
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19e5(%rip), %rsi      # 0xcd2d
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x19ea(%rip), %rsi      # 0xcd43
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_lr.c
// Function: gen_goto_table
void
gen_goto_table(int filde, cfg_t const* cfg,
							vector_t const* lr1_states, char const* header) {

	dprintf(filde, STATIC SP INT NL);
	gen_verbatim_file(filde, header);

	dprintf(filde, "_lr_goto_table[%zu][" MACRO_NTER "] = " BEG_BLOCK NL,
			SIZE_VECTOR(lr1_states));

	for (size_t i = 0; i < SIZE_VECTOR(lr1_states); ++i) {
		lr1_state_t* state = (lr1_state_t*)AT_VECTOR(lr1_states, i);
		dprintf(filde, "/* %3zu */" TAB BEG_BLOCK, i);
		trans_list_t* action = state->goto_lst;
		while (action) {
			dprintf(filde, "[");
			gen_nter_symbol(filde, cfg, action->input ^ _GOTO, true);
			dprintf(filde, "]=" GOTO_STR "(%d)", action->state);

			if (action->next)
				{ dprintf(filde, COMMA SP); }
			action = action->next;
		}
		dprintf(filde, END_BLOCK COMMA NL);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq 0x165c(%rip), %rsi      # 0xcc4d
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x4150
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x17ad(%rip), %rsi      # 0xcdc3
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb705
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rdx
leaq 0x172e(%rip), %rsi      # 0xcd86
movb $0x0, %al
callq 0x10d0
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb6e3
movl -0x4(%rbp), %edi
leaq 0x1841(%rip), %rsi      # 0xcebd
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
xorl $0x2000, %eax           # imm = 0x2000
movslq %eax, %rdx
movl $0x1, %ecx
callq 0xb7b0
movl -0x4(%rbp), %edi
movq -0x38(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x1734(%rip), %rsi      # 0xcde8
movb $0x0, %al
callq 0x10d0
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb6d6
movl -0x4(%rbp), %edi
leaq 0x183d(%rip), %rsi      # 0xcf0c
movb $0x0, %al
callq 0x10d0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xb66b
movl -0x4(%rbp), %edi
leaq 0x1825(%rip), %rsi      # 0xcf12
movb $0x0, %al
callq 0x10d0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb625
movl -0x4(%rbp), %edi
leaq 0x157b(%rip), %rsi      # 0xcc8a
movb $0x0, %al
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_location_token
void
gen_location_token(int filde, cfg_t const* cfg) {
	dprintf(filde, DEFINE(_ONLY_STATE_TOKEN_,) NL);
	for (size_t i = 0; i < SIZE_VECTOR(cfg->token_file); ++i) {
		dprintf(filde, INCLUDE(%s) NL, (char const*)
								AT_VECTOR(cfg->token_file, i));
	}
	dprintf(filde, UNDEF(_ONLY_STATE_TOKEN_) NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq 0x16ba(%rip), %rsi      # 0xcdf3
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb78c
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1699(%rip), %rsi      # 0xce10
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb748
movl -0x4(%rbp), %edi
leaq 0x1689(%rip), %rsi      # 0xce1f
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_nter_symbol
void
gen_nter_symbol(int filde, cfg_t const* cfg, size_t index, bool sep) {
	vector_t const* nter = cfg->non_terminal;
	symbol_t* symbol = (symbol_t*)AT_VECTOR(nter, index);

	size_t depth = 0;
	size_t spec_nth = 0;

	if (symbol->special) {
		dprintf(filde, ((symbol->spec_kind == OPT) ? OPT_STR : LST_STR));
		if (sep)
			{ dprintf(filde, SEP); }
		
		depth = symbol->depth;
		spec_nth = symbol->spec_nth;

		symbol = symbol->special;
	}

	dprintf(filde, NTER_PREFIX);
	if (sep)
		{ dprintf(filde, SEP); }

	size_t len = strlen(symbol->name) - 1;
	for (size_t i = 1; i < len; ++i) {
		if (symbol->name[i] == '\'')
			{ dprintf(filde, PRIME_STR); }
		else
			{ write(filde, symbol->name + i, 1); }
	}
	if (depth)
		{ dprintf(filde, SEP "%zu" SEP "%zu", spec_nth, depth); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xb865
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rax
movl 0x38(%rax), %ecx
leaq 0x162a(%rip), %rsi      # 0xce3f
leaq 0x161f(%rip), %rax      # 0xce3b
cmpl $0x0, %ecx
cmoveq %rax, %rsi
movb $0x0, %al
callq 0x10d0
testb $0x1, -0x19(%rbp)
je 0xb841
movl -0x4(%rbp), %edi
leaq 0xabc(%rip), %rsi       # 0xc2f6
movb $0x0, %al
callq 0x10d0
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edi
leaq 0x7e4(%rip), %rsi       # 0xc053
movb $0x0, %al
callq 0x10d0
testb $0x1, -0x19(%rbp)
je 0xb88d
movl -0x4(%rbp), %edi
leaq 0xa70(%rip), %rsi       # 0xc2f6
movb $0x0, %al
callq 0x10d0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1080
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq $0x1, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xb905
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x50(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
jne 0xb8dc
movl -0x4(%rbp), %edi
leaq 0x1570(%rip), %rsi      # 0xce43
movb $0x0, %al
callq 0x10d0
jmp 0xb8f5
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
addq -0x50(%rbp), %rsi
movl $0x1, %edx
callq 0x1070
jmp 0xb8f7
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xb8aa
cmpq $0x0, -0x38(%rbp)
je 0xb925
movl -0x4(%rbp), %edi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0x152c(%rip), %rsi      # 0xce4a
movb $0x0, %al
callq 0x10d0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_non_terminal_enum
void
gen_non_terminal_enum(int filde, cfg_t const* cfg) {
	dprintf(filde, ENUM SP BEG_BLOCK NL);
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal) - 1; ++i) {
		dprintf(filde, TAB);
		gen_nter_symbol(filde, cfg, i, true);
		dprintf(filde, COMMA NL);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
	dprintf(filde, DEFINE(%s, %zu) NL NL,
					MACRO_NTER, SIZE_VECTOR(cfg->non_terminal) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1346(%rip), %rsi      # 0xcc8f
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xb9b6
movl -0x4(%rbp), %edi
leaq 0x12d0(%rip), %rsi      # 0xcc4b
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0xb7b0
movl -0x4(%rbp), %edi
leaq 0x1306(%rip), %rsi      # 0xcca7
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb958
movl -0x4(%rbp), %edi
leaq 0x12ca(%rip), %rsi      # 0xcc8a
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
leaq 0x1472(%rip), %rsi      # 0xce53
leaq 0x147c(%rip), %rdx      # 0xce64
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)