LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: print_token_entry
void
print_token_entry(lexical_spec_t* spec) {
    for (size_t i = 0; i < SIZE_VECTOR(spec->entry_vect); ++i) {
        spec_entry_t* crt_entry = AT_VECTOR(spec->entry_vect, i);
        printf("Token %s, fragment %d.\n",
                                        crt_entry->name, crt_entry->fragment);
        printf("Root node = %p\n", crt_entry->regex_ast);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x50b3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x93f3(%rip), %rdi      # 0xe47b
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x93f5(%rip), %rdi      # 0xe493
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5044
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_regex_opt_fragment
int
spec_regex_opt_fragment(lexical_spec_t* spec, spec_entry_t* entry) {
    if (peek_token(spec->lex) == T_ARROW) {
        advance_token(spec->lex);
        if (peek_token(spec->lex) == T_FRAGMENT) {
            advance_token(spec->lex);
            entry->fragment = true;

            if (entry->fragment && entry->use_look) {
                errorf(CURRENT_LINE(spec->lex),
                            "The token %s use the lookahead feature"
                            " but it's a fragment token.", entry->name);
                return (ERROR);
            }
        }
        else {
            errorf(CURRENT_LINE(spec->lex),
                            "A $FRAGMENT must appear after the '->'.");
            return (ERROR);
        }
    }
    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3300
cmpl $0x2e, %eax
jne 0x5b4a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cc0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3300
cmpl $0x44, %eax
jne 0x5b26
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cc0
movq -0x18(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x5b24
movq -0x18(%rbp), %rax
testb $0x1, 0x1a(%rax)
je 0x5b24
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x8bb5(%rip), %rsi      # 0xe6c9
movb $0x0, %al
callq 0x4230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5b51
jmp 0x5b48
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x8bd3(%rip), %rsi      # 0xe70b
movb $0x0, %al
callq 0x4230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5b51
jmp 0x5b4a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_action_state
int
spec_action_state(lexical_spec_t* spec, spec_entry_t* entry) {
    if (advance_token(spec->lex) != T_LPAREN) {
        errorf(CURRENT_LINE(spec->lex),
                        "Missing an open paren in the action list construct.");
        return (ERROR);
    }
    
    size_t count_pos = 0;
    if (spec_action_pair(spec, entry, &count_pos) == ERROR)
        { return (ERROR); }

    while (peek_token(spec->lex) == T_COMMA) {
        advance_token(spec->lex);
        if (peek_token(spec->lex) == T_RPAREN)
            { break; }
        else if (spec_action_pair(spec, entry, &count_pos) == ERROR)
            { return (ERROR); }
    }

    if (advance_token(spec->lex) != T_RPAREN) {
        errorf(CURRENT_LINE(spec->lex),
                    "Missing a close paren in the action list construct.");
        return (ERROR);
    }
    return (DONE);  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cc0
cmpq $0x34, %rax
je 0x5ba7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x8b9f(%rip), %rsi      # 0xe733
movb $0x0, %al
callq 0x4230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c61
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5c70
cmpl $-0x1, %eax
jne 0x5bd1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c61
jmp 0x5bd3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3300
cmpl $0x31, %eax
jne 0x5c26
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cc0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3300
cmpl $0x35, %eax
jne 0x5c03
jmp 0x5c26
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5c70
cmpl $-0x1, %eax
jne 0x5c22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c61
jmp 0x5c24
jmp 0x5bd3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cc0
cmpq $0x35, %rax
je 0x5c5a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x8b1d(%rip), %rsi      # 0xe767
movb $0x0, %al
callq 0x4230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c61
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: del_nfa_record
void
del_nfa_record(void) {
    foreach_vector(record_nfa_state, &del_nfa_state);
    del_vector(record_nfa_state);
    foreach_vector(record_nfa_automata, &del_nfa_automaton);
    del_vector(record_nfa_automata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1ba25(%rip), %rdi     # 0x21db0
leaq 0x3e(%rip), %rsi        # 0x63d0
callq 0x23c0
movq 0x1ba12(%rip), %rdi     # 0x21db0
callq 0x2010
movq 0x1ba0e(%rip), %rdi     # 0x21db8
leaq 0x6f(%rip), %rsi        # 0x6420
callq 0x23c0
movq 0x1b9fb(%rip), %rdi     # 0x21db8
callq 0x2010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: del_nfa_state
static void
del_nfa_state(nfa_state_t* state) {
    if (state) {
        if (state->symbol_edge == EDGE_CLASS)
            { del_bitset(state->class); }
        del_bitset(state->eclos);
    }
    FREE(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6407
movq -0x8(%rbp), %rax
cmpl $-0x2, 0x10(%rax)
jne 0x63fa
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1320
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1320
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: transform_regex_nfa
static int
transform_regex_nfa(spec_entry_t* crt_entry) {
    regex_node_t* root = crt_entry->regex_ast;
    int exit_st = DONE;

    if ((crt_entry->nfa_m = dfs_regex_node(root)) == NULL_AUTOMATON)
        { exit_st = ERROR; }
    else
        { STATE_FINAL(crt_entry->nfa_m->head_state, GET_INDEX(crt_entry)); }

    if (crt_entry->beg_line)
        { STATE_ANCHOR(crt_entry->nfa_m->head_state); }

    del_regex_node(root);
    crt_entry->regex_ast = NULL_NODE;

    return (exit_st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x70b0
movq -0x8(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0x69ef
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x6a07
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x19(%rax)
je 0x6a21
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movb $0x1, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0xa380
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: dfs_regex_node
static nfa_automaton_t* 
dfs_regex_node(regex_node_t* root) {
    if (root) {
        switch (root->kind_ast) {
            case AST_UNION:
                return (regex_node_union(root));

            case AST_LOOK:
            case AST_CONCAT:
                return (regex_node_concat(root));

            case AST_QUES:
            case AST_PLUS:
            case AST_STAR:
                return (regex_node_closure(root));

            case AST_TILDE:
                return (regex_node_tilde(root->left));

            case AST_OPTION:
                return (regex_node_option(root));

            case AST_SYMBOL:
                return (regex_node_symbol(root->symbol));

            case AST_EPSILON:
                return (regex_node_epsilon());

            case AST_DOT:
                return (regex_node_dot(root->is_dotall));

            case AST_CLASS:
                return (regex_node_class(root->class));

            default:
                break;
        }   
    }
    return (NULL_AUTOMATON);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x718f
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0xc, %rax
ja 0x718b
movq -0x18(%rbp), %rax
leaq 0x7b92(%rip), %rcx      # 0xec78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x71b0
movq %rax, -0x8(%rbp)
jmp 0x7197
movq -0x10(%rbp), %rdi
callq 0x7310
movq %rax, -0x8(%rbp)
jmp 0x7197
movq -0x10(%rbp), %rdi
callq 0x7450
movq %rax, -0x8(%rbp)
jmp 0x7197
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x75a0
movq %rax, -0x8(%rbp)
jmp 0x7197
movq -0x10(%rbp), %rdi
callq 0x76f0
movq %rax, -0x8(%rbp)
jmp 0x7197
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x7780
movq %rax, -0x8(%rbp)
jmp 0x7197
callq 0x77d0
movq %rax, -0x8(%rbp)
jmp 0x7197
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x7820
movq %rax, -0x8(%rbp)
jmp 0x7197
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x78e0
movq %rax, -0x8(%rbp)
jmp 0x7197
jmp 0x718d
jmp 0x718f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_union
static nfa_automaton_t*
regex_node_union(regex_node_t* root) {
    nfa_automaton_t* left = dfs_regex_node(root->left);
    if (!left)
        { return (NULL_AUTOMATON); }

    nfa_automaton_t* right = dfs_regex_node(root->right);
    if (!right) {
        del_nfa_automaton(left);
        return (NULL_AUTOMATON);
    }

    nfa_state_t* new_tail_state = new_nfa_state(EDGE_AUTOMATA, left, right);
    nfa_state_t* new_head_state = new_nfa_state(NO_EDGE);

    if ((!new_tail_state) || (!new_head_state)) {
        del_nfa_automaton(left);
        del_nfa_automaton(right);
        return (NULL_AUTOMATON);
    }

    if (left->head_state->symbol_edge == NO_EDGE)
        { left->head_state->symbol_edge = EPSILON; }
    else
        { left->head_state->symbol_edge = EDGE_BOTH; }
    left->head_state->out_state = new_head_state; 

    if (right->head_state->symbol_edge == NO_EDGE)
        { right->head_state->symbol_edge = EPSILON; } 
    else
        { right->head_state->symbol_edge = EDGE_BOTH; }
    right->head_state->out_state = new_head_state;   

    return (new_nfa_automaton(NFA_UNION,
                                left, right, new_tail_state, new_head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x71e1
movq $0x0, -0x8(%rbp)
jmp 0x7300
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x70b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x720f
movq -0x18(%rbp), %rdi
callq 0x6420
movq $0x0, -0x8(%rbp)
jmp 0x7300
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x6460
movq %rax, -0x28(%rbp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movb $0x0, %al
callq 0x6460
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7245
cmpq $0x0, -0x30(%rbp)
jne 0x7264
movq -0x18(%rbp), %rdi
callq 0x6420
movq -0x20(%rbp), %rdi
callq 0x6420
movq $0x0, -0x8(%rbp)
jmp 0x7300
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $-0x4, 0x10(%rax)
jne 0x7283
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl $0x101, 0x10(%rax)      # imm = 0x101
jmp 0x7292
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl $0xfffffffd, 0x10(%rax) # imm = 0xFFFFFFFD
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $-0x4, 0x10(%rax)
jne 0x72c1
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl $0x101, 0x10(%rax)      # imm = 0x101
jmp 0x72d0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl $0xfffffffd, 0x10(%rax) # imm = 0xFFFFFFFD
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x3, %edi
movb $0x0, %al
callq 0x6bf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_concat
static nfa_automaton_t*
regex_node_concat(regex_node_t* root) {
    nfa_automaton_t* left = dfs_regex_node(root->left);
    if (!left)
        { return (NULL_AUTOMATON); }

    size_t start_state = SIZE_VECTOR(record_nfa_state);

    nfa_automaton_t* right = dfs_regex_node(root->right);
    if (!right) {
        del_nfa_automaton(left);
        return (NULL_AUTOMATON);
    }
    else if (IS_LOOK(root)) {
        for (size_t i = start_state; i < SIZE_VECTOR(record_nfa_state); ++i) {
            nfa_state_t* crt_state = (nfa_state_t*)
                                        AT_VECTOR(record_nfa_state, i);
            crt_state->in_look_machine = true;
        }
    }

    if (left->head_state->symbol_edge != EDGE_AUTOMATA) {
        left->head_state->symbol_edge = EDGE_AUTOMATA;
        left->head_state->edge = right;
    }
    else
        { left->head_state->edge2 = right; }

    if (root->kind_ast == AST_LOOK)
        { set_states_lookahead(right); }

    return (new_nfa_automaton(NFA_CONCAT, left, right, right->head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7341
movq $0x0, -0x8(%rbp)
jmp 0x7441
movq 0x1aa68(%rip), %rax     # 0x21db0
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x70b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x737e
movq -0x18(%rbp), %rdi
callq 0x6420
movq $0x0, -0x8(%rbp)
jmp 0x7441
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x73ce
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x1aa16(%rip), %rcx     # 0x21db0
cmpq 0x10(%rcx), %rax
jae 0x73cc
movq 0x1aa09(%rip), %rax     # 0x21db0
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x1, 0xe(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x738f
jmp 0x73ce
jmp 0x73d0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $-0x1, 0x10(%rax)
je 0x73ff
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x740f
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x7421
movq -0x28(%rbp), %rdi
callq 0x7970
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movl $0x2, %edi
movb $0x0, %al
callq 0x6bf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_closure
static nfa_automaton_t*
regex_node_closure(regex_node_t* root) {
    if (root->kind_ast == AST_QUES) {
        root->right = new_regex_node(AST_EPSILON);
        root->kind_ast = AST_UNION;

        return (regex_node_union(root));
    }
    else if (root->kind_ast == AST_PLUS) {
        root->right = new_regex_node(AST_STAR, cpy_regex_node(root->left));
        root->kind_ast = AST_CONCAT;

        return (regex_node_concat(root));
    }

    nfa_automaton_t* middle = dfs_regex_node(root->left);
    if (!middle)
        { return (NULL_AUTOMATON); }

    nfa_state_t* new_head_state = new_nfa_state(EDGE_AUTOMATA,
                                            middle, NULL_AUTOMATON);

    if (!new_head_state) {
        del_nfa_automaton(middle);
        return (NULL_AUTOMATON);
    }

    if (middle->head_state->symbol_edge == NO_EDGE) 
        { middle->head_state->symbol_edge = EPSILON; }
    else
        { middle->head_state->symbol_edge = EDGE_BOTH; }
    middle->head_state->out_state = new_head_state;

    return (new_nfa_automaton(NFA_CLOSURE, middle, new_head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x7498
movl $0xb, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x71b0
movq %rax, -0x8(%rbp)
jmp 0x7593
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x74e4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa440
movq %rax, %rsi
movl $0x3, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7310
movq %rax, -0x8(%rbp)
jmp 0x7593
jmp 0x74e6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x750b
movq $0x0, -0x8(%rbp)
jmp 0x7593
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x6460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x753d
movq -0x18(%rbp), %rdi
callq 0x6420
movq $0x0, -0x8(%rbp)
jmp 0x7593
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $-0x4, 0x10(%rax)
jne 0x755c
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl $0x101, 0x10(%rax)      # imm = 0x101
jmp 0x756b
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl $0xfffffffd, 0x10(%rax) # imm = 0xFFFFFFFD
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %edi
movb $0x0, %al
callq 0x6bf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_tilde
static nfa_automaton_t*
regex_node_tilde(regex_node_t* root) {
    size_t count_tilde = 0;
    while (root->kind_ast == AST_TILDE) {
        root = root->left;
        ++count_tilde;
    }
    if ((root->kind_ast != AST_SYMBOL) && (root->kind_ast != AST_CLASS)) {
        errorf(0, "The tilde '~' operator can only apply to"
                    " symbol or character class.");
        return (NULL_AUTOMATON);
    }
    else if (count_tilde % 2)
        { return (dfs_regex_node(root)); }

    bitset_t* negate_lang = NULL_BITSET;
    if (root->kind_ast == AST_SYMBOL) {
        negate_lang = new_bitset();
        ADD_BITSET(negate_lang, (size_t)root->symbol);
    }
    else
        { negate_lang = dup_bitset(root->class); }
    
    nfa_automaton_t* new_m = regex_node_class(COMPL_BITSET(negate_lang));
    del_bitset(negate_lang);

    return (new_m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x75d7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x75b4
movq -0x10(%rbp), %rax
cmpl $0xa, (%rax)
je 0x7608
movq -0x10(%rbp), %rax
cmpl $0xc, (%rax)
je 0x7608
xorl %eax, %eax
movl %eax, %edi
leaq 0x76d0(%rip), %rsi      # 0xecc4
movb $0x0, %al
callq 0x4230
movq $0x0, -0x8(%rbp)
jmp 0x76dd
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x7628
movq -0x10(%rbp), %rdi
callq 0x70b0
movq %rax, -0x8(%rbp)
jmp 0x76dd
jmp 0x762a
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xa, (%rax)
jne 0x769d
callq 0x12b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x766b
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0x1440
jmp 0x769b
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x76ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1370
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x18b0
movq %rax, %rdi
callq 0x78e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1320
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_option
static nfa_automaton_t*
regex_node_option(regex_node_t* root) {
    regex_node_t* child = root->left;
    if (root->igcase)
        { set_option_ast(child, &set_igcase); }
    if (root->dotall)
        { set_option_ast(child, &set_dotall); }
    if (root->skipws)
        { set_option_ast(child, &set_skipws); }
    if (root->reverse)
        { reverse_regex_concat(child); }

    nfa_automaton_t* left = dfs_regex_node(child);
    return (left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x7722
movq -0x10(%rbp), %rdi
leaq 0x34b3(%rip), %rsi      # 0xabd0
callq 0xae50
movq -0x8(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x773c
movq -0x10(%rbp), %rdi
leaq 0x33e9(%rip), %rsi      # 0xab20
callq 0xae50
movq -0x8(%rbp), %rax
testb $0x1, 0xa(%rax)
je 0x7756
movq -0x10(%rbp), %rdi
leaq 0x340f(%rip), %rsi      # 0xab60
callq 0xae50
movq -0x8(%rbp), %rax
testb $0x1, 0xb(%rax)
je 0x7769
movq -0x10(%rbp), %rdi
callq 0xb030
movq -0x10(%rbp), %rdi
callq 0x70b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_symbol
static inline nfa_automaton_t*
regex_node_symbol(int symbol) {
    nfa_state_t* new_head_state = new_nfa_state(NO_EDGE);
    if (!new_head_state)
        { return (NULL_AUTOMATON); }
    return (new_nfa_automaton(NFA_SYMBOL, symbol, new_head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movb $0x0, %al
callq 0x6460
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x77ac
movq $0x0, -0x8(%rbp)
jmp 0x77c3
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x4, %edi
movb $0x0, %al
callq 0x6bf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_epsilon
static inline nfa_automaton_t*
regex_node_epsilon(void) {
    nfa_state_t* new_head_state = new_nfa_state(NO_EDGE);
    if (!new_head_state)
        { return (NULL_AUTOMATON); }
    return (new_nfa_automaton(NFA_EPSILON, new_head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movb $0x0, %al
callq 0x6460
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x77f9
movq $0x0, -0x8(%rbp)
jmp 0x780d
movq -0x10(%rbp), %rsi
movl $0x5, %edi
movb $0x0, %al
callq 0x6bf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_dot
static inline nfa_automaton_t*
regex_node_dot(bool is_dotall) {
    bitset_t* dot_range = new_bitset();

    ADD_BITSET(dot_range, '\n');
    COMPL_BITSET(dot_range);

    if (is_dotall)
        { ADD_BITSET(dot_range, '\n'); }
    nfa_automaton_t* nfa_m = regex_node_class(dot_range);

    del_bitset(dot_range);
    return (nfa_m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
callq 0x12b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0xa, %eax
cmpl 0x4(%rcx), %eax
jb 0x7857
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x1440
jmp 0x786c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
orq $0x400, %rcx            # imm = 0x400
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x18b0
testb $0x1, -0x1(%rbp)
je 0x78b7
movq -0x10(%rbp), %rcx
movl $0xa, %eax
cmpl 0x4(%rcx), %eax
jb 0x78a2
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x1440
jmp 0x78b7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
orq $0x400, %rcx            # imm = 0x400
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x78e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1320
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_class
static nfa_automaton_t*
regex_node_class(bitset_t* root_class) {
    nfa_state_t* new_head_state = new_nfa_state(NO_EDGE);
    if (!new_head_state)
        { return (NULL_AUTOMATON); }

    nfa_state_t* new_tail_state = new_nfa_state(EDGE_CLASS,
                                    dup_bitset(root_class), new_head_state);
    if (!new_tail_state) {
        del_nfa_state(new_head_state);
        return (NULL_AUTOMATON);
    }
    
    return (new_nfa_automaton(NFA_CLASS, new_tail_state, new_head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movb $0x0, %al
callq 0x6460
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x790d
movq $0x0, -0x8(%rbp)
jmp 0x795f
movq -0x10(%rbp), %rdi
callq 0x1370
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
movb $0x0, %al
callq 0x6460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7947
movq -0x18(%rbp), %rdi
callq 0x63d0
movq $0x0, -0x8(%rbp)
jmp 0x795f
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x6, %edi
movb $0x0, %al
callq 0x6bf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: set_states_lookahead
static bool
set_states_lookahead(nfa_automaton_t* right) {
    switch (right->kind_nfa) {
        case NFA_UNION: ;
            bool once_false = true;
            once_false = set_states_lookahead(right->right);
            if (!set_states_lookahead(right->left))
                { once_false = false; }
            return (once_false);

        case NFA_CONCAT:
            if (!set_states_lookahead(right->left)
                                && !set_states_lookahead(right->right))
                { return (false); }
            break;

        case NFA_CLOSURE:
            set_states_lookahead(right->middle);
            return (false);
 
        case NFA_CLASS:
        case NFA_SYMBOL:
            right->head_state->beg_lookahead = true;
            break;

        case NFA_EPSILON:
            return (false);

        default:
            break;
    }
    return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x7a2e
movq -0x20(%rbp), %rax
leaq 0x730d(%rip), %rcx      # 0xecac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7970
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7970
testb $0x1, %al
jne 0x79d3
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7a34
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7970
testb $0x1, %al
jne 0x7a05
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7970
testb $0x1, %al
jne 0x7a05
movb $0x0, -0x1(%rbp)
jmp 0x7a34
jmp 0x7a30
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x7a34
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movb $0x1, 0xd(%rax)
jmp 0x7a30
movb $0x0, -0x1(%rbp)
jmp 0x7a34
jmp 0x7a30
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: build_regex
regex_node_t*
build_regex(lexical_spec_t* spec, spec_entry_t* entry) {
    regex_spec = spec;
    regex_entry = entry;
    if (peek_token(spec->lex) == T_REG_CARET) {
        advance_token(spec->lex);
        entry->beg_line = true;
    }
    regex_node_t* root = regex_look();
    if (!root)
        { return (NULL_NODE); }
    if (peek_token(spec->lex) == T_REG_DOLLAR) {
        if (root->kind_ast == AST_LOOK) {
            del_regex_node(root);
            errorf(CURRENT_LINE(regex_spec->lex),
                                "$ can't follow the / operator.");
            return (NULL_NODE);
        }
        advance_token(spec->lex);
        root = new_regex_node(AST_LOOK, root,
                                    new_regex_node(AST_SYMBOL, '\n', false));
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x1a365(%rip)     # 0x21dc0
movq -0x18(%rbp), %rax
movq %rax, 0x1a362(%rip)     # 0x21dc8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3300
cmpl $0x18, %eax
jne 0x7a8b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cc0
movq -0x18(%rbp), %rax
movb $0x1, 0x19(%rax)
callq 0x7b40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7aa8
movq $0x0, -0x8(%rbp)
jmp 0x7b34
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3300
cmpl $0x19, %eax
jne 0x7b2c
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x7af1
movq -0x20(%rbp), %rdi
callq 0xa380
movq 0x1a2ee(%rip), %rax     # 0x21dc0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x732c(%rip), %rsi      # 0xee0c
movb $0x0, %al
callq 0x4230
movq $0x0, -0x8(%rbp)
jmp 0x7b34
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2cc0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xa, %esi
xorl %edx, %edx
movl %esi, %edi
movb $0x0, %al
callq 0x9c00
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movl $0x5, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_look
static regex_node_t*
regex_look(void) {
    regex_node_t* root = regex_union();
    if (!root)
        { return (NULL_NODE); }

    if (peek_token(regex_spec->lex) == T_REG_LOOK) {
        advance_token(regex_spec->lex);
        regex_node_t* right_op = regex_union();
        if (!right_op) {
            del_regex_node(right_op);
            return (NULL_NODE);
        }
        root = new_regex_node(AST_LOOK, root, right_op);
        regex_entry->use_look = true;
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x7be0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7b62
movq $0x0, -0x8(%rbp)
jmp 0x7bd3
movq 0x1a257(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x3300
cmpl $0xb, %eax
jne 0x7bcb
movq 0x1a243(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
callq 0x7be0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7ba8
movq -0x18(%rbp), %rdi
callq 0xa380
movq $0x0, -0x8(%rbp)
jmp 0x7bd3
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x5, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
movq 0x1a201(%rip), %rax     # 0x21dc8
movb $0x1, 0x1a(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_union
static regex_node_t*
regex_union(void) {
    regex_node_t* root = regex_cat();
    if (!root)
        { return (NULL_NODE); }

    while (peek_token(regex_spec->lex) == T_REG_UNION) {
        advance_token(regex_spec->lex);
        regex_node_t* right_op = regex_cat();
        if (!right_op) {
            del_regex_node(root);
            errorf(CURRENT_LINE(regex_spec->lex), "Missing an operand to '|'.");
            return (NULL_NODE);
        }
        root = new_regex_node(AST_UNION, root, right_op);
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x7ca0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7c05
movq $0x0, -0x8(%rbp)
jmp 0x7c88
jmp 0x7c07
movq 0x1a1b2(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x3300
cmpl $0x4, %eax
jne 0x7c80
movq 0x1a19e(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
callq 0x7ca0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7c69
movq -0x10(%rbp), %rdi
callq 0xa380
movq 0x1a176(%rip), %rax     # 0x21dc0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x71d3(%rip), %rsi      # 0xee2b
movb $0x0, %al
callq 0x4230
movq $0x0, -0x8(%rbp)
jmp 0x7c88
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %edi, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
jmp 0x7c07
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_cat
static regex_node_t*
regex_cat(void) {
    regex_node_t* root = regex_closure();
    if (!root)
        { return (NULL_NODE); }

    while (!in_first(regex_spec->lex, T_REG_LOOK, T_REG_UNION, T_REG_RPAREN,
                                    T_REG_DOLLAR, T_CLOSE_REGEX, T_EOF, -1)) {
         regex_node_t* right_op = regex_closure();
        if (!right_op) {
            del_regex_node(root);
            return (NULL_NODE); 
        }
        root = new_regex_node(AST_CONCAT, root, right_op);
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x7d60
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7cc5
movq $0x0, -0x8(%rbp)
jmp 0x7d4f
jmp 0x7cc7
movq 0x1a0f2(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
movl $0xb, %esi
movl $0x4, %edx
movl $0x9, %ecx
movl $0x19, %r8d
movl $0x3, %r9d
movl $0x70, (%rsp)
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x3350
xorb $-0x1, %al
testb $0x1, %al
jne 0x7d0a
jmp 0x7d47
callq 0x7d60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7d2d
movq -0x10(%rbp), %rdi
callq 0xa380
movq $0x0, -0x8(%rbp)
jmp 0x7d4f
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
jmp 0x7cc7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_closure
static regex_node_t*
regex_closure(void) {
    regex_node_t* root = regex_tilde();
    if (!root)
        { return (NULL_NODE); }

    while (in_first(regex_spec->lex, T_REG_STAR, T_REG_PLUS,
                                            T_REG_QUES, T_REG_LBRACE, -1)) {
        int closure_kind = advance_token(regex_spec->lex);
        switch (closure_kind) {
            case T_REG_PLUS:
                if (root->kind_ast != AST_PLUS)
                    { root = new_regex_node(AST_PLUS, root); }
                break;
            case T_REG_QUES:
                if (root->kind_ast != AST_QUES)
                    { root = new_regex_node(AST_QUES, root); }
                break;
            case T_REG_STAR:
                if (root->kind_ast != AST_STAR)
                    { root = new_regex_node(AST_STAR, root); }
                break;
            case T_REG_LBRACE: root = finite_seq(root);
                break;
        }
        if (!root)
            { return (NULL_NODE); }
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x7e90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7d85
movq $0x0, -0x8(%rbp)
jmp 0x7e7b
jmp 0x7d87
movq 0x1a032(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
movl $0x5, %esi
movl $0x6, %edx
movl $0x7, %ecx
movl $0xf, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x3350
testb $0x1, %al
jne 0x7dbc
jmp 0x7e73
movq 0x19ffd(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xa, %eax
ja 0x7e5d
movq -0x20(%rbp), %rax
leaq 0x6f1e(%rip), %rcx      # 0xed08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0x7e10
movq -0x10(%rbp), %rsi
movl $0x4, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
jmp 0x7e5d
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x7e2f
movq -0x10(%rbp), %rsi
movl $0x2, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
jmp 0x7e5d
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
je 0x7e4e
movq -0x10(%rbp), %rsi
movl $0x3, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
jmp 0x7e5d
movq -0x10(%rbp), %rdi
callq 0x7f40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7e6e
movq $0x0, -0x8(%rbp)
jmp 0x7e7b
jmp 0x7d87
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_tilde
static regex_node_t*
regex_tilde(void) {
    size_t tilde = 0;

    while (peek_token(regex_spec->lex) == T_REG_TILDE) {
        advance_token(regex_spec->lex);
        ++tilde;
    }

    regex_node_t* root = regex_atom();
    if (!root)
        { return (NULL_NODE); }

    if (tilde) {
        root = new_regex_node(AST_TILDE, root);
        if (tilde > 1)
            { root = new_regex_node(AST_TILDE, root); }
    }

    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
movq 0x19f19(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x3300
cmpl $0xe, %eax
jne 0x7ed1
movq 0x19f05(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7ea0
callq 0x8150
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7eeb
movq $0x0, -0x8(%rbp)
jmp 0x7f2b
cmpq $0x0, -0x10(%rbp)
je 0x7f23
movq -0x18(%rbp), %rsi
movl $0x6, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x10(%rbp)
jbe 0x7f21
movq -0x18(%rbp), %rsi
movl $0x6, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x18(%rbp)
jmp 0x7f23
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_string
static regex_node_t*
regex_string(void) {
    advance_token(regex_spec->lex);

    regex_node_t* root_concat = NULL;
    bool empty_str = true;

    while (!in_first(regex_spec->lex, T_REG_QUOTE, T_EOF, -1)) {
        int kind_char;
        if ((kind_char = advance_token(regex_spec->lex)) == T_ERROR)
            { break; }
        regex_node_t* symbol = new_regex_node(AST_SYMBOL,
                                            regex_char(kind_char), true);
        if (!root_concat)
            { root_concat = symbol; }
        else
            { root_concat = new_regex_node(AST_CONCAT, root_concat, symbol); }
        empty_str = false;
    }
    if (empty_str)
        { root_concat = new_regex_node(AST_EPSILON); }
    if (!root_concat)
         { return (NULL_NODE); }
    if (advance_token(regex_spec->lex) != T_REG_QUOTE) {
        del_regex_node(root_concat);
        errorf(CURRENT_LINE(regex_spec->lex),
                                "Missing a close quote ('\"') in string.");
        return (NULL_NODE);
    }
    return (root_concat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x198c1(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
movq $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq 0x198a6(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
movl $0xc, %esi
movl $0x70, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x3350
xorb $-0x1, %al
testb $0x1, %al
jne 0x853b
jmp 0x85a5
movq 0x1987e(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
movl %eax, -0x18(%rbp)
cmpl $0x6f, %eax
jne 0x8554
jmp 0x85a5
movl -0x18(%rbp), %edi
callq 0x88b0
movl %eax, %esi
movl $0xa, %edi
movl $0x1, %edx
movb $0x0, %al
callq 0x9c00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8584
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x859c
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
jmp 0x8513
testb $0x1, -0x11(%rbp)
je 0x85bb
movl $0xb, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x85cc
movq $0x0, -0x8(%rbp)
jmp 0x8618
movq 0x197ed(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
cmpq $0xc, %rax
je 0x8610
movq -0x10(%rbp), %rdi
callq 0xa380
movq 0x197cf(%rip), %rax     # 0x21dc0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x6973(%rip), %rsi      # 0xef72
movb $0x0, %al
callq 0x4230
movq $0x0, -0x8(%rbp)
jmp 0x8618
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_loneccl
static regex_node_t*
regex_loneccl(void) {
    advance_token(regex_spec->lex);
    bool negate = (peek_token(regex_spec->lex) == T_REG_CARET);

    if (negate)
        { advance_token(regex_spec->lex); }

    bool cce_lower = false;
    bool cce_upper = false;

    bitset_t* range = regex_ccl(&cce_lower, &cce_upper);
    if (!range)
        { return (NULL_NODE); }
    else if (advance_token(regex_spec->lex) != T_REG_RBRACK) {
        del_bitset(range);
        errorf(CURRENT_LINE(regex_spec->lex),
                                "Missing a close bracket (']') in ccl.");
        return (NULL_NODE);
    }

    if (is_empty_bitset(range) && !negate) {
        del_bitset(range);
        return (new_regex_node(AST_EPSILON));
    }
    else if (negate)
        { COMPL_BITSET(range); }

    return (new_regex_node(AST_CLASS, range,
            ((cce_lower) ? CURRENT_LINE(regex_spec->lex) : -1),
            ((cce_upper) ? CURRENT_LINE(regex_spec->lex) : -1)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x19351(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
movq 0x19342(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x3300
cmpl $0x18, %eax
sete %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x8aa6
movq 0x19322(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
movb $0x0, -0xa(%rbp)
movb $0x0, -0xb(%rbp)
leaq -0xa(%rbp), %rdi
leaq -0xb(%rbp), %rsi
callq 0x8be0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8ad3
movq $0x0, -0x8(%rbp)
jmp 0x8bd5
movq 0x192e6(%rip), %rax     # 0x21dc0
movq (%rax), %rdi
callq 0x2cc0
cmpq $0x17, %rax
je 0x8b1a
movq -0x18(%rbp), %rdi
callq 0x1320
movq 0x192c8(%rip), %rax     # 0x21dc0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x63e7(%rip), %rsi      # 0xeeed
movb $0x0, %al
callq 0x4230
movq $0x0, -0x8(%rbp)
jmp 0x8bd5
jmp 0x8b1c
movq -0x18(%rbp), %rdi
callq 0x16c0
testb $0x1, %al
jne 0x8b2b
jmp 0x8b4f
testb $0x1, -0x9(%rbp)
jne 0x8b4f
movq -0x18(%rbp), %rdi
callq 0x1320
movl $0xb, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x8(%rbp)
jmp 0x8bd5
testb $0x1, -0x9(%rbp)
je 0x8b67
movq -0x18(%rbp), %rsi
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x18b0
jmp 0x8b69
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0xa(%rbp)
je 0x8b89
movq 0x19242(%rip), %rax     # 0x21dc0
movq (%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x8b93
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x8b93
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
testb $0x1, -0xb(%rbp)
je 0x8bb1
movq 0x1921a(%rip), %rax     # 0x21dc0
movq (%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x8bbb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x8bbb
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %ecx
movl $0xc, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: hex_to_dec
static int
hex_to_dec(int c) {
    if (isdigit(c)) { return (c - '0'); }
    else if (islower(c)) { return ((c - 'a') + 10); }
    else if (isupper(c)) { return ((c - 'A') + 10); }
    return (ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x11a0
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x9410
movl -0x8(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x946b
callq 0x11a0
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x9438
movl -0x8(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x946b
callq 0x11a0
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x9460
movl -0x8(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x946b
jmp 0x9462
jmp 0x9464
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/dfa_minimization.c
// Function: input_to_state
static size_t
input_to_state(trans_list_t const* list, size_t input) {
    while (list) {
        if ((size_t)list->input == input)
            { return (list->state); }
        list = list->next;
    }
    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9a7c
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x9a6f
movq -0x10(%rbp), %rax
movslq 0xc(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9a84
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9a4c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)