LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/buffer.c
// Function: move_front_buffer
void
move_front_buffer(buffer_t* dst_buff, buffer_t* src_buff, size_t size) {
    if (size > SIZE_BUFFER(src_buff))
        { size = SIZE_BUFFER(src_buff); }
    for (size_t i = 0; i < size; ++i) {
        int char_at = CHAR_AT(src_buff, i);
        write_char_buffer(dst_buff, char_at);
    }
    unget_char_front_buffer(src_buff, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x10(%rsi), %rax
cmpq %rdx, %rax
cmovbq %rax, %r14
testq %r14, %r14
je 0x31c9
movq %rdi, %r15
xorl %r12d, %r12d
movq (%rbx), %rax
movsbl (%rax,%r12), %esi
movq %r15, %rdi
callq 0x2f24
incq %r12
cmpq %r12, %r14
jne 0x31b1
testq %rbx, %rbx
je 0x3216
movq 0x10(%rbx), %rdx
subq %r14, %rdx
jbe 0x3200
movq %rdx, 0x10(%rbx)
movq (%rbx), %rdi
leaq (%rdi,%r14), %rsi
callq 0x2170
movq (%rbx), %rdi
addq 0x10(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
xorl %esi, %esi
callq 0x20d0
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/lexer.c
// Function: new_lexer
lexer_t*
new_lexer(int filde) {
    lexer_t* lex = NEW(lexer_t, 1);

    if (!lex)
        { return (NULL); }
    memset(lex, 0, sizeof(*lex));

    lex->filde = filde;

    lex->push_back = new_buffer();
    lex->last_lexeme = new_buffer();

    lex->last_token = NO_TOKEN;
    lex->lineno = START_LINE;
    
    lex->stack_state = new_vector();
    lex->crt_state = INIT_STATE;

    return (lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
movl $0x30, %edi
callq 0x3b0a
testq %rax, %rax
je 0x3280
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movl %r14d, (%rax)
callq 0x2e68
movq %rax, 0x8(%rbx)
callq 0x2e68
movq %rax, 0x10(%rbx)
movl $0xffffffff, 0x4(%rbx)  # imm = 0xFFFFFFFF
movl $0x1, 0x28(%rbx)
callq 0x2afc
movq %rax, 0x18(%rbx)
movq $0x1, 0x20(%rbx)
jmp 0x3282
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/lexer.c
// Function: del_lexer
void
del_lexer(lexer_t* lex) {
    if (lex) {
        del_buffer(lex->push_back);
        del_buffer(lex->last_lexeme);
        del_vector(lex->stack_state);
    }
    FREE(lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x32b3
movq 0x8(%rbx), %rdi
callq 0x2f00
movq 0x10(%rbx), %rdi
callq 0x2f00
movq 0x18(%rbx), %rdi
callq 0x2b9e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/lexer.c
// Function: peek_token
int
peek_token(lexer_t* lex) {
    if (!lex)
        { return (-1); }
    if (lex->last_token == -1)
        { lex->last_token = advance_token(lex); }
    return (lex->last_token);
}

// Assembly:
testq %rdi, %rdi
je 0x399d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rdi)
jne 0x3993
movq %rbx, %rdi
callq 0x32da
movl %eax, 0x4(%rbx)
movl 0x4(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/lexer.c
// Function: in_first
bool
in_first(lexer_t* lex, ...) {
    va_list args;
    va_start(args, lex);
    int token;
    while ((token = va_arg(args, int)) != -1) {
        if (token == peek_token(lex))
            { return (true); }
    }
    va_end(args);
    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x39fc
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x3a2e
movq %rcx, %rax
addq -0x20(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x30(%rbp)
jmp 0x3a3a
movq -0x28(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %r14d
cmpl $-0x1, %r14d
je 0x3a68
testq %rbx, %rbx
je 0x3a5e
cmpl $-0x1, 0x4(%rbx)
jne 0x3a59
movq %rbx, %rdi
callq 0x32da
movl %eax, 0x4(%rbx)
movl 0x4(%rbx), %eax
jmp 0x3a63
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %eax, %r14d
jne 0x3a16
cmpl $-0x1, %r14d
setne %al
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: round_up
size_t
round_up(size_t size) {
    size_t close2 = 1;
    while (close2 <= size)
        { close2 <<= 1; }
    return (close2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %ecx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rdi, %rax
jbe 0x3a85
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: strjoin
char*
strjoin(char const* str1, char const* str2) {
    size_t const s1 = strlen(str1);
    size_t const s2 = strlen(str2);
    char* frame = NEW(char, s1 + s2 + 1);
    if (!frame)
        { return (NULL); }
    memcpy(frame, str1, sizeof(char) * s1);
    memcpy(frame + s1, str2, sizeof(char) * s2);
    frame[s1 + s2] = EOS;
    return (frame);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2090
movq %rax, %r15
movq %rbx, %rdi
callq 0x2090
movq %rax, %r12
addq %r15, %rax
movq %rax, -0x30(%rbp)
leaq (%r12,%r15), %rdi
incq %rdi
callq 0x3b0a
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2140
addq %r13, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2140
movq -0x30(%rbp), %rax
movb $0x0, (%r13,%rax)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: pmalloc
void*
_pmalloc(size_t size) {
    if (!size)
        { size = 1; }
    void* chunk = malloc(size);
#ifndef NDEBUG
    assert(chunk);
#else
    if (!chunk) {
        errorf(0, "No enough memory for this process.");
        errno = ENOMEM;
    }
#endif
    return (chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x1, %rdi
adcq $0x0, %rdi
callq 0x2150
testq %rax, %rax
je 0x3b22
popq %rbp
retq
leaq 0x63f5(%rip), %rdi      # 0x9f1e
leaq 0x63c1(%rip), %rsi      # 0x9ef1
leaq 0x63cc(%rip), %rcx      # 0x9f03
movl $0xc8, %edx
callq 0x20b0
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: get_filename
char const*
get_filename(char const* path) {
    char const* last = path;
    while (*path) {
        if (*path++ == '/')
            { last = path; }
    }
    return (last);
}

// Assembly:
movq %rdi, %rax
movb (%rdi), %cl
testb %cl, %cl
je 0x3b63
pushq %rbp
movq %rsp, %rbp
leaq 0x1(%rax), %rdx
cmpb $0x2f, %cl
cmoveq %rdx, %rax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x3b52
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: readjust_index
void
readjust_index(vector_t* vect, size_t base, void(*dealloc)(void*)) {
    if (base >= SIZE_VECTOR(vect))
        { return; }
    (*dealloc)(AT_VECTOR(vect, base));
    erase_vector(vect, base);
    for (size_t i = base; i < SIZE_VECTOR(vect); ++i) {
        obj_index_t* obj = (obj_index_t*)AT_VECTOR(vect, i);
        --(obj->index);
    }
}

// Assembly:
cmpq %rsi, 0x10(%rdi)
jbe 0x3baa
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax,%rsi,8), %rdi
callq *%rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c7d
movq 0x10(%r14), %rax
cmpq %rbx, %rax
jbe 0x3ba6
movq (%r14), %rcx
movq (%rcx,%rbx,8), %rdx
decq (%rdx)
incq %rbx
cmpq %rbx, %rax
jne 0x3b97
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: new_trans_list
trans_list_t*
new_trans_list(int input, int state, trans_list_t* tail) {
    trans_list_t* list = NEW(trans_list_t, 1);
    if (!list)
        { return (NULL); }
    list->input = input;
    list->state = state;
    list->next = tail;
    return (list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %r15d
movl $0x10, %edi
callq 0x3b0a
movl %r15d, 0x8(%rax)
movl %r14d, 0xc(%rax)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: size_gen_list
size_t
size_gen_list(gen_list_t const* list) {
    size_t crt_size = 0;
    while (list) {
        ++crt_size;
        list = list->next;
    }
    return (crt_size);
}

// Assembly:
testq %rdi, %rdi
je 0x3bf6
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incq %rax
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x3be9
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: redirect_trans_list
void
redirect_trans_list(trans_list_t* list, int change, int base) {
    while (list) {
        if (list->state == base)
            { list->state = change; }
        else if (list->state > base)
            { --(list->state); }
        list = list->next;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3c1d
pushq %rbp
movq %rsp, %rbp
movl 0xc(%rdi), %eax
movl %esi, %ecx
cmpl %edx, %eax
je 0x3c11
jle 0x3c14
decl %eax
movl %eax, %ecx
movl %ecx, 0xc(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x3c02
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: del_node_trans_list
void
del_node_trans_list(trans_list_t** list, trans_list_t const* tnode) {
    if (!list || !*list || !tnode)
        { return; }

    if ((*list) == tnode)
        { (*list) = tnode->next; }
    else {
        trans_list_t* base = *list;
        while (base) {
            if (base->next == tnode) {
                base->next = tnode->next;
                break;
            }
            base = base->next;
        }
    }
    FREE(tnode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x3c65
movq (%rdi), %rax
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x3c65
cmpq %rsi, %rax
je 0x3c67
testq %rax, %rax
je 0x3c6d
movq %rax, %rdi
movq (%rax), %rax
jmp 0x3c53
popq %rbp
retq
movq (%rsi), %rax
movq %rax, (%rdi)
movq %rsi, %rdi
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: del_trans_list
void
del_trans_list(trans_list_t* list) {
    while (list) {
        trans_list_t* next = list->next;
        FREE(list);
        list = next;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3c97
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rbx
callq 0x21d0
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x3c81
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: trans_list_at
trans_list_t*
trans_list_at(trans_list_t* base, size_t at) {
    size_t count_index = 0;
    while (count_index < at) {
        if (!base)
            { return (NULL); }
        ++count_index;
        base = base->next;
    }
    return (base);
}

// Assembly:
movq %rdi, %rax
testq %rsi, %rsi
je 0x3cb6
pushq %rbp
movq %rsp, %rbp
testq %rax, %rax
je 0x3cb3
movq (%rax), %rax
decq %rsi
jne 0x3ca4
jmp 0x3cb5
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/tools/src/utils.c
// Function: cmp_input_trans_list
int
cmp_input_trans_list(trans_list_t const* list, int input) {
    if (!list)
        { return (-1); }
    size_t count_index = 0;
    while (list) {
        if (list->input == input)
            { return (count_index); }
        ++count_index;
        list = list->next;
    }
    return (-1);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x3cdb
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
cmpl %esi, 0x8(%rdi)
je 0x3cd8
movq (%rdi), %rdi
incl %ecx
testq %rdi, %rdi
jne 0x3cc7
jmp 0x3cda
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
setne %al
testq %rsi, %rsi
setne %cl
movl %eax, %edx
andb %cl, %dl
cmpb $0x1, %dl
jne 0x3d1e
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x3d24
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x3d24
movq (%rdi), %rdi
movq (%rsi), %rsi
testq %rsi, %rsi
setne %cl
testq %rdi, %rdi
setne %al
je 0x3d1e
testq %rsi, %rsi
jne 0x3cf5
orb %cl, %al
xorb $0x1, %al
jmp 0x3d26
xorl %eax, %eax
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3d50
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3d50
movl 0x8(%rax), %ecx
decl %ecx
cmpl 0x8(%rdi), %ecx
jne 0x3d50
movl 0xc(%rax), %ecx
cmpl 0xc(%rdi), %ecx
je 0x3d2e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %cl
testb %cl, %cl
je 0x3d73
pushq %rbp
movq %rsp, %rbp
incq %rdi
xorl %eax, %eax
movsbq %cl, %rcx
addq %rcx, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x3d61
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3dd4
callq 0x2050
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x11, (%rcx)
jne 0x3dd4
movq %rbx, %rdi
movl $0x201, %esi            # imm = 0x201
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e0d
callq 0x2160
testq %rax, %rax
jne 0x3e14
leaq 0x6125(%rip), %rdi      # 0x9f1a
leaq 0x60f5(%rip), %rsi      # 0x9ef1
leaq 0x6121(%rip), %rcx      # 0x9f24
movl $0xda, %edx
callq 0x20b0
callq 0x21d0
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3e65
leaq -0x100(%rdi), %rax
cmpq $0xff00, %rax           # imm = 0xFF00
setb %cl
movb $0x10, %al
testb %sil, %cl
jne 0x3e65
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_O1/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 0x60c5(%rip), %rsi      # 0x9f46
movl $0x1, %edx
callq 0x2080
movb (%r14), %r13b
testb %r13b, %r13b
je 0x3edb
callq 0x21c0
movq %rax, %r15
incq %r14
leaq -0x29(%rbp), %r12
movq (%r15), %rcx
movsbq %r13b, %r13
movb $0x5f, %al
testb $0x8, (%rcx,%r13,2)
je 0x3ebe
callq 0x2030
movq (%rax), %rax
movb (%rax,%r13,4), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movl %ebx, %edi
movq %r12, %rsi
callq 0x2080
movb (%r14), %r13b
incq %r14
testb %r13b, %r13b
jne 0x3ea2
leaq 0x6062(%rip), %rsi      # 0x9f44
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_O1/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 0x603c(%rip), %rsi      # 0x9f48
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3e67
leaq 0x602d(%rip), %rsi      # 0x9f51
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3e67
leaq 0x6a4e(%rip), %rsi      # 0xa98c
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x600d(%rip), %rsi      # 0x9f5b
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x6012(%rip), %rsi      # 0x9f70
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
callq 0x21c0
movq %rax, %r15
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x3fdf
leaq 0x5f73(%rip), %rsi      # 0x9f46
movl $0x1, %edx
movl %ebx, %edi
callq 0x2080
movb (%r14), %al
testb %al, %al
je 0x4016
cmpb $0x5f, %al
je 0x3ffa
movq (%r15), %rcx
movsbq %al, %rax
movzwl (%rcx,%rax,2), %eax
andl $0x8, %eax
je 0x4016
leaq 0x1(%r14), %r12
movl $0x1, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x2080
movb 0x1(%r14), %al
movq %r12, %r14
jmp 0x3fe2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x38, %edi
callq 0x3b0a
testq %rax, %rax
je 0x43f3
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x30(%rax)
movb $0x1, 0x30(%rax)
callq 0x2afc
movq %rax, (%rbx)
callq 0x2afc
movq %rax, 0x8(%rbx)
callq 0x2afc
movq %rax, 0x10(%rbx)
callq 0x2afc
movq %rax, 0x18(%rbx)
movl %r14d, %edi
callq 0x3220
movq %rax, 0x20(%rbx)
jmp 0x43f5
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/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 0x4476
movq 0x8(%rbx), %rdi
leaq 0x6b(%rip), %r14        # 0x4482
movq %r14, %rsi
callq 0x2d75
movq 0x8(%rbx), %rdi
callq 0x2b9e
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2d75
movq 0x10(%rbx), %rdi
callq 0x2b9e
movq (%rbx), %rdi
leaq 0x14b1(%rip), %rsi      # 0x58f8
callq 0x2d75
movq (%rbx), %rdi
callq 0x2b9e
movq 0x18(%rbx), %rdi
movq 0xab61(%rip), %rsi      # 0xefc0
callq 0x2d75
movq 0x18(%rbx), %rdi
callq 0x2b9e
movq 0x20(%rbx), %rdi
callq 0x328a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/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 0x44e5
movq 0x10(%rbx), %rdi
callq 0x21d0
movl 0x8(%rbx), %eax
cmpl $0x2d, %eax
je 0x44c8
cmpl $0x28, %eax
je 0x44d6
cmpl $0x27, %eax
jne 0x44e5
movq 0x20(%rbx), %rdi
callq 0x248a
movq 0x28(%rbx), %rdi
callq 0x248a
movq 0x30(%rbx), %rdi
callq 0x248a
jmp 0x44e5
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0x44e0
cmpl $0x28, %eax
jne 0x44e5
cmpb $0x0, 0x1c(%rbx)
jne 0x44e5
movq 0x20(%rbx), %rdi
callq 0x21d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/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 0x438c
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0x3974
cmpl $0x70, %eax
jne 0x4532
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x5c18(%rip), %rsi      # 0xa13e
xorl %eax, %eax
callq 0x22b9
jmp 0x463b
movl %eax, %r14d
leaq 0x5abc(%rip), %r12      # 0x9ff8
xorl %r15d, %r15d
movq 0x20(%rbx), %rdi
callq 0x32da
addl $-0x65, %eax
cmpl $0x3, %eax
ja 0x4585
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
xorl %eax, %eax
leaq 0x6db(%rip), %r13       # 0x4c3d
jmp 0x458a
xorl %eax, %eax
leaq 0x776(%rip), %r13       # 0x4ce3
jmp 0x458a
xorl %eax, %eax
leaq 0xa89(%rip), %r13       # 0x5001
jmp 0x458a
xorl %eax, %eax
leaq 0x92a(%rip), %r13       # 0x4ead
jmp 0x458a
movb $0x1, %al
xorl %r13d, %r13d
movq 0x20(%rbx), %rdi
testb %al, %al
jne 0x45e4
callq 0x32da
cmpq $0x32, %rax
jne 0x45f8
movq %rbx, %rdi
callq *%r13
cmpl $-0x1, %eax
je 0x4600
movq 0x20(%rbx), %rdi
callq 0x32da
cmpq $0x33, %rax
jne 0x4604
movq 0x20(%rbx), %rdi
callq 0x32da
cmpq $0x30, %rax
jne 0x460c
movq 0x20(%rbx), %rdi
callq 0x3974
cmpl $0x70, %eax
jne 0x453f
cmpl $0x70, %r14d
je 0x4517
jmp 0x463b
movslq 0x28(%rdi), %rdi
leaq 0x5b5b(%rip), %rsi      # 0xa14a
xorl %eax, %eax
callq 0x4020
jmp 0x4631
movl $0x7b, %r15d
jmp 0x4612
movb $0x1, %al
jmp 0x4614
movl $0x7d, %r15d
jmp 0x4612
movl $0x3b, %r15d
xorl %eax, %eax
testb %al, %al
jne 0x4631
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x5b3a(%rip), %rsi      # 0xa161
movl %r15d, %edx
xorl %eax, %eax
callq 0x4020
movq %rbx, %rdi
callq 0x43fd
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_O1/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 0x4701
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x56a5(%rip), %rdx      # 0x9d0f
movl $0x27, %esi
callq 0x4702
movq %rax, %r14
movb $0x1, 0xc(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x58a0
movq %rax, %r15
movq (%rax), %rcx
movq 0x30(%r14), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rcx
jae 0x46ae
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x46b6
movq %rcx, %rsi
callq 0x2568
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rcx
movq (%rax), %rax
movq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0x5935
leaq 0x5934(%rip), %rdx      # 0xa008
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x4702
movb $0x1, 0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x5935
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r15d
xorl %eax, %eax
cmpl $0x27, %esi
setne %al
movq 0x8(%rdi,%rax,8), %rbx
testq %rdx, %rdx
je 0x4754
leaq 0x4f4(%rip), %rdx       # 0x4c23
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d0a
cmpl $-0x1, %eax
je 0x474b
movq (%rbx), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %r14
jmp 0x474b
cmpl $-0x1, %eax
jne 0x4805
movl $0x58, %edi
callq 0x3b0a
xorl %r13d, %r13d
testq %rax, %rax
je 0x47ee
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x50(%rax)
movl %r15d, 0x8(%rax)
testq %r12, %r12
je 0x47aa
movq %r12, %rdi
callq 0x21b0
movq %rax, 0x10(%r14)
xorl %r13d, %r13d
testq %rax, %rax
sete %r13b
cmpl $0x28, %r15d
jne 0x47ba
movl $0xffffffff, 0x18(%r14) # imm = 0xFFFFFFFF
jmp 0x47e1
movb $0x1, 0xd(%r14)
cmpl $0x2d, %r15d
jne 0x47cc
movb $0x1, 0xc(%r14)
jmp 0x47e1
callq 0x243c
movq %rax, 0x30(%r14)
testq %rax, %rax
movl $0x1, %eax
cmovel %eax, %r13d
testl %r13d, %r13d
je 0x47f3
movq %r14, %rdi
callq 0x4482
xorl %r14d, %r14d
jmp 0x4805
movq 0x10(%rbx), %rsi
movq %rsi, (%r14)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2bf1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x48d3
movq %rdi, %r14
cmpb $0x1, 0x30(%rdi)
jne 0x4841
leaq 0x57d0(%rip), %rsi      # 0xa00c
jmp 0x48ca
movq 0x18(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x48c3
movq 0x8(%r14), %rdi
callq 0x5801
cmpl $-0x1, %eax
je 0x48d3
movq 0x10(%r14), %rdi
callq 0x5801
cmpl $-0x1, %eax
je 0x48d3
movq %r14, %rdi
callq 0x5a48
cmpl $-0x1, %eax
je 0x48d3
movq %r14, %rdi
callq 0x5da5
cmpl $-0x1, %eax
jne 0x4892
leaq 0x57dc(%rip), %rsi      # 0xa065
xorl %edi, %edi
xorl %eax, %eax
callq 0x22b9
movq %r14, %rdi
callq 0x5b60
movq %r14, %rdi
callq 0x629c
movq %r14, %rdi
callq 0x6303
movq %r14, %rdi
callq 0x5fcb
cmpl $-0x1, %eax
je 0x48d3
movq %r14, %rdi
callq 0x63cf
xorl %ebx, %ebx
jmp 0x48d3
leaq 0x576c(%rip), %rsi      # 0xa036
xorl %edi, %edi
xorl %eax, %eax
callq 0x4020
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x57a8(%rip), %rdi      # 0xa093
callq 0x2060
movq 0x10(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x491b
xorl %r14d, %r14d
movq (%rax), %rax
movq (%rax,%r14,8), %rax
movq 0x10(%rax), %rdi
callq 0x2060
incq %r14
movq 0x10(%rbx), %rax
cmpq 0x10(%rax), %r14
jb 0x48fe
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5773(%rip), %rdi      # 0xa0a4
callq 0x2060
movq 0x8(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x4961
xorl %r14d, %r14d
movq (%rax), %rax
movq (%rax,%r14,8), %rax
movq 0x10(%rax), %rdi
callq 0x2060
incq %r14
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %r14
jb 0x4944
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x573b(%rip), %rdi      # 0xa0b9
callq 0x2060
movq (%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x49ff
leaq 0x5738(%rip), %r14      # 0xa0cc
leaq 0x5617(%rip), %r15      # 0x9fb2
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20a0
movq 0x10(%r13), %r13
testq %r13, %r13
je 0x49e9
movq 0x8(%r13), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20a0
cmpq $0x0, (%r13)
je 0x49e3
movl $0x20, %edi
callq 0x2040
movq (%r13), %r13
jmp 0x49bb
movl $0xa, %edi
callq 0x2040
incq %r12
movq (%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x499e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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 0x56b1(%rip), %rdi      # 0xa0d3
callq 0x2060
movq 0x8(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x4a64
leaq 0x56b2(%rip), %r14      # 0xa0eb
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rax
cmpb $0x1, 0x18(%rax)
jne 0x4a57
movq 0x10(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20a0
incq %r15
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %r15
jb 0x4a3c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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 0x5675(%rip), %rdi      # 0xa0fc
callq 0x2060
movq 0x8(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x4b3a
leaq 0x5510(%rip), %r12      # 0x9fb2
xorl %ecx, %ecx
movq (%rax), %rax
movq %rcx, -0x30(%rbp)
movq (%rax,%rcx,8), %r13
movq 0x10(%r13), %rsi
leaq 0x5654(%rip), %rdi      # 0xa10e
xorl %eax, %eax
callq 0x20a0
movq 0x20(%r13), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x4b19
movl %eax, %r14d
movb $0x1, %r15b
testb $0x1, %r15b
jne 0x4ae9
leaq 0x6076(%rip), %rdi      # 0xab58
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 %r15d, %r15d
movq %r12, %rdi
xorl %eax, %eax
callq 0x20a0
movq 0x20(%r13), %rdi
callq 0x28eb
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x4ad5
leaq 0x58a7(%rip), %rdi      # 0xa3c7
callq 0x2060
movq -0x30(%rbp), %rcx
incq %rcx
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %rcx
jb 0x4aa4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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 0x55bb(%rip), %rdi      # 0xa11c
callq 0x2060
movq 0x8(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x4c14
leaq 0x5436(%rip), %r12      # 0x9fb2
xorl %ecx, %ecx
movq (%rax), %rax
movq %rcx, -0x30(%rbp)
movq (%rax,%rcx,8), %r13
movq 0x10(%r13), %rsi
leaq 0x559b(%rip), %rdi      # 0xa12f
xorl %eax, %eax
callq 0x20a0
movq 0x28(%r13), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x4bf3
movl %eax, %r14d
movb $0x1, %r15b
testb $0x1, %r15b
jne 0x4bc3
leaq 0x5f9c(%rip), %rdi      # 0xab58
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 %r15d, %r15d
movq %r12, %rdi
xorl %eax, %eax
callq 0x20a0
movq 0x28(%r13), %rdi
callq 0x28eb
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x4baf
leaq 0x57cd(%rip), %rdi      # 0xa3c7
callq 0x2060
movq -0x30(%rbp), %rcx
incq %rcx
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %rcx
jb 0x4b7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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 %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x20(%rbx), %rdi
callq 0x3974
cmpl $0x33, %eax
je 0x4cd7
movq 0x20(%rbx), %rdi
callq 0x32da
movq 0x20(%rbx), %rcx
cmpq $0x28, %rax
jne 0x4cbf
movq 0x10(%rcx), %rdi
movl $0x1, %esi
callq 0x30b2
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %rax
movq 0x10(%r15), %r12
movq 0x10(%rax), %rax
movq (%rax), %rdi
incq %rdi
callq 0x21b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2bf1
movq 0x20(%rbx), %rdi
callq 0x3974
cmpl $0x31, %eax
jne 0x4cd7
movq 0x20(%rbx), %rdi
callq 0x32da
jmp 0x4c4e
movslq 0x28(%rcx), %rdi
leaq 0x54bb(%rip), %rsi      # 0xa185
xorl %eax, %eax
callq 0x4020
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq 0x20(%rdi), %rdi
callq 0x3974
xorl %r12d, %r12d
cmpl $0x33, %eax
je 0x4fef
leaq 0x53fc(%rip), %r14      # 0xa2d6
leaq 0x543e(%rip), %r15      # 0xa31f
movq 0x20(%rbx), %rdi
callq 0x32da
cmpq $0x27, %rax
jne 0x4f93
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x27, %esi
callq 0x4702
movq %rax, %r12
movq 0x20(%rbx), %rdi
callq 0x3974
movl %eax, %r13d
movq 0x20(%rbx), %rdi
callq 0x32da
cmpl $0x2e, %r13d
jne 0x4f46
movb $0x0, 0x30(%rbx)
movb $0x1, 0xc(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5221
cmpl $-0x1, %eax
jne 0x4f62
jmp 0x4fa2
movq 0x20(%rbx), %rdi
testq %rax, %rax
jne 0x4fb4
callq 0x32da
cmpq $0x6b, %rax
jne 0x4fa9
movq (%r12), %rax
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rdi
callq 0x32da
xorl %r12d, %r12d
cmpq $0x30, %rax
jne 0x4f97
movq $0x0, 0x17f11(%rip) # 0x1ce90
movq 0x20(%rbx), %rdi
callq 0x3974
cmpl $0x33, %eax
jne 0x4ee1
jmp 0x4fef
xorl %eax, %eax
jmp 0x4fcc
xorl %eax, %eax
leaq 0x5342(%rip), %r14      # 0xa2e2
jmp 0x4fcc
movb $0x1, %al
xorl %r14d, %r14d
jmp 0x4fcc
movq 0x20(%rbx), %rdi
leaq 0x534f(%rip), %r15      # 0xa303
movslq 0x28(%rdi), %rdi
movq 0x10(%r12), %rdx
xorl %r14d, %r14d
movq %r15, %rsi
xorl %eax, %eax
callq 0x4020
movb $0x1, %al
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb %al, %al
jne 0x4fef
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x52ff(%rip), %rsi      # 0xa2e4
movq %r14, %rdx
xorl %eax, %eax
callq 0x4020
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x58a0
movq %rax, %r12
movq (%rax), %rcx
movq 0x30(%rbx), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rcx
jae 0x5265
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x526d
movq %rcx, %rsi
callq 0x2568
movq %r14, %rdi
movq %r12, %rsi
callq 0x5301
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x52f5
movq %r14, %rdi
movq %r12, %rsi
callq 0x541c
cmpl $-0x1, %eax
je 0x52f5
movq 0x20(%r14), %rdi
callq 0x3974
cmpl $0x29, %eax
jne 0x52f2
movq 0x20(%r14), %rdi
callq 0x32da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58a0
movq %rax, %r12
movq (%rax), %rcx
movq 0x30(%rbx), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rcx
jae 0x52dd
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x52e5
movq %rcx, %rsi
callq 0x2568
movq %r14, %rdi
movq %r12, %rsi
callq 0x5301
jmp 0x527e
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0x2a, %esi
movl $0x32, %edx
movl $0x27, %ecx
movl $0x2d, %r8d
movl $0x28, %r9d
xorl %eax, %eax
callq 0x39a3
testb %al, %al
je 0x53a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x54c7
cmpl $-0x1, %eax
je 0x5408
xorl %r15d, %r15d
movq 0x20(%r14), %rdi
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movl $0x2a, %esi
movl $0x32, %edx
movl $0x27, %ecx
movl $0x2d, %r8d
movl $0x28, %r9d
xorl %eax, %eax
callq 0x39a3
testb %al, %al
je 0x540e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x54c7
cmpl $-0x1, %eax
jne 0x5359
jmp 0x5408
movq 0x20(%r14), %rdi
callq 0x3974
movq 0x20(%r14), %rdi
cmpl $0x6a, %eax
jne 0x53bc
callq 0x32da
xorl %r15d, %r15d
jmp 0x540e
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movl $0x2b, %esi
movl $0x33, %edx
movl $0x34, %ecx
movl $0x29, %r8d
movl $0x30, %r9d
xorl %eax, %eax
callq 0x39a3
testb %al, %al
jne 0x540e
movq 0x20(%r14), %rax
movslq 0x28(%rax), %rdi
movq (%rbx), %rdx
incq %rdx
leaq 0x4f5f(%rip), %rsi      # 0xa360
xorl %eax, %eax
callq 0x4020
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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 %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x3974
xorl %r14d, %r14d
cmpl $0x34, %eax
jne 0x54b9
movq 0x20(%rbx), %rdi
callq 0x32da
movq 0x20(%rbx), %rdi
callq 0x32da
cmpq $0x69, %rax
jne 0x54b3
movq 0x20(%rbx), %rdi
callq 0x32da
cmpl $0x2d, %eax
je 0x5468
cmpl $0x28, %eax
jne 0x549d
movq 0x20(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x4702
movq %rax, 0x28(%r15)
movb $0x1, 0xd(%rax)
movq 0x20(%rbx), %rdi
callq 0x32da
cmpq $0x35, %rax
je 0x54b9
leaq 0x508f(%rip), %rsi      # 0xa52a
jmp 0x54a4
leaq 0x5042(%rip), %rsi      # 0xa4e6
movq 0x20(%rbx), %rax
movslq 0x28(%rax), %rdi
xorl %eax, %eax
callq 0x4020
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/cfg.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
cmpq $0x0, 0x10(%rdi)
je 0x5889
movq %rdi, %rbx
leaq 0x4e52(%rip), %r14      # 0xa672
leaq 0x4e1b(%rip), %r15      # 0xa642
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
cmpb $0x0, 0xc(%rax)
je 0x5856
cmpb $0x0, 0xd(%rax)
jne 0x587e
movq 0x10(%rax), %rdx
xorl %edi, %edi
leaq 0x4e2d(%rip), %rsi      # 0xa67a
xorl %eax, %eax
callq 0x22b9
jmp 0x587e
cmpl $0x27, 0x8(%rax)
movq %r14, %rdx
leaq 0x4e01(%rip), %rcx      # 0xa665
cmoveq %rcx, %rdx
movq 0x10(%rax), %rcx
xorl %edi, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4020
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
incq %r13
cmpq 0x10(%rbx), %r13
jb 0x582d
jmp 0x588c
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop