LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: new_cfg
cfg_t*
new_cfg(int filde) {
	cfg_t* cfg = NEW(cfg_t, 1);

	if (!cfg)
		{ return (NULL); }
	memset(cfg, 0, sizeof(cfg_t));

	cfg->miss_prod = true;
	cfg->productions = new_vector();
	cfg->non_terminal = new_vector();
	cfg->terminal = new_vector();
	cfg->token_file = new_vector();
	cfg->lex = new_lexer(filde);

	return (cfg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x38, %edi
callq 0x38b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x479a
movq $0x0, -0x8(%rbp)
jmp 0x480c
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10b0
movq -0x18(%rbp), %rax
movb $0x1, 0x30(%rax)
callq 0x1ee0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
callq 0x1ee0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x1ee0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x1ee0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %edi
callq 0x2b40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%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/cfg.c
// Function: del_cfg
void
del_cfg(cfg_t* cfg) {
	if (cfg) {
		foreach_vector(cfg->non_terminal, &free_symbol);	
		del_vector(cfg->non_terminal);
		
		foreach_vector(cfg->terminal, &free_symbol);
		del_vector(cfg->terminal);
	
		foreach_vector(cfg->productions, &del_production);
		del_vector(cfg->productions);
	
		foreach_vector(cfg->token_file, &free);
		del_vector(cfg->token_file);

		del_lexer(cfg->lex);		
	}
	FREE(cfg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x48c6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x9a(%rip), %rsi        # 0x48e0
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x79(%rip), %rsi        # 0x48e0
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x20a9(%rip), %rsi      # 0x6930
callq 0x23a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0xc721(%rip), %rsi      # 0x10fc8
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2bf0
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/cfg.c
// Function: free_symbol
static void
free_symbol(symbol_t* sym) {
	if (sym) {
		FREE(sym->name);
		if (sym->kind == T_NON_TERMINAL) {
			del_bitset(sym->first);
			del_bitset(sym->follow);
			del_bitset(sym->prod_lst);
		}
		else if ((sym->kind == T_TERMINAL) && (sym->prec))
			{ FREE(sym->prec); }
		else if ((sym->kind == T_LITERAL) && (!sym->share_prec))
			{ FREE(sym->prec); }
	}
	FREE(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4982
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1190
movq -0x8(%rbp), %rax
cmpl $0x27, 0x8(%rax)
jne 0x4937
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1300
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1300
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1300
jmp 0x4980
movq -0x8(%rbp), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x495b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x495b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1190
jmp 0x497e
movq -0x8(%rbp), %rax
cmpl $0x28, 0x8(%rax)
jne 0x497c
movq -0x8(%rbp), %rax
testb $0x1, 0x1c(%rax)
jne 0x497c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1190
jmp 0x497e
jmp 0x4980
jmp 0x4982
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/cfg.c
// Function: parse_cfg
cfg_t*
parse_cfg(int filde) {
	cfg_t* cfg = new_cfg(filde);
	if (cfg_section(cfg) == ERROR) {
		del_cfg(cfg);
		return (NULL);
	}
	return (cfg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x4770
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x49f0
cmpl $-0x1, %eax
jne 0x49d8
movq -0x18(%rbp), %rdi
callq 0x4820
movq $0x0, -0x8(%rbp)
jmp 0x49e0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_section
int
cfg_section(cfg_t* cfg) {
	bool empty = true;
	while (peek_token(cfg->lex) != T_EOF) {
		if (cfg_entry_section(cfg) == ERROR)
			{ return (ERROR); }
		empty = false;
	}
	if (empty)
		{ warnf(CURRENT_LINE(cfg->lex), "Empty file."); }
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x70, %eax
je 0x4a2f
movq -0x10(%rbp), %rdi
callq 0x5310
cmpl $-0x1, %eax
jne 0x4a29
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a56
movb $0x0, -0x11(%rbp)
jmp 0x4a00
testb $0x1, -0x11(%rbp)
je 0x4a4f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x7aaa(%rip), %rsi      # 0xc4f2
movb $0x0, %al
callq 0x43c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: augment_grammar
void
augment_grammar(cfg_t* cfg) {
	if (!cfg)
		{ return; }

	symbol_t* start = add_symbol_cfg(cfg, T_NON_TERMINAL, "$START");
	start->is_defined = true;

	production_t* prod = new_production(start, cfg);
	ADD_BITSET(start->prod_lst, GET_INDEX(prod));

	add_symbol_rhs(prod, AT_VECTOR(cfg->non_terminal, cfg->goal));
	symbol_t* eof_symbol = add_symbol_cfg(cfg, T_TERMINAL, "EOF");

	eof_symbol->is_eof = true;
	add_symbol_rhs(prod, eof_symbol);

	cfg->goal = start->index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4a78
jmp 0x4b66
movq -0x8(%rbp), %rdi
movl $0x27, %esi
leaq 0x7637(%rip), %rdx      # 0xc0bf
callq 0x4b70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0xc(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x68a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x4ad7
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1420
jmp 0x4b09
movq -0x18(%rbp), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6990
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
leaq 0x787f(%rip), %rdx      # 0xc3b8
callq 0x4b70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6990
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_sanity_check
int
cfg_sanity_check(cfg_t* cfg) {
	if (!cfg)
		{ return (ERROR); }
	else if (cfg->miss_prod) {
		errorf(0, "No production have been encounter at all.");
		return (ERROR);
	}
	else if (!SIZE_VECTOR(cfg->token_file)) {
		errorf(0, "At most one location of token must be defined.");
		return (ERROR);
	}
	else if (detect_bad_symbol(cfg) == ERROR)
		{ return (ERROR); }
	else if (preprocess_literal(cfg) == ERROR)
		{ return (ERROR); }

	if (unreachable_production(cfg) == ERROR)
		{ warnf(0, "Some unreachable nonterminal has been remove."); }

	check_mimic_prod(cfg);

	detect_nullable(cfg);
	compute_first(cfg);

	if (cfg_not_realizable(cfg) == ERROR)
		{ return (ERROR); }

	compute_follow(cfg);

	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4d1f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e0f
movq -0x10(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x4d47
xorl %eax, %eax
movl %eax, %edi
leaq 0x7688(%rip), %rsi      # 0xc3bc
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e0f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4d74
xorl %eax, %eax
movl %eax, %edi
leaq 0x7685(%rip), %rsi      # 0xc3e6
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e0f
movq -0x10(%rbp), %rdi
callq 0x4e20
cmpl $-0x1, %eax
jne 0x4d8e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e0f
movq -0x10(%rbp), %rdi
callq 0x6bb0
cmpl $-0x1, %eax
jne 0x4da5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e0f
jmp 0x4da7
jmp 0x4da9
jmp 0x4dab
jmp 0x4dad
movq -0x10(%rbp), %rdi
callq 0x71a0
cmpl $-0x1, %eax
jne 0x4dcd
xorl %eax, %eax
movl %eax, %edi
leaq 0x764f(%rip), %rsi      # 0xc415
movb $0x0, %al
callq 0x43c0
movq -0x10(%rbp), %rdi
callq 0x6db0
movq -0x10(%rbp), %rdi
callq 0x7a00
movq -0x10(%rbp), %rdi
callq 0x7aa0
movq -0x10(%rbp), %rdi
callq 0x7570
cmpl $-0x1, %eax
jne 0x4dff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e0f
movq -0x10(%rbp), %rdi
callq 0x7bb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: detect_bad_symbol
static int
detect_bad_symbol(cfg_t* cfg) {
	if (!cfg)
		{ return (ERROR); }
	int exit_status = (cfg_unused_symbol(cfg->non_terminal) == ERROR)
			|| (cfg_unused_symbol(cfg->terminal) == ERROR );
	return ((exit_status) ? ERROR : DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4e3c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e89
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x67d0
movl %eax, %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x4e6b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x67d0
cmpl $-0x1, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: print_terminal
void
print_terminal(cfg_t const* cfg) {
	puts("=== TERMINAL ===");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->terminal); ++i) {
		printf("%s\n", ((symbol_t*)
			AT_VECTOR(cfg->terminal, i))->name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7590(%rip), %rdi      # 0xc443
callq 0x1050
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4f05
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
leaq 0x7564(%rip), %rdi      # 0xc454
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4ec0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: print_non_terminal
void
print_non_terminal(cfg_t const* cfg) {
	puts("=== NON_TERMINAL ===");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal); ++i) {
		printf("%s\n", ((symbol_t*)
			AT_VECTOR(cfg->non_terminal, i))->name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7535(%rip), %rdi      # 0xc458
callq 0x1050
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4f75
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
leaq 0x74f4(%rip), %rdi      # 0xc454
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4f30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: print_production
void
print_production(cfg_t const* cfg) {
	puts("=== PRODUCTION ===");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
		production_t* prod = AT_VECTOR(cfg->productions, i);
		printf("%s -> ", prod->symbol_lhs->name);
		list_rhs_t* list = prod->rhs_element;
		while (list) {
			printf("%s", list->symbol_rhs->name);
			if (list->next)
				{ printf(" "); }
			list = list->next;
		}
		puts("");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x74da(%rip), %rdi      # 0xc46d
callq 0x1050
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x5054
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x74a2(%rip), %rdi      # 0xc480
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5037
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x7357(%rip), %rdi      # 0xc362
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x502a
leaq 0x7348(%rip), %rdi      # 0xc36b
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4ff1
leaq 0x7c0e(%rip), %rdi      # 0xcc4c
callq 0x1050
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4fa0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: print_nullable
void
print_nullable(cfg_t const* cfg) {
	puts("=== NULLABLE SYMBOL ===");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal); ++i) {
		symbol_t* non_terminal = AT_VECTOR(cfg->non_terminal, i);
		if (non_terminal->nullable)
			{ printf("%s is nullable.\n", non_terminal->name); }
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7414(%rip), %rdi      # 0xc487
callq 0x1050
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x50d9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x50c9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x73dd(%rip), %rdi      # 0xc49f
movb $0x0, %al
callq 0x1090
jmp 0x50cb
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5080
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: print_first_set
void
print_first_set(cfg_t const* cfg) {
	puts("=== FIRST SET ===");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal); ++i) {
		symbol_t* non_terminal = AT_VECTOR(cfg->non_terminal, i);
		printf("FIRST(%s) = {", non_terminal->name);
		bool first = true;
		int j;
		while ((j = IT_NEXT(non_terminal->first)) != IT_NULL) {
			if (!first)
				{ printf(", "); }
			symbol_t* terminal = AT_VECTOR(cfg->terminal, j);
			printf("%s", terminal->name);
			first = false;
		}
		puts("}");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x73bd(%rip), %rdi      # 0xc4b0
callq 0x1050
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x51c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x7386(%rip), %rdi      # 0xc4c2
movb $0x0, %al
callq 0x1090
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1aa0
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
je 0x51a3
testb $0x1, -0x19(%rbp)
jne 0x5170
leaq 0x7da3(%rip), %rdi      # 0xcf0c
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x71cc(%rip), %rdi      # 0xc362
movb $0x0, %al
callq 0x1090
movb $0x0, -0x19(%rbp)
jmp 0x5147
leaq 0x75d1(%rip), %rdi      # 0xc77b
callq 0x1050
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: print_follow_set
void
print_follow_set(cfg_t const* cfg) {
	puts("=== FOLLOW SET ===");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal); ++i) {
		symbol_t* non_terminal = AT_VECTOR(cfg->non_terminal, i);
		printf("FOLLOW(%s) = {", non_terminal->name);
		bool first = true;
		int j;
		while ((j = IT_NEXT(non_terminal->follow)) != IT_NULL) {
			if (!first)
				{ printf(", "); }
			symbol_t* terminal = AT_VECTOR(cfg->terminal, j);
			printf("%s", terminal->name);
			first = false;
		}
		puts("}");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x72ed(%rip), %rdi      # 0xc4d0
callq 0x1050
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x52b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x72b7(%rip), %rdi      # 0xc4e3
movb $0x0, %al
callq 0x1090
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1aa0
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
je 0x5293
testb $0x1, -0x19(%rbp)
jne 0x5260
leaq 0x7cb3(%rip), %rdi      # 0xcf0c
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x70dc(%rip), %rdi      # 0xc362
movb $0x0, %al
callq 0x1090
movb $0x0, -0x19(%rbp)
jmp 0x5237
leaq 0x74e1(%rip), %rdi      # 0xc77b
callq 0x1050
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x51f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_entry_section
static int
cfg_entry_section(cfg_t* cfg) {
	int kind = advance_token(cfg->lex);
	int (*section_ptr)(cfg_t*) = NULL;
	switch (kind) {
		case T_EXTERN:		section_ptr = &cfg_path_list;
					break;
		case T_ALIAS:		section_ptr = &cfg_alias_list;
					break;
		case T_PRODUCTION:	section_ptr = &cfg_production_list;
					break;
		case T_PRECEDENCE:	section_ptr = &cfg_precedence_list;
					break; 
	}
	if (!section_ptr) {
		errorf(CURRENT_LINE(cfg->lex), "Bad section directive.");
		return (ERROR);
	}
	char miss_c;
	if ((miss_c = '{', advance_token(cfg->lex) != T_LBRACE)
			|| (miss_c = '\0', (*section_ptr)(cfg) == ERROR)
			|| (miss_c = '}', advance_token(cfg->lex) != T_RBRACE)
			|| (miss_c = ';', advance_token(cfg->lex) != T_SEMI)) {
		if (miss_c) {
			errorf(CURRENT_LINE(cfg->lex),
							"Missing a '%c' after the directive.", miss_c);
		}
		return (ERROR);
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movl %eax, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $-0x65, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x538b
movq -0x30(%rbp), %rax
leaq 0x7058(%rip), %rcx      # 0xc3a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xf0(%rip), %rax        # 0x5450
movq %rax, -0x20(%rbp)
jmp 0x538b
leaq 0x1e3(%rip), %rax       # 0x5550
movq %rax, -0x20(%rbp)
jmp 0x538b
leaq 0x376(%rip), %rax       # 0x56f0
movq %rax, -0x20(%rbp)
jmp 0x538b
leaq 0x3c9(%rip), %rax       # 0x5750
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x53b8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x7159(%rip), %rsi      # 0xc4fe
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5444
movb $0x7b, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x32, %rax
jne 0x5410
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $-0x1, %eax
je 0x5410
movb $0x7d, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x33, %rax
jne 0x5410
movb $0x3b, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x30, %rax
je 0x543d
cmpb $0x0, -0x21(%rbp)
je 0x5434
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
movsbl -0x21(%rbp), %edx
leaq 0x70e8(%rip), %rsi      # 0xc515
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5444
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_path_list
int
cfg_path_list(cfg_t* cfg) {
	if (peek_token(cfg->lex) == T_RBRACE)
		{ return (DONE); }
	else if (advance_token(cfg->lex) == T_LITERAL) {
		unget_char_back_buffer(LAST_LEXEME(cfg->lex), 1);
		PUSH_BACK_VECTOR(cfg->token_file, strdup(C_LEXEME(cfg->lex) + 1));
		if (peek_token(cfg->lex) == T_COMMA) {
			advance_token(cfg->lex);
			return (cfg_path_list(cfg));
		}
	}
	else {
		errorf(CURRENT_LINE(cfg->lex),
						"Missing a literal in the $EXTERN section.");
		return (ERROR);
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x33, %eax
jne 0x547a
movl $0x0, -0x4(%rbp)
jmp 0x5546
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x28, %rax
jne 0x551a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0x2930
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
addq $0x1, %rdi
callq 0x1170
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x2070
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x31, %eax
jne 0x5518
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq -0x10(%rbp), %rdi
callq 0x5450
movl %eax, -0x4(%rbp)
jmp 0x5546
jmp 0x553d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x700c(%rip), %rsi      # 0xc539
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5546
jmp 0x553f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_alias_list
int
cfg_alias_list(cfg_t* cfg) {
	if (peek_token(cfg->lex) == T_RBRACE)
		{ return (DONE); }
	else if (advance_token(cfg->lex) == T_LPAREN) {
		if (advance_token(cfg->lex) != T_TERMINAL) {
			errorf(CURRENT_LINE(cfg->lex),
						"Missing an token identifier in the $ALIAS section.");
			return (ERROR);
		}

		symbol_t* alias_ter = add_symbol_cfg(cfg,
										T_TERMINAL, C_LEXEME(cfg->lex));

		if (advance_token(cfg->lex) != T_BARROW) {
			errorf(CURRENT_LINE(cfg->lex),
						"Missing a => in the $ALIAS section.");
			return (ERROR);
		}
		else if (alias_literal_list(cfg, alias_ter) == ERROR)
			{ return (ERROR); }
		else if (advance_token(cfg->lex) != T_RPAREN) {
			errorf(CURRENT_LINE(cfg->lex),
						"Missing a close paren in the $ALIAS section.");
			return (ERROR);
		}
		else if (peek_token(cfg->lex) == T_COMMA) {
			advance_token(cfg->lex);
			return (cfg_alias_list(cfg));
		}
	}
	else {
		errorf(CURRENT_LINE(cfg->lex),
						"Missing an open paren in the $ALIAS section.");
		return (ERROR);
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x33, %eax
jne 0x557a
movl $0x0, -0x4(%rbp)
jmp 0x56d9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x34, %rax
jne 0x56ad
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x2d, %rax
je 0x55ca
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x6fac(%rip), %rsi      # 0xc563
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x56d9
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
movl $0x2d, %esi
callq 0x4b70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x2f, %rax
je 0x5624
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x6f85(%rip), %rsi      # 0xc596
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x56d9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5860
cmpl $-0x1, %eax
jne 0x5642
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x56d9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x35, %rax
je 0x5678
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x6f52(%rip), %rsi      # 0xc5ba
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x56d9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x31, %eax
jne 0x56a5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq -0x10(%rbp), %rdi
callq 0x5550
movl %eax, -0x4(%rbp)
jmp 0x56d9
jmp 0x56a7
jmp 0x56a9
jmp 0x56ab
jmp 0x56d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x6f27(%rip), %rsi      # 0xc5e7
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x56d9
jmp 0x56d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_production_list
int
cfg_production_list(cfg_t* cfg) {
	while (peek_token(cfg->lex) != T_RBRACE) {
		if (cfg_production(cfg) == ERROR)
			{ return (ERROR); }
		special_pos = 0;
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x33, %eax
je 0x5732
movq -0x10(%rbp), %rdi
callq 0x5a00
cmpl $-0x1, %eax
jne 0x5725
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5739
movq $0x0, 0x1a678(%rip) # 0x1fda8
jmp 0x56fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_precedence_list
int
cfg_precedence_list(cfg_t* cfg) {
	size_t prec_depth = NOT_PREC + 1;
	while (1) {
		if (peek_token(cfg->lex) == T_RBRACE)
			{ return (DONE); }
		int kind_prec = advance_token(cfg->lex);
		switch (kind_prec) {
			case T_LEFT: case T_RIGHT: case T_NONASSOC: break;
			default: errorf(CURRENT_LINE(cfg->lex),
						"Bad associativity in the $PRECEDENCE section.");
					return (ERROR);
		}
		if (advance_token(cfg->lex) == T_LPAREN) {
			if (cfg_precedence_atom(cfg, kind_prec, prec_depth++) == ERROR)
				{ return (ERROR); }
			if (peek_token(cfg->lex) == T_COMMA)
				{ advance_token(cfg->lex); }
		}
		else {
			errorf(CURRENT_LINE(cfg->lex),
						"Missing an open paren in the $PRECEDENCE section.");
			return (ERROR);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x33, %eax
jne 0x5782
movl $0x0, -0x4(%rbp)
jmp 0x584d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x6c, %eax
subl $0x2, %eax
ja 0x57a1
jmp 0x579f
jmp 0x57c7
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x715a(%rip), %rsi      # 0xc90e
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x584d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x34, %rax
jne 0x5825
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rdx, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x65b0
cmpl $-0x1, %eax
jne 0x5804
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x584d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x31, %eax
jne 0x5823
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
jmp 0x5848
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x7104(%rip), %rsi      # 0xc93c
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x584d
jmp 0x5764
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_production
int
cfg_production(cfg_t* cfg) {
	char const* next;
	if ((next = "nonterminal", advance_token(cfg->lex) != T_NON_TERMINAL)
			|| (next = NULL, follow_prod(cfg) == ERROR)
			|| (next = ";", advance_token(cfg->lex) != T_SEMI)) {
		if (next) {
			errorf(CURRENT_LINE(cfg->lex),
							"Missing %s for the production.", next);
		}
		return (ERROR);
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x6c77(%rip), %rax      # 0xc68a
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x27, %rax
jne 0x5a5e
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5aa0
cmpl $-0x1, %eax
je 0x5a5e
leaq 0x6c4f(%rip), %rax      # 0xc696
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x30, %rax
je 0x5a8c
cmpq $0x0, -0x18(%rbp)
je 0x5a83
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6c1c(%rip), %rsi      # 0xc698
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5a93
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: follow_prod
static int
follow_prod(cfg_t* cfg) {
	symbol_t* symbol_lhs = add_symbol_cfg(cfg,
							T_NON_TERMINAL, C_LEXEME(cfg->lex));

	if (peek_token(cfg->lex) == T_ARROW) {
		advance_token(cfg->lex);

		cfg->miss_prod = false;
		symbol_lhs->is_defined = true;

		if (cfg_rhs(cfg, symbol_lhs) == ERROR)
			{ return (ERROR); }
	}
	else if (advance_token(cfg->lex) == T_EQUAL) {
		if (advance_token(cfg->lex) != T_START) {
			errorf(CURRENT_LINE(cfg->lex),
						"Must $START follow '%s = '.", symbol_lhs->name);
			return (ERROR);
		}
		cfg->goal = symbol_lhs->index;
	}
	else {
		errorf(CURRENT_LINE(cfg->lex),
						"Missing an arrow (->) or an equal sign after"
						" the nonterminal %s.", symbol_lhs->name);
		return (ERROR);
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
movl $0x27, %esi
callq 0x4b70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x2e, %eax
jne 0x5b1f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq -0x10(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0xc(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5bc0
cmpl $-0x1, %eax
jne 0x5b1a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bb5
jmp 0x5bae
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x0, %rax
jne 0x5b81
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x6b, %rax
je 0x5b70
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x6b57(%rip), %rsi      # 0xc6b7
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bb5
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x5bac
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x6b37(%rip), %rsi      # 0xc6d3
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bb5
jmp 0x5bae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_rhs
int
cfg_rhs(cfg_t* cfg, symbol_t* lhs) {
	production_t* prod = new_production(lhs, cfg);
	ADD_BITSET(lhs->prod_lst, GET_INDEX(prod));

	if (!prod)
		{ return (ERROR); }
	else if ((cfg_opt_list(cfg, prod) == ERROR)
								|| (cfg_mimic(cfg, prod) == ERROR))
		{ return (ERROR); }
	while (peek_token(cfg->lex) == T_UNION) {
		advance_token(cfg->lex);

		prod = new_production(lhs, cfg);
		ADD_BITSET(lhs->prod_lst, GET_INDEX(prod));

		if (!prod)
			{ return (ERROR); }
		else if (cfg_opt_list(cfg, prod) == ERROR
									|| cfg_mimic(cfg, prod) == ERROR)
			{ return (ERROR); }
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x68a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x5c0e
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x1420
jmp 0x5c40
movq -0x20(%rbp), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x20(%rbp)
jne 0x5c53
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d65
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d70
cmpl $-0x1, %eax
je 0x5c77
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5e70
cmpl $-0x1, %eax
jne 0x5c83
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d65
jmp 0x5c85
jmp 0x5c87
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x29, %eax
jne 0x5d5e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x68a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x5ce8
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x1420
jmp 0x5d1a
movq -0x20(%rbp), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x20(%rbp)
jne 0x5d2a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d65
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d70
cmpl $-0x1, %eax
je 0x5d4e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5e70
cmpl $-0x1, %eax
jne 0x5d57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d65
jmp 0x5d59
jmp 0x5c87
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_opt_list
int
cfg_opt_list(cfg_t* cfg, production_t* prod) {
	if (in_first(cfg->lex, T_LBRACK, T_LBRACE,
								T_NON_TERMINAL, T_TERMINAL, T_LITERAL, -1))
		{ return (cfg_list(cfg, prod)); }
	else if (peek_token(cfg->lex) == T_EMPTY)
		{ advance_token(cfg->lex); }
	else if (!in_first(cfg->lex, T_RBRACK, T_RBRACE, 
									T_LPAREN, T_UNION, T_SEMI, -1)) {
		errorf(CURRENT_LINE(cfg->lex),
					"An open paren, a pipe or a semicolon must follow"
					" the production %zu.", GET_INDEX(prod) + 1);
		return (ERROR);
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x2a, %esi
movl $0x32, %edx
movl $0x27, %ecx
movl $0x2d, %r8d
movl $0x28, %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x3330
testb $0x1, %al
jne 0x5db7
jmp 0x5dcc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f90
movl %eax, -0x4(%rbp)
jmp 0x5e5b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x6a, %eax
jne 0x5ded
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
jmp 0x5e52
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x2b, %esi
movl $0x33, %edx
movl $0x34, %ecx
movl $0x29, %r8d
movl $0x30, %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x3330
testb $0x1, %al
jne 0x5e50
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
addq $0x1, %rdx
leaq 0x68d4(%rip), %rsi      # 0xc714
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e5b
jmp 0x5e52
jmp 0x5e54
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_mimic
int
cfg_mimic(cfg_t* cfg, production_t* crt_prod) {
	if (peek_token(cfg->lex) != T_LPAREN)
		{ return (DONE); }

	advance_token(cfg->lex);

	if (advance_token(cfg->lex) != T_MIMIC) {
		return (ERROR);
		errorf(CURRENT_LINE(cfg->lex),
					"The directive $MIMIC must follow the open paren.");
	}

	int allow_kind = advance_token(cfg->lex);
	if ((allow_kind != T_TERMINAL) && (allow_kind != T_LITERAL)) {
		errorf(CURRENT_LINE(cfg->lex),
					"The directive $MIMIC must be followed by"
					" a token name or a literal.");
		return (ERROR);
	}

	crt_prod->mimic_sym = add_symbol_cfg(cfg, allow_kind, C_LEXEME(cfg->lex));
	crt_prod->mimic_sym->is_used = true;

	if (advance_token(cfg->lex) != T_RPAREN) {
		errorf(CURRENT_LINE(cfg->lex),
					"A close paren must follow the directive $MIMIC.");
		return (ERROR);
	}

	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x34, %eax
je 0x5e9e
movl $0x0, -0x4(%rbp)
jmp 0x5f78
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x69, %rax
je 0x5eca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f78
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movl %eax, -0x1c(%rbp)
cmpl $0x2d, -0x1c(%rbp)
je 0x5f09
cmpl $0x28, -0x1c(%rbp)
je 0x5f09
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x69a1(%rip), %rsi      # 0xc89a
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f78
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
callq 0x4b70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movb $0x1, 0xd(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x35, %rax
je 0x5f71
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x697d(%rip), %rsi      # 0xc8de
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f78
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_list
int
cfg_list(cfg_t* cfg, production_t* prod) {
	if (cfg_atom(cfg, prod) == ERROR)
		{ return (ERROR); }
	while (in_first(cfg->lex, T_LBRACK, T_LBRACE,
								T_NON_TERMINAL, T_TERMINAL, T_LITERAL, -1)) {
		if (cfg_atom(cfg, prod) == ERROR)
			{ return (ERROR); }
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6030
cmpl $-0x1, %eax
jne 0x5fbb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6018
jmp 0x5fbd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x2a, %esi
movl $0x32, %edx
movl $0x27, %ecx
movl $0x2d, %r8d
movl $0x28, %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x3330
testb $0x1, %al
jne 0x5ff4
jmp 0x6011
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6030
cmpl $-0x1, %eax
jne 0x600f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6018
jmp 0x5fbd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_atom
int
cfg_atom(cfg_t* cfg, production_t* prod) {
	if ((peek_token(cfg->lex) == T_LBRACK)
								|| (peek_token(cfg->lex) == T_LBRACE)) {
		if (enclosed_element(cfg, prod) == ERROR)
			{ return (ERROR); }
	}
	else {
		symbol_t* atom_symbol = add_symbol_cfg(cfg,
					advance_token(cfg->lex), C_LEXEME(cfg->lex));

		atom_symbol->is_used = true;
		if ((atom_symbol->kind == T_LITERAL)
									&& (atom_symbol->terminal_alias != -1)) {
			add_symbol_rhs(prod, AT_VECTOR(cfg->terminal,
								atom_symbol->terminal_alias));
		}
		else
			{ add_symbol_rhs(prod, atom_symbol); }
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x2a, %eax
je 0x6064
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x32, %eax
jne 0x6087
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6120
cmpl $-0x1, %eax
jne 0x6082
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x610e
jmp 0x6107
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq -0x28(%rbp), %rdi
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
callq 0x4b70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0xd(%rax)
movq -0x20(%rbp), %rax
cmpl $0x28, 0x8(%rax)
jne 0x60f8
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
je 0x60f8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6990
jmp 0x6105
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6990
jmp 0x6107
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: add_recursive
static int
add_recursive(cfg_t* cfg, symbol_t* opt_nter, size_t base_index) {
	size_t kind_recur = T_LEFT;
	if (peek_token(cfg->lex) == T_BARROW) {
		advance_token(cfg->lex);
		if (advance_token(cfg->lex) != T_LPAREN) {
			errorf(CURRENT_LINE(cfg->lex),
					"Missing an open paren when the kind of"
					" recursivity is choosen.");
			return (ERROR);
		}
		kind_recur = advance_token(cfg->lex);
		switch (kind_recur) {
			case T_LEFT: case T_RIGHT: break;
			default:
				errorf(CURRENT_LINE(cfg->lex), "Missing $RIGHT or $LEFT.");
				return (ERROR);
		}
		if (advance_token(cfg->lex) != T_RPAREN) {
			errorf(CURRENT_LINE(cfg->lex),
					"Missing an close paren when the kind of"
					" recursivity is choosen.");
			return (ERROR);
		}
	}

	for (size_t i = base_index; i < SIZE_VECTOR(cfg->productions); ++i) {
		production_t* prod = (production_t*)AT_VECTOR(cfg->productions, i);
		if (LHS(prod) == opt_nter) {
			if (kind_recur == T_RIGHT)
				{ add_symbol_rhs(prod, opt_nter); }
			else
				{ add_symbol_rhs_front(prod, opt_nter);  }
		}
	}
	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x6c, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32e0
cmpl $0x2f, %eax
jne 0x6529
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x34, %rax
je 0x64a8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x636d(%rip), %rsi      # 0xc802
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65a2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x6c, %rax
subq $0x1, %rax
ja 0x64cb
jmp 0x64c9
jmp 0x64f1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x6363(%rip), %rsi      # 0xc841
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65a2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ca0
cmpq $0x35, %rax
je 0x6527
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x6343(%rip), %rsi      # 0xc85a
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65a2
jmp 0x6529
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x659b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x658b
cmpq $0x6d, -0x28(%rbp)
jne 0x657c
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6990
jmp 0x6589
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a70
jmp 0x658b
jmp 0x658d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6531
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: cfg_unused_symbol
static int
cfg_unused_symbol(vector_t const* symbol_tab) {
	int unused = DONE;
	for (size_t i = 0; i < SIZE_VECTOR(symbol_tab); ++i) {
		symbol_t* symbol = (symbol_t*)AT_VECTOR(symbol_tab, i);
		if (!symbol->is_defined) {
			errorf(0, "The %s %s is used but not defined.",
								((IS_NON_TERMINAL(symbol))
								? "non terminal" : "literal"), symbol->name);
			unused = ERROR;
		}
		else if (!symbol->is_used) {
			warnf(0, "The symbol %s is defined but not used.",
							symbol->name);
		}
	}
	return (unused);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x6892
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0xc(%rax)
jne 0x6859
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x61fe(%rip), %rdx      # 0xca26
leaq 0x61ea(%rip), %rax      # 0xca19
cmpl $0x27, %ecx
cmoveq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
movl %eax, %edi
leaq 0x61ad(%rip), %rsi      # 0xc9f6
movb $0x0, %al
callq 0x4210
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x687f
movq -0x20(%rbp), %rax
testb $0x1, 0xd(%rax)
jne 0x687d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x61b8(%rip), %rsi      # 0xca2e
movb $0x0, %al
callq 0x43c0
jmp 0x687f
jmp 0x6881
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x67eb
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x30, %edi
callq 0x38b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x68cf
movq $0x0, -0x8(%rbp)
jmp 0x6920
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10b0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)