LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/utils.c
// Function: cmp_trans_list
bool
cmp_trans_list(trans_list_t const* t1, trans_list_t const* t2) {
    while (t1 && t2) {
        if ((t1->input != t2->input) || (t1->state != t2->state))
            { return (false); }
        t1 = t1->next;
        t2 = t2->next;
    }
    return (!t1 && !t2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x38d3
testq %rsi, %rsi
je 0x38d3
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x38cf
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x38cf
movq (%rdi), %rdi
movq (%rsi), %rsi
jmp 0x38ad
xorl %eax, %eax
jmp 0x38d9
orq %rsi, %rdi
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/utils.c
// Function: contiguous_range
trans_list_t const*
contiguous_range(trans_list_t const* t) {
    while (t && t->next) {
        if (((t->input - 1) != (t->next->input))
                || (t->state != t->next->state))
            { break;  }
        t = t->next;
    }
    return (t); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
testq %rdi, %rdi
je 0x3901
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3901
movl 0x8(%rax), %ecx
decl %ecx
cmpl 0x8(%rdi), %ecx
jne 0x3901
movl 0xc(%rax), %ecx
cmpl 0xc(%rdi), %ecx
je 0x38df
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/utils.c
// Function: hash_str
size_t
hash_str(char const* str) {
    size_t posc = EOS;
    while (*str)
        { posc += *(str++); }
    return (posc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movsbq (%rdi), %rcx
testq %rcx, %rcx
je 0x391a
incq %rdi
addq %rcx, %rax
jmp 0x3909
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/utils.c
// Function: open_new_file
int
open_new_file(char const* path_name) {
    int filde = open(path_name, O_WRONLY | O_CREAT | O_EXCL, 0644);
    if ((filde == -1) && (EEXIST == errno))
        { filde = open(path_name, O_WRONLY | O_TRUNC); }
    return (filde);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xc1, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2180
cmpl $-0x1, %eax
jne 0x3975
callq 0x2050
cmpl $0x11, (%rax)
jne 0x3972
movq %rbx, %rdi
movl $0x201, %esi            # imm = 0x201
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2180
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/utils.c
// Function: prealloc
void*
_prealloc(void* ptr, size_t size) {
    if (!size) {
        FREE(ptr);
        return (NULL);
    }
    void* new_chunk = realloc(ptr, size);
#ifndef NDEBUG
    assert(new_chunk);
#else
    if (!chunck) {
        errorf(0, "The reallocation has failed.\n");
        errno = ENOMEM;
    }
#endif
    return (new_chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x39ae
callq 0x2160
testq %rax, %rax
jne 0x39b5
leaq 0x656b(%rip), %rdi      # 0x9f01
leaq 0x653b(%rip), %rsi      # 0x9ed8
leaq 0x6567(%rip), %rcx      # 0x9f0b
movl $0xda, %edx
callq 0x20b0
callq 0x21d0
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/gen.c
// Function: min_size_type
uint8_t
min_size_type(size_t size, bool unsign) {
    if ((unsign && size <= UCHAR_MAX) || (!unsign && size <= SCHAR_MAX))
        { return (BYTE); }
    else if ((unsign && size > UCHAR_MAX && size <= USHRT_MAX)
            || (!unsign && size > SCHAR_MAX && size <= SHRT_MAX))
        { return (SHORT); }
    return (LONG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
shll $0x7, %ecx
orq $0x7f, %rcx
movb $0x8, %al
cmpq %rdi, %rcx
jae 0x3a05
leaq -0x100(%rdi), %rax
cmpq $0xff00, %rax           # imm = 0xFF00
setb %cl
movb $0x10, %al
testb %sil, %cl
jne 0x3a05
addq $-0x8000, %rdi          # imm = 0x8000
shlb $0x4, %sil
addb $0x10, %sil
cmpq $-0x7f80, %rdi          # imm = 0x8080
movzbl %sil, %ecx
movl $0x20, %eax
cmovael %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/gen.c
// Function: gen_include_macro
void
gen_include_macro(int filde, char const* header) {
    write(filde, SEP, 1);
    while (*header) {
        char c;
        if (isalnum(*header))
            { c = toupper(*header); }
        else
            { c = '_'; }    
        write(filde, &c, 1);
        ++header;
    }
    dprintf(filde, SEP HEADER_SUF SEP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x650c(%rip), %rsi      # 0x9f2d
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x2080
leaq -0x29(%rbp), %r12
movsbq (%r14), %r13
testq %r13, %r13
je 0x3a6c
callq 0x21c0
movq (%rax), %rcx
movb $0x5f, %al
testb $0x8, (%rcx,%r13,2)
je 0x3a57
callq 0x2030
movq (%rax), %rax
movb (%rax,%r13,4), %al
movb %al, -0x29(%rbp)
movl %ebx, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2080
incq %r14
jmp 0x3a31
leaq 0x64b8(%rip), %rsi      # 0x9f2b
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/gen.c
// Function: gen_require_macro
void
gen_require_macro(int filde, char const* header) {
    dprintf(filde, "#ifndef ");
    gen_include_macro(filde, header);
    dprintf(filde, NL "#define ");
    gen_include_macro(filde, header);
    dprintf(filde, NL NL);
    dprintf(filde, INCLUDE_SYS(stdint.h) NL);
    dprintf(filde, INCLUDE_SYS(stdbool.h) NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x6492(%rip), %rsi      # 0x9f2f
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3a07
leaq 0x6483(%rip), %rsi      # 0x9f38
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3a07
leaq 0x6eab(%rip), %rsi      # 0xa97a
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x6463(%rip), %rsi      # 0x9f42
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x6468(%rip), %rsi      # 0x9f57
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/gen.c
// Function: gen_verbatim_file
void
gen_verbatim_file(int filde, char const* header) {
    if (isdigit(*header))
        { write(filde, "_", 1); }
    while (*header && (isalnum(*header) || (*header == '_')))
        { write(filde, header++, 1); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
callq 0x21c0
movq %rax, %r14
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x3b6d
leaq 0x63ca(%rip), %rsi      # 0x9f2d
pushq $0x1
popq %rdx
movl %ebx, %edi
callq 0x2080
movq %r15, %rsi
movsbq (%r15), %rax
testq %rax, %rax
je 0x3b8f
cmpb $0x5f, %al
je 0x3b89
movq (%r14), %rcx
movzwl (%rcx,%rax,2), %eax
andl $0x8, %eax
je 0x3b8f
leaq 0x1(%rsi), %r15
jmp 0x3b63
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/tools/src/error.c
// Function: print_error
static void
print_error(size_t lineno, char const* label, char const* color,
                                char const* format, va_list args) {
    // Color Output
    int tty = isatty(STDERR_FILENO);
    if (tty)
        { fprintf(stderr, "%s", color); }
    fprintf(stderr, "(%s", label);
    if (lineno)
        { fprintf(stderr, ":%zu", lineno); }
    fprintf(stderr, ") ");
    vfprintf(stderr, format, args);
    fprintf(stderr, "\n");
    if (tty)
        { fprintf(stderr, NO_COLOR); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, -0x30(%rbp)
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
pushq $0x2
popq %rdi
callq 0x2070
movl %eax, %r14d
testl %eax, %eax
je 0x3c66
movq 0xb395(%rip), %rax      # 0xeff0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x20c0
movq 0xb383(%rip), %rbx      # 0xeff0
movq (%rbx), %rdi
leaq 0x6321(%rip), %rsi      # 0x9f98
movq %r13, %rdx
xorl %eax, %eax
callq 0x2130
testq %r12, %r12
je 0x3c9a
movq (%rbx), %rdi
leaq 0x630c(%rip), %rsi      # 0x9f9c
movq %r12, %rdx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rcx
leaq 0x62fd(%rip), %rdi      # 0x9fa1
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x21a0
movq (%rbx), %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x2190
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x2100
testl %r14d, %r14d
jne 0x3cdd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rcx
leaq 0x62bd(%rip), %rdi      # 0x9fa4
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %r14d
pushq $0x38
popq %rdi
callq 0x36ef
movq %rax, %rbx
testq %rax, %rax
je 0x40c4
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x30(%rbx)
movb $0x1, 0x30(%rbx)
callq 0x28e4
movq %rax, (%rbx)
callq 0x28e4
movq %rax, 0x8(%rbx)
callq 0x28e4
movq %rax, 0x10(%rbx)
callq 0x28e4
movq %rax, 0x18(%rbx)
movl %r14d, %edi
callq 0x2f7c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x4145
movq 0x8(%rbx), %rdi
leaq 0x6b(%rip), %r14        # 0x4151
movq %r14, %rsi
callq 0x2b58
movq 0x8(%rbx), %rdi
callq 0x2986
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2b58
movq 0x10(%rbx), %rdi
callq 0x2986
movq (%rbx), %rdi
leaq 0x1318(%rip), %rsi      # 0x542e
callq 0x2b58
movq (%rbx), %rdi
callq 0x2986
movq 0x18(%rbx), %rdi
movq 0xae92(%rip), %rsi      # 0xefc0
callq 0x2b58
movq 0x18(%rbx), %rdi
callq 0x2986
movq 0x20(%rbx), %rdi
callq 0x2fdd
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x41a6
movq 0x10(%rbx), %rdi
callq 0x21d0
movl 0x8(%rbx), %eax
cmpl $0x2d, %eax
je 0x419d
cmpl $0x28, %eax
je 0x4197
cmpl $0x27, %eax
jne 0x41a6
movq 0x20(%rbx), %rdi
callq 0x2311
movq 0x28(%rbx), %rdi
callq 0x2311
movq 0x30(%rbx), %rdi
callq 0x2311
jmp 0x41a6
cmpb $0x0, 0x1c(%rbx)
jne 0x41a6
movq 0x20(%rbx), %rdi
callq 0x21d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x4064
movq %rax, %rbx
movb $0x1, %r12b
leaq 0xabec(%rip), %r15      # 0xedc0
pushq $0x7b
popq %r14
pushq $0x3b
popq %r13
movq 0x20(%rbx), %rdi
callq 0x3519
cmpl $0x70, %eax
je 0x4241
movq 0x20(%rbx), %rdi
callq 0x302d
addl $-0x65, %eax
cmpl $0x4, %eax
jae 0x425f
movl %eax, %eax
movq (%r15,%rax,8), %r12
movq 0x20(%rbx), %rdi
callq 0x302d
cmpq $0x32, %rax
jne 0x427b
movq %rbx, %rdi
callq *%r12
cmpl $-0x1, %eax
je 0x4294
movq 0x20(%rbx), %rdi
callq 0x302d
cmpq $0x33, %rax
jne 0x4277
movq 0x20(%rbx), %rdi
callq 0x302d
xorl %r12d, %r12d
cmpq $0x30, %rax
je 0x41dc
movl %r13d, %r14d
jmp 0x427b
testb $0x1, %r12b
je 0x429e
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x5ebc(%rip), %rsi      # 0xa112
xorl %eax, %eax
callq 0x3d00
jmp 0x429e
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x5eb0(%rip), %rsi      # 0xa11e
xorl %eax, %eax
callq 0x3b9c
jmp 0x4294
pushq $0x7d
popq %r14
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x5eab(%rip), %rsi      # 0xa135
movl %r14d, %edx
xorl %eax, %eax
callq 0x3b9c
movq %rbx, %rdi
callq 0x40cc
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/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:
testq %rdi, %rdi
je 0x435e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4ece(%rip), %rdx      # 0x919b
pushq $0x27
popq %rsi
callq 0x435f
movq %rax, %r14
movb $0x1, 0xc(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x53dc
movq %rax, %r15
movq (%rax), %rcx
movq 0x30(%r14), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rcx
jae 0x430d
pushq $0x1
popq %rax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x4315
movq %rcx, %rsi
callq 0x23b9
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rcx
movq (%rax), %rax
movq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0x5468
leaq 0x5ca9(%rip), %rdx      # 0x9fdc
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x435f
movb $0x1, 0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x5468
movq (%r14), %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.c
// Function: add_symbol_cfg
static symbol_t*
add_symbol_cfg(cfg_t* cfg, int kind, char const* crt_lexeme) {
	vector_t* dest = (kind == T_NON_TERMINAL)
						? cfg->non_terminal : cfg->terminal;
	if (crt_lexeme) {
		int index = get_index_vector(dest, crt_lexeme, &cmp_symbol_name);
		if (index != -1)
			{ return ((symbol_t*)AT_VECTOR(dest, index)); }
	}

	symbol_t* symbol = NEW(symbol_t, 1);
	if (!symbol)
		{ return (NULL); }
	memset(symbol, 0, sizeof(*symbol));

	symbol->kind = kind;
	if (crt_lexeme)
		{ symbol->name = strdup(crt_lexeme); }

	int fail = 0;
	if (crt_lexeme && !symbol->name)
		{ fail = 1; }
	
	if (kind == T_LITERAL) 
		{ symbol->terminal_alias = -1; }
	else {
		symbol->is_used = true;
		if (kind == T_TERMINAL)
			{ symbol->is_defined = true; }
		else {
			symbol->prod_lst = new_bitset();
			if (!symbol->prod_lst)
				{ fail = 1; }
		}
	}

	if (fail) {
		free_symbol(symbol);
		return (NULL);
	}

/*
	if (kind == T_NON_TERMINAL)
		{ *strchr(sym->name, '>') = EOS; }

	//vector_t** dst = (kind == T_NON_TERMINAL)
	//? cfg->non_terminal : cfg->terminal;
	//size_t hs = hash_str(sym->name) % HASH_SIZE;
	//else
	//	{ FREE(sym); }
*/

	symbol->index = SIZE_VECTOR(dest);
	PUSH_BACK_VECTOR(dest, symbol);

	return (symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %esi, %r15d
xorl %eax, %eax
cmpl $0x27, %esi
setne %al
movq 0x8(%rdi,%rax,8), %rbx
testq %rdx, %rdx
je 0x43a7
leaq 0x477(%rip), %rdx       # 0x4800
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2af6
cmpl $-0x1, %eax
je 0x43a7
movq (%rbx), %rcx
cltq
movq (%rcx,%rax,8), %r14
jmp 0x444c
pushq $0x58
popq %rdi
callq 0x36ef
testq %rax, %rax
je 0x4449
movq %rax, %r14
andq $0x0, 0x50(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movl %r15d, 0x8(%rax)
testq %r12, %r12
je 0x43f4
movq %r12, %rdi
callq 0x21b0
movq %rax, 0x10(%r14)
testq %rax, %rax
setne %r12b
jmp 0x43f7
movb $0x1, %r12b
cmpl $0x28, %r15d
jne 0x4404
orl $-0x1, 0x18(%r14)
jmp 0x4414
movb $0x1, 0xd(%r14)
cmpl $0x2d, %r15d
jne 0x442d
movb $0x1, 0xc(%r14)
testb %r12b, %r12b
je 0x4441
movq 0x10(%rbx), %rsi
movq %rsi, (%r14)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x29d6
jmp 0x444c
callq 0x22cc
movq %rax, 0x30(%r14)
testq %rax, %rax
setne %al
testb %r12b, %al
jne 0x4419
movq %r14, %rdi
callq 0x4151
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x4512
movq %rdi, %r14
cmpb $0x1, 0x30(%rdi)
jne 0x4480
leaq 0x5b65(%rip), %rsi      # 0x9fe0
jmp 0x4509
movq 0x18(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x4502
movq 0x8(%r14), %rdi
callq 0x534a
cmpl $-0x1, %eax
je 0x4512
movq 0x10(%r14), %rdi
callq 0x534a
cmpl $-0x1, %eax
je 0x4512
movq %r14, %rdi
callq 0x5560
cmpl $-0x1, %eax
je 0x4512
movq %r14, %rdi
callq 0x5861
cmpl $-0x1, %eax
jne 0x44d1
leaq 0x5b71(%rip), %rsi      # 0xa039
xorl %edi, %edi
xorl %eax, %eax
callq 0x3d00
movq %r14, %rdi
callq 0x5667
movq %r14, %rdi
callq 0x5cd8
movq %r14, %rdi
callq 0x5d40
movq %r14, %rdi
callq 0x5a5c
cmpl $-0x1, %eax
je 0x4512
movq %r14, %rdi
callq 0x5e08
xorl %ebx, %ebx
jmp 0x4512
leaq 0x5b01(%rip), %rsi      # 0xa00a
xorl %edi, %edi
xorl %eax, %eax
callq 0x3b9c
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5b3d(%rip), %rdi      # 0xa067
callq 0x2060
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
cmpq 0x10(%rax), %r14
jae 0x4551
movq (%rax), %rax
movq (%rax,%r14,8), %rax
movq 0x10(%rax), %rdi
callq 0x2060
incq %r14
jmp 0x4532
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5b11(%rip), %rdi      # 0xa078
callq 0x2060
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %r14
jae 0x458e
movq (%rax), %rax
movq (%rax,%r14,8), %rax
movq 0x10(%rax), %rdi
callq 0x2060
incq %r14
jmp 0x456f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5ae2(%rip), %rdi      # 0xa08d
callq 0x2060
leaq 0x59e2(%rip), %r12      # 0x9f99
pushq $0x20
popq %r13
xorl %r14d, %r14d
movq (%rbx), %rax
cmpq 0x10(%rax), %r14
jae 0x461f
movq (%rax), %rax
movq (%rax,%r14,8), %r15
movq 0x8(%r15), %rax
movq 0x10(%rax), %rsi
leaq 0x5ac3(%rip), %rdi      # 0xa0a0
xorl %eax, %eax
callq 0x20a0
addq $0x10, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4612
movq 0x8(%r15), %rax
movq 0x10(%rax), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x20a0
cmpq $0x0, (%r15)
je 0x45e8
movl %r13d, %edi
callq 0x2040
jmp 0x45e8
pushq $0xa
popq %rdi
callq 0x2040
incq %r14
jmp 0x45be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5a65(%rip), %rdi      # 0xa0a7
callq 0x2060
leaq 0x5a71(%rip), %r14      # 0xa0bf
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %r15
jae 0x467b
movq (%rax), %rax
movq (%rax,%r15,8), %rax
cmpb $0x1, 0x18(%rax)
jne 0x4676
movq 0x10(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20a0
incq %r15
jmp 0x4651
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5a32(%rip), %rdi      # 0xa0d0
callq 0x2060
leaq 0x58ef(%rip), %r12      # 0x9f99
xorl %ecx, %ecx
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %rcx
jae 0x4734
movq (%rax), %rax
movq %rcx, -0x30(%rbp)
movq (%rax,%rcx,8), %r15
movq 0x10(%r15), %rsi
leaq 0x5a16(%rip), %rdi      # 0xa0e2
xorl %eax, %eax
callq 0x20a0
movb $0x1, %r13b
movq 0x20(%r15), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x471c
movl %eax, %r14d
testb $0x1, %r13b
jne 0x46fb
leaq 0x6452(%rip), %rdi      # 0xab46
xorl %eax, %eax
callq 0x20a0
movq 0x10(%rbx), %rax
movq (%rax), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
xorl %r13d, %r13d
movq %r12, %rdi
xorl %eax, %eax
callq 0x20a0
jmp 0x46d6
leaq 0x5c78(%rip), %rdi      # 0xa39b
callq 0x2060
movq -0x30(%rbp), %rcx
incq %rcx
jmp 0x46ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5995(%rip), %rdi      # 0xa0f0
callq 0x2060
leaq 0x5832(%rip), %r12      # 0x9f99
xorl %ecx, %ecx
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %rcx
jae 0x47f1
movq (%rax), %rax
movq %rcx, -0x30(%rbp)
movq (%rax,%rcx,8), %r15
movq 0x10(%r15), %rsi
leaq 0x597a(%rip), %rdi      # 0xa103
xorl %eax, %eax
callq 0x20a0
movb $0x1, %r13b
movq 0x28(%r15), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x47d9
movl %eax, %r14d
testb $0x1, %r13b
jne 0x47b8
leaq 0x6395(%rip), %rdi      # 0xab46
xorl %eax, %eax
callq 0x20a0
movq 0x10(%rbx), %rax
movq (%rax), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
xorl %r13d, %r13d
movq %r12, %rdi
xorl %eax, %eax
callq 0x20a0
jmp 0x4793
leaq 0x5bbb(%rip), %rdi      # 0xa39b
callq 0x2060
movq -0x30(%rbp), %rcx
incq %rcx
jmp 0x4769
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
xorl %r15d, %r15d
movq 0x20(%rbx), %rdi
callq 0x3519
cmpl $0x33, %eax
je 0x48b8
movq 0x20(%rbx), %rdi
callq 0x302d
movq 0x20(%rbx), %rcx
cmpq $0x28, %rax
jne 0x48a2
movq 0x10(%rcx), %rdi
movq %r14, %rsi
callq 0x2e79
movq 0x18(%rbx), %r12
movq 0x20(%rbx), %rax
movq 0x10(%r12), %r13
movq 0x10(%rax), %rax
movq (%rax), %rdi
incq %rdi
callq 0x21b0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x29d6
movq 0x20(%rbx), %rdi
callq 0x3519
cmpl $0x31, %eax
jne 0x48b8
movq 0x20(%rbx), %rdi
callq 0x302d
jmp 0x4832
movslq 0x28(%rcx), %rdi
leaq 0x58ac(%rip), %rsi      # 0xa159
xorl %eax, %eax
callq 0x3b9c
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
pushq $0x27
popq %r12
pushq $-0x1
popq %rbx
movq 0x20(%r15), %rdi
callq 0x3519
cmpl $0x33, %eax
je 0x4b60
movq 0x20(%r15), %rdi
callq 0x302d
cmpq $0x27, %rax
jne 0x4b64
movq 0x20(%r15), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
movq %r15, %rdi
movl %r12d, %esi
callq 0x435f
movq %rax, %r13
movq 0x20(%r15), %rdi
callq 0x3519
movl %eax, %r14d
movq 0x20(%r15), %rdi
callq 0x302d
cmpl $0x2e, %r14d
jne 0x4b28
movb $0x0, 0x30(%r15)
movb $0x1, 0xc(%r13)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4da7
cmpl $-0x1, %eax
jne 0x4b44
jmp 0x4bb0
movq 0x20(%r15), %rdi
testq %rax, %rax
jne 0x4b85
callq 0x302d
cmpq $0x6b, %rax
jne 0x4b96
movq (%r13), %rax
movq %rax, 0x28(%r15)
movq 0x20(%r15), %rdi
callq 0x302d
cmpq $0x30, %rax
jne 0x4b6d
andq $0x0, 0x18345(%rip)     # 0x1cea0
jmp 0x4ab0
xorl %ebx, %ebx
jmp 0x4bb0
leaq 0x573f(%rip), %rdx      # 0xa2aa
jmp 0x4b74
leaq 0x5742(%rip), %rdx      # 0xa2b6
movq 0x20(%r15), %rax
movslq 0x28(%rax), %rdi
leaq 0x5735(%rip), %rsi      # 0xa2b8
jmp 0x4ba9
movslq 0x28(%rdi), %rdi
movq 0x10(%r13), %rdx
leaq 0x575f(%rip), %rsi      # 0xa2f3
jmp 0x4ba9
movq 0x20(%r15), %rax
movslq 0x28(%rax), %rdi
movq 0x10(%r13), %rdx
leaq 0x572e(%rip), %rsi      # 0xa2d7
xorl %eax, %eax
callq 0x3b9c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r13d, %r13d
pushq $0x8
popq %r15
movq 0x20(%r14), %rdi
callq 0x3519
cmpl $0x33, %eax
je 0x4d74
movq 0x20(%r14), %rdi
callq 0x302d
movq %rax, %r12
addl $-0x6c, %eax
movq 0x20(%r14), %rdi
cmpl $0x3, %eax
jae 0x4d78
callq 0x302d
cmpq $0x34, %rax
jne 0x4d85
movslq %r12d, %rbx
leal 0x1(%r13), %eax
movl %eax, -0x2c(%rbp)
movq 0x20(%r14), %rdi
callq 0x3519
movl %eax, %r12d
cmpl $0x2d, %eax
je 0x4c3b
cmpl $0x28, %r12d
jne 0x4d96
cmpl $0x2d, %r12d
je 0x4c4b
cmpl $0x28, %r12d
jne 0x4cfd
movq 0x20(%r14), %rdi
callq 0x302d
movq 0x20(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
movq %r14, %rdi
movl %r12d, %esi
callq 0x435f
movq %rax, %r12
cmpq $0x0, 0x20(%rax)
jne 0x4d2f
movq %r15, %rdi
callq 0x36ef
testq %rax, %rax
je 0x4d62
andq $0x0, (%rax)
movl %r13d, (%rax)
cmpq $0x6e, %rbx
je 0x4cae
cmpq $0x6d, %rbx
je 0x4ca8
cmpq $0x6c, %rbx
jne 0x4cb4
movb $0x1, 0x4(%rax)
jmp 0x4cb4
movb $0x1, 0x5(%rax)
jmp 0x4cb4
movw $0x101, 0x4(%rax)       # imm = 0x101
movq %rax, 0x20(%r12)
movq 0x20(%r14), %rdi
callq 0x3519
cmpl $0x31, %eax
je 0x4cd5
movq 0x20(%r14), %rdi
callq 0x3519
cmpl $0x35, %eax
jne 0x4d4c
movq 0x20(%r14), %rdi
callq 0x3519
cmpl $0x31, %eax
jne 0x4cec
movq 0x20(%r14), %rdi
callq 0x302d
movq 0x20(%r14), %rdi
callq 0x3519
movl %eax, %r12d
jmp 0x4c3b
movq 0x20(%r14), %rdi
callq 0x302d
movq 0x20(%r14), %rdi
callq 0x3519
movl -0x2c(%rbp), %ebx
movl %ebx, %r13d
cmpl $0x31, %eax
jne 0x4bd9
movq 0x20(%r14), %rdi
callq 0x302d
movl %ebx, %r13d
jmp 0x4bd9
movq 0x20(%r14), %rax
movslq 0x28(%rax), %rdi
movq 0x10(%r12), %rdx
leaq 0x5874(%rip), %rsi      # 0xa5b7
xorl %eax, %eax
callq 0x3b9c
jmp 0x4d62
movq 0x20(%r14), %rax
movslq 0x28(%rax), %rdi
leaq 0x5889(%rip), %rsi      # 0xa5e4
xorl %eax, %eax
callq 0x3b9c
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x4d65
movslq 0x28(%rdi), %rdi
leaq 0x57ab(%rip), %rsi      # 0xa52e
jmp 0x4d5b
movq 0x20(%r14), %rax
movslq 0x28(%rax), %rdi
leaq 0x57c8(%rip), %rsi      # 0xa55c
jmp 0x4d5b
movq 0x20(%r14), %rax
movslq 0x28(%rax), %rdi
leaq 0x57e9(%rip), %rsi      # 0xa58e
jmp 0x4d5b
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x53dc
movq %rax, %r12
movq (%rax), %rcx
movq 0x30(%rbx), %rdi
movl 0x4(%rdi), %eax
pushq $0x1
popq %r13
cmpq %rax, %rcx
jae 0x4df0
movq %r13, %rax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x4df8
movq %rcx, %rsi
callq 0x23b9
movq %r14, %rdi
movq %r12, %rsi
callq 0x4e8e
pushq $-0x1
popq %r15
cmpl $-0x1, %eax
je 0x4e7c
movq %r14, %rdi
movq %r12, %rsi
callq 0x4f8e
cmpl $-0x1, %eax
je 0x4e7c
movq 0x20(%r14), %rdi
callq 0x3519
cmpl $0x29, %eax
jne 0x4e79
movq 0x20(%r14), %rdi
callq 0x302d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53dc
movq %rax, %r12
movq (%rax), %rcx
movq 0x30(%rbx), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rcx
jae 0x4e64
movq %r13, %rax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x4e6c
movq %rcx, %rsi
callq 0x23b9
movq %r14, %rdi
movq %r12, %rsi
callq 0x4e8e
jmp 0x4e07
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
orl $-0x1, (%rsp)
pushq $0x2a
popq %rsi
pushq $0x32
popq %rdx
pushq $0x27
popq %rcx
pushq $0x2d
popq %r8
pushq $0x28
popq %r9
xorl %eax, %eax
callq 0x3545
testb %al, %al
je 0x4f1d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5039
pushq $-0x1
popq %r15
cmpl $-0x1, %eax
je 0x4f7c
pushq $0x2d
popq %r13
pushq $0x28
popq %r12
xorl %r15d, %r15d
movq 0x20(%r14), %rdi
orl $-0x1, (%rsp)
pushq $0x2a
popq %rsi
pushq $0x32
popq %rdx
pushq $0x27
popq %rcx
movl %r13d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x3545
testb %al, %al
je 0x4f7c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5039
cmpl $-0x1, %eax
jne 0x4ee9
jmp 0x4f78
movq 0x20(%r14), %rdi
callq 0x3519
movq 0x20(%r14), %rdi
cmpl $0x6a, %eax
jne 0x4f39
callq 0x302d
xorl %r15d, %r15d
jmp 0x4f7c
orl $-0x1, (%rsp)
xorl %r15d, %r15d
pushq $0x2b
popq %rsi
pushq $0x33
popq %rdx
pushq $0x34
popq %rcx
pushq $0x29
popq %r8
pushq $0x30
popq %r9
xorl %eax, %eax
callq 0x3545
testb %al, %al
jne 0x4f7c
movq 0x20(%r14), %rax
movslq 0x28(%rax), %rdi
movq (%rbx), %rdx
incq %rdx
leaq 0x53c3(%rip), %rsi      # 0xa334
xorl %eax, %eax
callq 0x3b9c
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg.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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x3519
xorl %r14d, %r14d
cmpl $0x34, %eax
jne 0x502d
movq 0x20(%rbx), %rdi
callq 0x302d
movq 0x20(%rbx), %rdi
callq 0x302d
pushq $-0x1
popq %r12
cmpq $0x69, %rax
jne 0x502a
movq 0x20(%rbx), %rdi
callq 0x302d
cmpl $0x2d, %eax
je 0x4fdf
cmpl $0x28, %eax
jne 0x5014
movq 0x20(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x435f
movq %rax, 0x28(%r15)
movb $0x1, 0xd(%rax)
movq 0x20(%rbx), %rdi
callq 0x302d
cmpq $0x35, %rax
je 0x502d
leaq 0x54ec(%rip), %rsi      # 0xa4fe
jmp 0x501b
leaq 0x549f(%rip), %rsi      # 0xa4ba
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
xorl %eax, %eax
callq 0x3b9c
movl %r12d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x52b4(%rip), %r15      # 0xa616
pushq $-0x1
popq %r13
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq 0x10(%rbx), %r14
jae 0x53c9
movq (%rbx), %rax
movq (%rax,%r14,8), %rax
cmpb $0x0, 0xc(%rax)
je 0x539b
cmpb $0x0, 0xd(%rax)
jne 0x53c4
movq 0x10(%rax), %rdx
xorl %edi, %edi
leaq 0x52bc(%rip), %rsi      # 0xa64e
xorl %eax, %eax
callq 0x3d00
jmp 0x53c4
cmpl $0x27, 0x8(%rax)
leaq 0x52a0(%rip), %rdx      # 0xa646
leaq 0x528c(%rip), %rcx      # 0xa639
cmoveq %rcx, %rdx
movq 0x10(%rax), %rcx
xorl %edi, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3b9c
movl %r13d, %r12d
incq %r14
jmp 0x536c
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: new_production
production_t*
new_production(symbol_t* lhs, cfg_t const* cfg) {
	production_t* prod = NEW(production_t, 1);

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

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

	return (prod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x30
popq %rdi
callq 0x36ef
movq %rax, %rbx
testq %rax, %rax
je 0x5420
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq (%r14), %rdi
movq 0x10(%rdi), %rsi
movq %rsi, (%rbx)
movq %rbx, %rdx
callq 0x29d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: del_production
void
del_production(production_t* prod) {
	if (prod) {
		list_rhs_t* it_list = prod->rhs_element;
		while (it_list) {
			list_rhs_t* next = it_list->next;
			FREE(it_list);
			it_list = next;
		}
		del_bitset(prod->select_set);
	}
	FREE(prod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x545c
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5453
movq (%rdi), %r14
callq 0x21d0
movq %r14, %rdi
jmp 0x5441
movq 0x18(%rbx), %rdi
callq 0x2311
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: add_symbol_rhs
int
add_symbol_rhs(production_t* prod, symbol_t* symbol) {
	if (!prod)
		{ return (ERROR); }

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %r14
testq %rdi, %rdi
je 0x54c8
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x36ef
testq %rax, %rax
je 0x54c8
andq $0x0, (%rax)
movq $0x1, 0x10(%rax)
movq %r15, 0x8(%rax)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x54be
pushq $0x2
popq %rdx
movq %rcx, %rbx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x54c2
movq %rdx, 0x10(%rax)
incq %rdx
jmp 0x54aa
addq $0x10, %rbx
movq %rax, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: add_symbol_rhs_front
int
add_symbol_rhs_front(production_t* prod, symbol_t* symbol) {
	if (!prod)
		{ return (ERROR); }

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

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

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

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

	return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %r14
testq %rdi, %rdi
je 0x5528
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x36ef
testq %rax, %rax
je 0x5528
andq $0x0, (%rax)
movq $0x1, 0x10(%rax)
movq %r15, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
testq %rcx, %rcx
je 0x5525
incq 0x10(%rcx)
movq (%rcx), %rcx
jmp 0x5517
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: last_symbol_in_prod
symbol_t*
last_symbol_in_prod(production_t const* prod) {
	if (!prod)
		{ return (NULL); }
	symbol_t* last_ter = NULL;
	list_rhs_t* list = prod->rhs_element;
	while (list) {	
		if (IS_TERMINAL(list->symbol_rhs))
			{ last_ter = list->symbol_rhs; }
		list = list->next;
	}
	return (last_ter);
}

// Assembly:
testq %rdi, %rdi
je 0x555d
pushq %rbp
movq %rsp, %rbp
addq $0x10, %rdi
xorl %eax, %eax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x555b
movq 0x8(%rdi), %rcx
cmpl $0x2d, 0x8(%rcx)
cmoveq %rcx, %rax
jmp 0x5545
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: preprocess_literal
int
preprocess_literal(cfg_t const* cfg) {
	if (!cfg)
		{ return (ERROR); }

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

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

	if (is_error == ERROR)
		{ return (ERROR); }
	
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
		production_t* prod = (production_t*)AT_VECTOR(cfg->productions, i);
		if (prod->mimic_sym && (prod->mimic_sym->kind == T_LITERAL)) {
			prod->mimic_sym = (symbol_t*)AT_VECTOR(cfg->terminal,
											prod->mimic_sym->terminal_alias);
		}
		list_rhs_t* list = prod->rhs_element;
		while (list) {
			if (list->symbol_rhs->kind == T_LITERAL) {
				list->symbol_rhs = (symbol_t*)AT_VECTOR(cfg->terminal,
										list->symbol_rhs->terminal_alias);
			}
			list = list->next;
		}
	}
	return (DONE);
}

// Assembly:
testq %rdi, %rdi
je 0x5651
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x50f4(%rip), %r14      # 0xa675
pushq $-0x1
popq %r15
xorl %r12d, %r12d
xorl %eax, %eax
movq 0x10(%rbx), %rcx
cmpq 0x10(%rcx), %r12
jae 0x55e9
movq (%rcx), %rcx
movq (%rcx,%r12,8), %r13
cmpl $0x28, 0x8(%r13)
jne 0x55e4
movslq 0x18(%r13), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0x55d7
cmpq 0x20(%r13), %rdx
je 0x55e4
movq 0x10(%rcx), %rdx
movq 0x10(%r13), %rcx
xorl %edi, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3b9c
movb $0x0, 0x1c(%r13)
movl %r15d, %eax
jmp 0x55e4
movb $0x1, 0x1c(%r13)
movq 0x20(%r13), %rdx
movq %rdx, 0x20(%rcx)
incq %r12
jmp 0x558a
cmpl $-0x1, %eax
je 0x5655
movq (%rbx), %rdx
movq 0x10(%rdx), %rsi
xorl %eax, %eax
xorl %edi, %edi
cmpq %rsi, %rdi
je 0x5658
movq (%rdx), %r8
movq (%r8,%rdi,8), %r8
movq 0x28(%r8), %r9
testq %r9, %r9
je 0x5624
cmpl $0x28, 0x8(%r9)
jne 0x5624
movq (%rcx), %r10
movslq 0x18(%r9), %r9
movq (%r10,%r9,8), %r9
movq %r9, 0x28(%r8)
addq $0x10, %r8
movq (%r8), %r8
testq %r8, %r8
je 0x564c
movq 0x8(%r8), %r9
cmpl $0x28, 0x8(%r9)
jne 0x5628
movq (%rcx), %r10
movslq 0x18(%r9), %r9
movq (%r10,%r9,8), %r9
movq %r9, 0x8(%r8)
jmp 0x5628
incq %rdi
jmp 0x55f9
pushq $-0x1
popq %rax
retq
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: check_mimic_prod
int
check_mimic_prod(cfg_t const* cfg) {
	if (!cfg)
		{ return (ERROR); }
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions); ++i) {
		production_t* prod = (production_t*)AT_VECTOR(cfg->productions, i);
		if (prod->mimic_sym) {
			if (!last_symbol_in_prod(prod)) {
				warnf(0, "The production %zu contain no terminal"
							" for the $MIMIC.", GET_INDEX(prod) + 1);
			}
			if (!prod->mimic_sym->prec) {
				warnf(0, "The precedence is not defined for the terminal %s.",
							prod->mimic_sym->name);
			}
		}
	}
	return (DONE);
}

// Assembly:
testq %rdi, %rdi
je 0x56f8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x505c(%rip), %r12      # 0xa6e4
xorl %ebx, %ebx
movq (%r14), %rax
cmpq 0x10(%rax), %rbx
jae 0x56e7
movq (%rax), %rax
movq (%rax,%rbx,8), %r13
movq 0x28(%r13), %r15
testq %r15, %r15
je 0x56e2
movq %r13, %rdi
callq 0x5536
testq %rax, %rax
jne 0x56cb
movq (%r13), %rdx
incq %rdx
xorl %edi, %edi
leaq 0x4fed(%rip), %rsi      # 0xa6ad
xorl %eax, %eax
callq 0x3d00
movq 0x28(%r13), %r15
cmpq $0x0, 0x20(%r15)
jne 0x56e2
movq 0x10(%r15), %rdx
xorl %edi, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3d00
incq %rbx
jmp 0x568a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfp/src/cfg_production.c
// Function: list_is_nullable
bool
list_is_nullable(list_rhs_t const* list) {
	if (!list)
		{ return (true); }
	while (list) {
		if (list->symbol_rhs->kind == T_TERMINAL)
			{ return (false); }
		else if (!list->symbol_rhs->nullable)
			{ return (false); }
		list = list->next;
	}
	return (true);
}

// Assembly:
testq %rdi, %rdi
je 0x5724
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %al
je 0x5722
movq 0x8(%rdi), %rcx
cmpl $0x2d, 0x8(%rcx)
je 0x5722
cmpb $0x1, 0x18(%rcx)
jne 0x5722
movq (%rdi), %rdi
jmp 0x5705
popq %rbp
retq
movb $0x1, %al
retq