LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x5c5e
testq %rax, %rax
je 0x6061
movq %rax, %rbx
movq 0x18(%r14), %rdi
callq 0x5c5e
testq %rax, %rax
je 0x604c
movq %rax, %r14
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x562e
movq %rax, %r15
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
xorl %eax, %eax
callq 0x562e
testq %r15, %r15
setne %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
je 0x6051
movq 0x28(%rbx), %rcx
cmpl $-0x4, 0x10(%rcx)
movl $0x101, %edx            # imm = 0x101
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
cmovel %edx, %esi
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
movl %esi, 0x10(%rcx)
movq %rax, 0x18(%rcx)
movq 0x28(%r14), %rcx
cmpl $-0x4, 0x10(%rcx)
cmovel %edx, %edi
movl %edi, 0x10(%rcx)
movq %rax, 0x18(%rcx)
movl $0x3, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5a70
movq %rbx, %rdi
jmp 0x605c
movq %rbx, %rdi
callq 0x5603
movq %r14, %rdi
callq 0x5603
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x5c5e
testq %rax, %rax
je 0x60f2
movq %rax, %rbx
movq 0x17e1c(%rip), %rax     # 0x1deb0
movq 0x10(%rax), %r12
movq 0x18(%r14), %rdi
callq 0x5c5e
testq %rax, %rax
je 0x60ea
movq %rax, %r15
cmpl $0x5, (%r14)
jne 0x60d2
movq 0x17dfa(%rip), %rcx     # 0x1deb0
movq 0x10(%rcx), %rax
cmpq %rax, %r12
jae 0x60d2
movq (%rcx), %rcx
movq (%rcx,%r12,8), %rdx
movb $0x1, 0xe(%rdx)
incq %r12
cmpq %r12, %rax
jne 0x60c2
movq 0x28(%rbx), %rax
cmpl $-0x1, 0x10(%rax)
je 0x60fd
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl $0x20, %ecx
jmp 0x6102
movq %rbx, %rdi
callq 0x5603
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %ecx
movq %r15, (%rax,%rcx)
cmpl $0x5, (%r14)
jne 0x6114
movq %r15, %rdi
callq 0x6194
movq 0x28(%r15), %rcx
movl $0x2, %edi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5a70
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
xorl %eax, %eax
callq 0x562e
testq %rax, %rax
je 0x618d
movq %rax, %rbx
movq %r14, %rdi
callq 0x24f8
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x562e
testq %rax, %rax
je 0x6185
movl $0x6, %edi
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5a70
movq %rbx, %rdi
callq 0x55cf
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl 0x8(%rbx), %eax
cmpl $0x1, %eax
jne 0x61b9
movq 0x10(%rbx), %rbx
andb %r15b, %r12b
movb $0x1, %r15b
jmp 0x61a5
addl $-0x2, %eax
cmpl $0x4, %eax
ja 0x61d9
leaq 0x5734(%rip), %rcx      # 0xb8fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rbx), %rax
movb $0x1, 0xd(%rax)
movb $0x1, %al
jmp 0x6221
movq 0x20(%rbx), %rdi
callq 0x6194
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x6194
andb %r14b, %al
movzbl %al, %ecx
movzbl %r12b, %eax
testb $0x1, %r15b
cmovel %ecx, %eax
jmp 0x622f
movq 0x18(%rbx), %rdi
callq 0x6194
testb %al, %al
jne 0x61d9
movq 0x20(%rbx), %rdi
callq 0x6194
testb %al, %al
jne 0x61d9
xorl %eax, %eax
movzbl %r12b, %ecx
movzbl %al, %eax
testb $0x1, %r15b
cmovnel %ecx, %eax
andb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x17c70(%rip)     # 0x1dec0
movq %rsi, 0x17c71(%rip)     # 0x1dec8
movq (%rdi), %rdi
callq 0x39b4
cmpl $0x18, %eax
jne 0x6270
movq (%r14), %rdi
callq 0x331a
movb $0x1, 0x19(%rbx)
callq 0x6353
testq %rax, %rax
je 0x62cc
movq %rax, %rbx
movq 0x17c3c(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x39b4
cmpl $0xb, %eax
jne 0x62d9
movq 0x17c28(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x331a
callq 0x6353
testq %rax, %rax
je 0x62d0
movl $0x5, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7948
movq %rax, %rbx
movq 0x17c02(%rip), %rax     # 0x1dec8
movb $0x1, 0x1a(%rax)
jmp 0x62d9
xorl %ebx, %ebx
jmp 0x62d9
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x7cad
testq %rbx, %rbx
je 0x6318
movq (%r14), %rdi
callq 0x39b4
cmpl $0x19, %eax
jne 0x631a
cmpl $0x5, (%rbx)
jne 0x6322
movq %rbx, %rdi
callq 0x7cad
movq 0x17bc1(%rip), %rax     # 0x1dec0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x5703(%rip), %rsi      # 0xba10
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4060
jmp 0x631a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rdi
callq 0x331a
movl $0xa, %edi
movl $0xa, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x7948
movl $0x5, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x63ea
testq %rax, %rax
je 0x63da
movq %rax, %rbx
leaq 0x56be(%rip), %r14      # 0xba2f
movq 0x17b48(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x39b4
cmpl $0x4, %eax
jne 0x63dc
movq 0x17b34(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x331a
callq 0x63ea
movq %rax, %r15
testq %rax, %rax
je 0x63b5
xorl %edi, %edi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7948
movq %rax, %rbx
jmp 0x63d5
movq %rbx, %rdi
callq 0x7cad
movq 0x17afc(%rip), %rax     # 0x1dec0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4060
testq %r15, %r15
jne 0x6371
xorl %ebx, %ebx
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/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
pushq %r14
pushq %rbx
callq 0x6471
testq %rax, %rax
je 0x6467
movq %rax, %rbx
movq 0x17abb(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
movl $0xb, %esi
movl $0x4, %edx
movl $0x9, %ecx
movl $0x19, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $-0x1
pushq $0x70
callq 0x39e3
addq $0x10, %rsp
testb %al, %al
jne 0x6469
callq 0x6471
movq %rax, %r14
testq %rax, %rax
je 0x645a
movl $0x1, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7948
movq %rax, %rbx
jmp 0x6462
movq %rbx, %rdi
callq 0x7cad
testq %r14, %r14
jne 0x63fe
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_char
static int
regex_char(int kind) {
    if (kind == T_REG_CHAR) {
        size_t input_c = (*C_LEXEME(regex_spec->lex));
        if (input_c == '\\') {
            input_c = C_LEXEME(regex_spec->lex)[1];

            switch (input_c) {
                case 'n': input_c = '\n'; break;
                case 'a': input_c = '\a'; break;
                case 'b': input_c = '\b'; break;
                case 'f': input_c = '\f'; break;
                case 'r': input_c = '\r'; break;
                case 't': input_c = '\t'; break;
                case 'v': input_c = '\v'; break;
                default:  break;
            }
        }
        return (input_c);
    }
    else if (kind == T_OCT_NUM) {
        char const* first_digit = C_LEXEME(regex_spec->lex) + 1;
        size_t oct_num = 0;
        while (*first_digit) {
            oct_num = (*first_digit - '0') + (oct_num * 8);
            ++first_digit;
        }
        return (oct_num);
    }
    else if (kind == T_HEX_NUM) {
        char const* first_digit = C_LEXEME(regex_spec->lex) + 2;
        size_t hex_num = 0;
        while (*first_digit) {
            hex_num = hex_to_dec(*first_digit) + (hex_num * 16);
            ++first_digit;
        }
        return (hex_num);
    }
    return (ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1d, %edi
je 0x6dd2
cmpl $0x1e, %edi
je 0x6d5f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1f, %edi
jne 0x6e09
movq 0x171ad(%rip), %rax     # 0x1dec0
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movsbl (%rcx), %eax
cmpl $0x5c, %eax
jne 0x6e09
movzbl 0x1(%rcx), %ecx
movsbl %cl, %eax
cmpl $0x6d, %ecx
jle 0x6e0e
addl $-0x6e, %ecx
cmpl $0x8, %ecx
ja 0x6e09
leaq 0x4c40(%rip), %rdx      # 0xb98c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0xa, %eax
jmp 0x6e09
movq 0x1715a(%rip), %rax     # 0x1dec0
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rbx
movb 0x2(%rbx), %r14b
testb %r14b, %r14b
je 0x6e07
callq 0x2200
movq (%rax), %rcx
addq $0x3, %rbx
xorl %eax, %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movsbl %r14b, %esi
movsbq %sil, %rdi
movzwl (%rcx,%rdi,2), %edi
btl $0xb, %edi
jb 0x6db4
btl $0x9, %edi
jb 0x6db9
addl $-0x37, %esi
btl $0x8, %edi
cmovael %edx, %esi
jmp 0x6dbc
addl $-0x30, %esi
jmp 0x6dbc
addl $-0x57, %esi
movl %esi, %esi
shlq $0x4, %rax
addq %rsi, %rax
movb (%rbx), %r14b
incq %rbx
testb %r14b, %r14b
jne 0x6d90
jmp 0x6e09
movq 0x170e7(%rip), %rax     # 0x1dec0
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movb 0x1(%rcx), %dl
testb %dl, %dl
je 0x6e07
addq $0x2, %rcx
xorl %eax, %eax
movsbq %dl, %rdx
leaq (%rdx,%rax,8), %rax
addq $-0x30, %rax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x6df0
jmp 0x6e09
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x61, %ecx
je 0x6e39
cmpl $0x62, %ecx
je 0x6e40
cmpl $0x66, %ecx
jne 0x6e09
movl $0xc, %eax
jmp 0x6e09
movl $0x9, %eax
jmp 0x6e09
movl $0xb, %eax
jmp 0x6e09
movl $0xd, %eax
jmp 0x6e09
movl $0x7, %eax
jmp 0x6e09
movl $0x8, %eax
jmp 0x6e09
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_n_cce
static bitset_t*
regex_n_cce(int kind_cce) {
    switch (kind_cce) {
        case T_N_CCE_ALNUM:
            return (COMPL_BITSET(regex_cce(T_CCE_ALNUM)));
        case T_N_CCE_ALPHA:
            return (COMPL_BITSET(regex_cce(T_CCE_ALPHA)));
        case T_N_CCE_BLANK:
            return (COMPL_BITSET(regex_cce(T_CCE_BLANK)));
        case T_N_CCE_CNTRL:
            return (COMPL_BITSET(regex_cce(T_CCE_CNTRL)));
        case T_N_CCE_DIGIT:
            return (COMPL_BITSET(regex_cce(T_CCE_DIGIT)));
        case T_N_CCE_GRAPH:
            return (COMPL_BITSET(regex_cce(T_CCE_GRAPH)));
        case T_N_CCE_LOWER:
            return (COMPL_BITSET(regex_cce(T_CCE_LOWER)));
        case T_N_CCE_PRINT:
            return (COMPL_BITSET(regex_cce(T_CCE_PRINT)));
        case T_N_CCE_PUNCT:
            return (COMPL_BITSET(regex_cce(T_CCE_PUNCT)));
        case T_N_CCE_SPACE:
            return (COMPL_BITSET(regex_cce(T_CCE_SPACE)));
        case T_N_CCE_UPPER:
            return (COMPL_BITSET(regex_cce(T_CCE_UPPER)));
        case T_N_CCE_XDIGIT:
            return (COMPL_BITSET(regex_cce(T_CCE_XDIGIT)));
        }
    return (NULL_BITSET);
}

// Assembly:
addl $-0x58, %edi
cmpl $0xb, %edi
ja 0x7443
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x4644(%rip), %rax      # 0xb9e0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x4b, %edi
jmp 0x7426
movl $0x56, %edi
jmp 0x7426
movl $0x4f, %edi
jmp 0x7426
movl $0x54, %edi
jmp 0x7426
movl $0x4d, %edi
jmp 0x7426
callq 0x247c
movq %rax, %rbx
movl $0x30, %esi
movl $0x3a, %edx
jmp 0x7417
movl $0x52, %edi
jmp 0x7426
movl $0x4c, %edi
jmp 0x7426
callq 0x247c
movq %rax, %rbx
movl $0x61, %esi
movl $0x7b, %edx
jmp 0x7417
movl $0x51, %edi
jmp 0x7426
callq 0x247c
movq %rax, %rbx
movl $0x41, %esi
movl $0x5b, %edx
movq %rax, %rdi
callq 0x26ca
jmp 0x742e
movl $0x53, %edi
callq 0x711f
movq %rax, %rbx
movl $0x3, %edi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2809
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: del_regex_node
void
del_regex_node(regex_node_t* node) {
    if (node) {
        if (node->kind_ast == AST_CLASS) 
            { del_bitset(node->class); }
        else if (node->kind_ast == AST_BOUND_NAME)
             { FREE(node->bound_name); }
        else if (CHILD_NODE(node->kind_ast)) {
            del_regex_node(node->left);
            del_regex_node(node->right);
        }
        FREE(node);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x7ce2
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x8, %eax
jae 0x7ce3
movq 0x10(%rbx), %rdi
callq 0x7cad
movq 0x18(%rbx), %rdi
callq 0x7cad
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
retq
je 0x7cf5
cmpl $0xc, %eax
jne 0x7cd4
movq 0x8(%rbx), %rdi
callq 0x24ca
jmp 0x7cd4
movq 0x8(%rbx), %rdi
callq 0x2040
jmp 0x7cd4
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: cpy_regex_node
regex_node_t*
cpy_regex_node(regex_node_t* root) {
    if (root) {
        if (root->kind_ast == AST_SYMBOL) {
            return (new_regex_node(AST_SYMBOL,
                                            root->symbol, root->in_string));
        }
        else if (root->kind_ast == AST_EPSILON)
            { return (new_regex_node(AST_EPSILON)); }
        else if (root->kind_ast == AST_CLASS)  {
            return (new_regex_node(AST_CLASS, dup_bitset(root->class),
                                root->cce_lower, root->cce_upper));
        }
        else if (root->kind_ast == AST_DOT)
            { return (new_regex_node(AST_DOT, root->is_dotall)); }
        else if (root->kind_ast == AST_BOUND_NAME) {
            return (new_regex_node(AST_BOUND_NAME,
                                                strdup(root->bound_name)));
        }
        else if (root->kind_ast == AST_OPTION) {
            return (new_regex_node(AST_OPTION, root->igcase, root->dotall,
                                    root->skipws, root->reverse, root->left));
        }
        else if (CHILD_NODE(root->kind_ast)) { 
            regex_node_t* left = cpy_regex_node(root->left);
            regex_node_t* right = cpy_regex_node(root->right);

            int new_kind = root->kind_ast;
            if (new_kind == AST_LOOK)
                { new_kind = AST_CONCAT; }

            return (new_regex_node(root->kind_ast, left, right));
        }
    }
    return (NULL_NODE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7d4f
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0xc, %rax
ja 0x7d4f
leaq 0x3f8a(%rip), %rcx      # 0xbca8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x7d00
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x7d00
movl (%rbx), %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0xb, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
movq 0x8(%rbx), %rdi
callq 0x24f8
movl 0x10(%rbx), %edx
movl 0x14(%rbx), %ecx
movl $0xc, %edi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
movzbl 0x8(%rbx), %esi
movl $0x9, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
movzbl 0x8(%rbx), %esi
movzbl 0x9(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movzbl 0xb(%rbx), %r8d
movq 0x10(%rbx), %r9
movl $0x7, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
movl 0x8(%rbx), %esi
movzbl 0xc(%rbx), %edx
movl $0xa, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
movq 0x8(%rbx), %rdi
callq 0x21f0
movl $0x8, %edi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x7948
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: cpy_concat_regex_node
regex_node_t*
cpy_concat_regex_node(regex_node_t* root, size_t size) {
    if (!size)
        { return (new_regex_node(AST_EPSILON)); }
    regex_node_t* atom = root;
    for (size_t i = 1; i < size; ++i)
        { root = new_regex_node(AST_CONCAT, root, cpy_regex_node(atom)); }
    return (root);
}

// Assembly:
testq %rsi, %rsi
je 0x7e14
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1, %rsi
jne 0x7e20
movq %rbx, %r15
jmp 0x7e48
movl $0xb, %edi
xorl %eax, %eax
jmp 0x7948
decq %r14
movq %rbx, %r15
movq %rbx, %rdi
callq 0x7d00
movl $0x1, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7948
movq %rax, %r15
decq %r14
jne 0x7e26
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: search_kind_regex_node
void
search_kind_regex_node(regex_node_t* root, size_t kind, vector_t* dst_vect) {
    if (!root)
        { return; }
    else if (root->kind_ast == kind)
        { PUSH_BACK_VECTOR(dst_vect, root); }
    else if (CHILD_NODE(root->kind_ast)) {
        search_kind_regex_node(root->left, kind, dst_vect);
        search_kind_regex_node(root->right, kind, dst_vect);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %r14, %r14
je 0x7e90
movl (%r14), %eax
cmpq %r15, %rax
je 0x7e9b
cmpl $0x7, %eax
ja 0x7e90
movq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x7e56
movq 0x18(%r14), %r14
jmp 0x7e69
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2c31
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: replace_bound_name_node
void
replace_bound_name_node(regex_node_t* root, lexical_spec_t* spec) {
    if (!root)
        { return; }
    else if (CHILD_NODE(root->kind_ast)) {
        if (root->left->kind_ast == AST_BOUND_NAME) {
            regex_node_t* target_node = ((spec_entry_t*)
                                        AT_VECTOR(spec->entry_vect,
                                        root->left->index_token))->regex_ast;

            del_regex_node(root->left);
            root->left = cpy_regex_node(target_node);
        }

        /* Check for '*', '?', '+', '~' operator */
        if (root->right && root->right->kind_ast == AST_BOUND_NAME) {
            regex_node_t* target_node = ((spec_entry_t*)
                                        AT_VECTOR(spec->entry_vect,
                                        root->right->index_token))->regex_ast;

            del_regex_node(root->right);
            root->right = cpy_regex_node(target_node);
        }

        replace_bound_name_node(root->left, spec);
        replace_bound_name_node(root->right, spec);
    }
    else if (root->kind_ast == AST_BOUND_NAME) {
        regex_node_t* target_node = cpy_regex_node(((spec_entry_t*)
                    AT_VECTOR(spec->entry_vect, root->index_token))->regex_ast);

        FREE(root->bound_name);
        memcpy(root, target_node, sizeof(*root));

        FREE(target_node);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x7f8b
cmpl $0x8, (%rbx)
jae 0x7f43
movq 0x10(%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x7eff
movq 0x8(%r14), %rax
movq (%rax), %rax
movq 0x10(%rdi), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %r15
callq 0x7cad
movq %r15, %rdi
callq 0x7d00
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x7f31
cmpl $0x8, (%rdi)
jne 0x7f31
movq 0x8(%r14), %rax
movq (%rax), %rax
movq 0x10(%rdi), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %r15
callq 0x7cad
movq %r15, %rdi
callq 0x7d00
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x7eb4
movq 0x18(%rbx), %rbx
jmp 0x7ec4
jne 0x7f8b
movq 0x8(%r14), %rax
movq (%rax), %rax
movq 0x10(%rbx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
callq 0x7d00
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x2040
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2040
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: set_dotall
regex_node_t*
set_dotall(regex_node_t* root) {
    if (!root)
        { return (NULL_NODE); }
    else if (root->kind_ast == AST_DOT)
        { root->is_dotall = true; }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x80a6
movq %rdi, %rax
cmpl $0x9, (%rdi)
jne 0x80a8
movb $0x1, 0x8(%rax)
jmp 0x80a8
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: set_skipws
regex_node_t*
set_skipws(regex_node_t* root) {
    if (!root)
        { return (NULL_NODE); }
    else if ((root->kind_ast == AST_SYMBOL)
                && IS_SKIPWS(root->symbol) && !(root->in_string))
        { root->kind_ast = AST_EPSILON; }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x80e2
movq %rdi, %rax
cmpl $0xa, (%rdi)
jne 0x80e4
movl 0x8(%rax), %ecx
cmpq $0x20, %rcx
ja 0x80e4
movabsq $0x100000600, %rdx      # imm = 0x100000600
btq %rcx, %rdx
jae 0x80e4
cmpb $0x0, 0xc(%rax)
jne 0x80e4
movl $0xb, (%rax)
jmp 0x80e4
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: set_igcase
regex_node_t*
set_igcase(regex_node_t* root) {
    if (!root)
        { return (NULL_NODE); }
    else if ((root->kind_ast == AST_SYMBOL) || (root->kind_ast == AST_CLASS)) {
        if ((root->kind_ast == AST_SYMBOL) && isalpha(root->symbol)) {
            size_t back_symbol = root->symbol;
            root->kind_ast = AST_CLASS;

            root->class = new_bitset();
            root->cce_lower = root->cce_upper = -1;

            ADD_BITSET(root->class, back_symbol);
        }

        if (root->kind_ast == AST_CLASS) {
            if (root->cce_lower != -1) {
                warnf(root->cce_lower,
                                "[:lower:] is use in ignore case option.");
            } 
            if (root->cce_upper != -1) {
                warnf(root->cce_upper,
                                "[:upper:] is use in ignore case option.");
            } 

            int i;
            while ((i = IT_NEXT(root->class)) != IT_NULL) {
                if (isalpha(i)) {
                    size_t target = (islower(i) ? toupper(i) : tolower(i));
                    ADD_BITSET(root->class, target);    
                }   
            } 
            IT_RESET(root->class);
        }
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8154
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0xc, %eax
je 0x8166
cmpl $0xa, %eax
jne 0x8234
callq 0x2200
movq (%rax), %rax
movslq 0x8(%rbx), %r14
testb $0x4, 0x1(%rax,%r14,2)
je 0x8166
movl $0xc, (%rbx)
callq 0x247c
movq %rax, 0x8(%rbx)
movq $-0x1, 0x10(%rbx)
movl 0x4(%rax), %ecx
cmpq %rcx, %r14
jae 0x815b
movl $0x1, %edx
movl %r14d, %ecx
shlq %cl, %rdx
movq 0x8(%rax), %rax
shrq $0x6, %r14
orq %rdx, (%rax,%r14,8)
jmp 0x8166
xorl %ebx, %ebx
jmp 0x8234
movq %rax, %rdi
movq %r14, %rsi
callq 0x25a8
cmpl $0xc, (%rbx)
jne 0x8234
movslq 0x10(%rbx), %rdi
cmpq $-0x1, %rdi
je 0x8187
leaq 0x3b8c(%rip), %rsi      # 0xbd0c
xorl %eax, %eax
callq 0x22f9
movslq 0x14(%rbx), %rdi
cmpq $-0x1, %rdi
je 0x819f
leaq 0x3b9c(%rip), %rsi      # 0xbd34
xorl %eax, %eax
callq 0x22f9
movq 0x8(%rbx), %rdi
callq 0x292b
cmpl $-0x1, %eax
je 0x821b
movl %eax, %r15d
callq 0x2200
movq %rax, %r14
movq (%r14), %rax
movslq %r15d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xa, %eax
jae 0x820a
movl %r15d, %edi
btl $0x9, %eax
jb 0x81d8
callq 0x2160
jmp 0x81dd
callq 0x2070
movslq %eax, %rcx
movq 0x8(%rbx), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rcx
jae 0x8202
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x820a
movq %rcx, %rsi
callq 0x25a8
movq 0x8(%rbx), %rdi
callq 0x292b
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0x81b8
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x8234
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x8231
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%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/fgfl/src/regex_node.c
// Function: set_option_ast
regex_node_t*
set_option_ast(regex_node_t* root, regex_node_t* (*opt_ptr)(regex_node_t*)) {
    if (!root)
        { return (NULL_NODE); }
    else if (CHILD_NODE(root->kind_ast)) {
        if (CHILD_NODE(root->left->kind_ast))
            { root->left = set_option_ast(root->left, opt_ptr); }
        else
            { root->left = (*opt_ptr)(root->left); }

        if (root->right && CHILD_NODE(root->right->kind_ast))
            { root->right = set_option_ast(root->right, opt_ptr); }
        else
            { root->right = (*opt_ptr)(root->right); }
        return (root);
    }
    else
        { return ((*opt_ptr)(root)); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8269
movq %rdi, %rbx
cmpl $0x7, (%rdi)
ja 0x826d
movq 0x10(%rbx), %rdi
cmpl $0x7, (%rdi)
ja 0x8276
movq %rsi, %r14
callq 0x8242
jmp 0x827b
xorl %ebx, %ebx
jmp 0x829e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *%rsi
movq %rsi, %r14
callq *%rsi
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8297
cmpl $0x7, (%rdi)
ja 0x8297
movq %r14, %rsi
callq 0x8242
jmp 0x829a
callq *%r14
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/regex_node.c
// Function: reverse_regex_concat
regex_node_t*
reverse_regex_concat(regex_node_t* root) {
    if (!root)
        { return (NULL_NODE); }

    switch (root->kind_ast) {
        case AST_CONCAT: ;
            regex_node_t* left  = reverse_regex_concat(root->left);
            regex_node_t* right = reverse_regex_concat(root->right);

            if (root->left->kind_ast != AST_CONCAT) {
                root->left  = right;
                root->right = left;
            }
            else {
                root->right = root->left->right;
                root->left->right = root->left->left;
                root->left->left = right;
            }

            break;

        case AST_UNION:
            reverse_regex_concat(root->left);
            reverse_regex_concat(root->right);

            break;

        case AST_QUES:
        case AST_STAR:
        case AST_PLUS:
        case AST_TILDE:
        case AST_OPTION:
            reverse_regex_concat(root->left);
            break;
    
        default:
            break;
    }

    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
movl $0xdc, %r14d
testq %rbx, %rbx
je 0x82fe
movl (%rbx), %eax
cmpl $0x7, %eax
ja 0x8300
btl %eax, %r14d
jae 0x82e0
testb $0x1, %r12b
cmoveq %rbx, %r15
movq 0x10(%rbx), %rbx
movb $0x1, %r12b
jmp 0x82bd
testl %eax, %eax
jne 0x8314
movq 0x10(%rbx), %rdi
callq 0x82a6
testb $0x1, %r12b
cmoveq %rbx, %r15
movq 0x18(%rbx), %rbx
movb $0x1, %r12b
jmp 0x82bd
xorl %ebx, %ebx
testb $0x1, %r12b
cmovneq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %eax
jne 0x8300
movq 0x10(%rbx), %rdi
callq 0x82a6
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x82a6
movq 0x10(%rbx), %rcx
cmpl $0x1, (%rcx)
jne 0x8351
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq 0x10(%rcx), %rdx
movq %rdx, 0x18(%rcx)
movq 0x10(%rbx), %rcx
movq %rax, 0x10(%rcx)
jmp 0x8300
movq %rax, 0x10(%rbx)
movq %r14, 0x18(%rbx)
jmp 0x8300
nop
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/preprocess_regex.c
// Function: topological_sort
vector_t*
topological_sort(lexical_spec_t* spec) {
    vector_t* stack_order = new_vector();
    bitset_t* seen_reg = new_bitset();

    int exit_st = DONE;
    for (size_t i = 0; i < SIZE_VECTOR(spec->entry_vect); ++i) {
        spec_entry_t* crt_entry = (spec_entry_t*)AT_VECTOR(spec->entry_vect, i);
        if (!((crt_entry->kind == T_TERMINAL) && (!crt_entry->fragment)))
            { continue; }
        else if (IS_PRESENT(seen_reg, GET_INDEX(crt_entry)))
            { continue; }

        if (recur_node_topsort(spec, crt_entry,
                                i, stack_order, seen_reg) == ERROR)
            { exit_st = ERROR; }
    }

    if (exit_st == ERROR) {
        del_vector(stack_order);
        stack_order = NULL_VECT;
    }
    del_bitset(seen_reg);

    return (stack_order);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x2b3c
movq %rax, %rbx
callq 0x247c
movq %rax, %r14
movq 0x8(%r15), %rax
cmpq $0x0, 0x10(%rax)
je 0x83fc
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r12,8), %rsi
cmpl $0x2d, 0x8(%rsi)
jne 0x83df
cmpb $0x0, 0x18(%rsi)
jne 0x83df
testq %r14, %r14
je 0x83c7
movq (%rsi), %rax
movl 0x4(%r14), %ecx
cmpq %rcx, %rax
jae 0x83c7
movq 0x8(%r14), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jb 0x83df
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x8416
cmpl $-0x1, %eax
cmovel %eax, %r13d
incq %r12
movq 0x8(%r15), %rax
cmpq 0x10(%rax), %r12
jb 0x838e
cmpl $-0x1, %r13d
jne 0x83fc
movq %rbx, %rdi
callq 0x2bde
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x24ca
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/fgfl/src/preprocess_regex.c
// Function: expand_macro_regex
int
expand_macro_regex(lexical_spec_t* spec) {
    vector_t* stack_order;
    int exit_st = DONE;

    if ((stack_order = topological_sort(spec))) {
        for (size_t i = 0; i < SIZE_VECTOR(stack_order); ++i) {
            size_t j = (long)AT_VECTOR(stack_order, i);
            spec_entry_t* crt_entry = (spec_entry_t*)
                                            AT_VECTOR(spec->entry_vect, j);
            replace_bound_name_node(crt_entry->regex_ast, spec);
            remove_useless_epsilon(crt_entry->regex_ast);

#if 0
            if (IS_LOOK(crt_entry->regex_ast))
                { readjust_opt_ast(crt_entry->regex_ast->right); }
#endif
        }
    }
    else
        { exit_st = ERROR; }

    del_vector(stack_order);
    return (exit_st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x835c
movq %rax, %rbx
testq %rax, %rax
je 0x87a9
cmpq $0x0, 0x10(%rbx)
je 0x87b1
xorl %r14d, %r14d
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%r15), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r13
movq 0x20(%r13), %rdi
movq %r15, %rsi
callq 0x7eb4
movq 0x20(%r13), %rdi
callq 0x7f96
incq %r12
cmpq 0x10(%rbx), %r12
jb 0x8777
jmp 0x87b4
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x87b4
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2bde
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/dfa.c
// Function: new_dfa_state
dfa_state_t*
new_dfa_state(bitset_t* set_state, vector_t* states) {
    dfa_state_t* state = NEW(dfa_state_t, 1);

    if (!state)
        { return (NULL_DFA_STATE); }
    memset(state, 0, sizeof(*state));

    if (set_state) {
        state->set_state = set_state;
        state->hash_state = hash_bitset(set_state);
    }

    state->final_entry = NO_FINAL;
    state->final_anchor_entry = NO_FINAL;

    state->group = START_GROUP;

    state->index = SIZE_VECTOR(states);
    PUSH_BACK_VECTOR(states, state);

    return (state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x30, %edi
callq 0x3b4a
testq %rax, %rax
je 0x8838
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
testq %r15, %r15
je 0x8815
movq %r15, 0x8(%rbx)
movq %r15, %rdi
callq 0x29a4
movq %rax, 0x10(%rbx)
movq $-0x1, 0x24(%rbx)
movl $0x1, 0x2c(%rbx)
movq 0x10(%r14), %rsi
movq %rsi, (%rbx)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2c31
jmp 0x883a
xorl %ebx, %ebx
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/fgfl/src/dfa.c
// Function: del_dfa_state
void
del_dfa_state(dfa_state_t* dfa_state) {
    if (dfa_state) {
        del_bitset(dfa_state->set_state);
        del_trans_list(dfa_state->trans);
    }
    FREE(dfa_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x8868
movq 0x8(%rbx), %rdi
callq 0x24ca
movq 0x18(%rbx), %rdi
callq 0x3cb6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/dfa.c
// Function: epsilon_closure
static bitset_t*
epsilon_closure(bitset_t* set_state) {
    if (!set_state)
        { return (NULL_BITSET); }

    bitset_t* seen_state = new_bitset();
    bool change = false;

    do {
        int i;
        change = false;

        while ((i = IT_NEXT(set_state)) != IT_NULL) {
            if (!IS_PRESENT(seen_state, (size_t)i)) {
                nfa_state_t* crt_state = NFA_STATE_AT(i);
                if (!do_eclos) {
                    if (crt_state->eclos) {
                        if (!is_subset_bitset(set_state, crt_state->eclos))
                            { UNION_BITSET(set_state, crt_state->eclos); }
                        else
                            { continue; }
                    }
                    else {
                        nfa_state_edges(NFA_STATE_AT(i), EPSILON, set_state);
                        ADD_BITSET(seen_state, (size_t)i);
                    }
                    change = true;
                }
                else
                    { UNION_BITSET(set_state, crt_state->eclos); }
            }
        }
        IT_RESET(set_state);
    } while (change);

    del_bitset(seen_state);
    return (set_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8ddb
movq %rdi, %rbx
callq 0x247c
movq %rax, %r14
movq %rbx, %rdi
callq 0x292b
xorl %r13d, %r13d
cmpl $-0x1, %eax
je 0x8db0
movslq %eax, %r15
testq %r14, %r14
je 0x8d13
movl 0x4(%r14), %eax
cmpq %rax, %r15
jae 0x8d13
movq 0x8(%r14), %rax
movq %r15, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r15, %rax
jb 0x8da3
leaq 0x15196(%rip), %rax     # 0x1deb0
movq (%rax), %rax
movq (%rax), %rax
movq (%rax,%r15,8), %r12
movq 0x30(%r12), %rdx
cmpb $0x0, 0x151a0(%rip)     # 0x1ded0
je 0x8d3e
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2809
jmp 0x8da3
testq %rdx, %rdx
je 0x8d63
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x29ce
testb %al, %al
jne 0x8da3
movq 0x30(%r12), %rdx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2809
jmp 0x8da0
movq %r12, %rdi
movl $0x101, %esi            # imm = 0x101
movq %rbx, %rdx
callq 0x8def
movl 0x4(%r14), %eax
cmpq %rax, %r15
jae 0x8d95
movl $0x1, %eax
movl %r15d, %ecx
shlq %cl, %rax
movq 0x8(%r14), %rcx
shrq $0x6, %r15
orq %rax, (%rcx,%r15,8)
jmp 0x8da0
movq %r14, %rdi
movq %r15, %rsi
callq 0x25a8
movb $0x1, %r13b
movq %rbx, %rdi
callq 0x292b
jmp 0x8ce0
cmpb $0x0, 0x54(%rbx)
je 0x8dc0
movl 0x4(%rbx), %eax
decl %eax
movl %eax, 0x50(%rbx)
jmp 0x8dc7
movl $0x0, 0x50(%rbx)
testb $0x1, %r13b
jne 0x8cd5
movq %r14, %rdi
callq 0x24ca
jmp 0x8ddd
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/fgfl/src/dfa.c
// Function: nfa_state_edges
static void
nfa_state_edges(nfa_state_t* state, int symbol, bitset_t* result) {
    switch (state->symbol_edge) {
        case EDGE_AUTOMATA:
            nfa_automaton_edges(state->edge, symbol, result);
            if (state->edge2)
                { nfa_automaton_edges(state->edge2, symbol, result); }
            break;

        case EDGE_CLASS:
            if ((symbol != EPSILON)
                                && (IS_PRESENT(state->class, (size_t)symbol)))
                { ADD_BITSET(result, GET_INDEX(state->out_state)); }
            break;

        case EDGE_BOTH:
            nfa_automaton_edges(state->edge, symbol, result);
            if (symbol == EPSILON)
                { ADD_BITSET(result, GET_INDEX(state->out_state)); }
            break;       

        case NO_EDGE:
            break;

        default:
            if (symbol == state->symbol_edge)
                { ADD_BITSET(result, GET_INDEX(state->out_state)); }
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movl 0x10(%rdi), %ecx
leal 0x4(%rcx), %eax
cmpl $0x3, %eax
ja 0x8e96
leaq 0x3008(%rip), %rcx      # 0xbe20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%r14), %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x8ede
cmpl $0x101, %r15d           # imm = 0x101
je 0x8e9b
jmp 0x8ebe
cmpl $0x101, %r15d           # imm = 0x101
je 0x8ebe
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x8ebe
cmpl %r15d, 0x4(%rax)
jbe 0x8ebe
movq 0x8(%rax), %rax
movl %r15d, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %r15, %rax
jb 0x8e9b
jmp 0x8ebe
movq 0x20(%r14), %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x8ede
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x8ebe
movl %r15d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ede
cmpl %r15d, %ecx
jne 0x8ebe
movq 0x18(%r14), %rax
movq (%rax), %rcx
movl 0x4(%rbx), %eax
cmpq %rax, %rcx
jae 0x8ec9
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rbx), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rcx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25a8
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/dfa.c
// Function: nfa_automaton_edges
static void
nfa_automaton_edges(nfa_automaton_t* nfa_m, int symbol, bitset_t* result) {
    switch (nfa_m->kind_nfa) {
        case NFA_UNION:
        case NFA_CLASS:
            if (symbol == EPSILON)
                { ADD_BITSET(result, GET_INDEX(nfa_m->tail_state)); }
            break;

        case NFA_SYMBOL:
            if (nfa_m->out_symbol == symbol)
                { ADD_BITSET(result, GET_INDEX(nfa_m->head_state)); }
            break;

        case NFA_CLOSURE:
        case NFA_EPSILON:
            if (symbol == EPSILON)
                { ADD_BITSET(result, GET_INDEX(nfa_m->head_state)); }
            break;

        case NFA_CONCAT:
            nfa_automaton_edges(nfa_m->left, symbol, result);
            break;

        case NFA_MASTER: ;
                int i;
                while ((i = IT_NEXT(nfa_m->out_automata)) != IT_NULL) {
                    nfa_automaton_t* crt_nfa_m = AUTOMATON_AT(i);
                    nfa_automaton_edges(crt_nfa_m, symbol, result);
                }
                IT_RESET(nfa_m->out_automata);
                break;

        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movl 0x8(%r14), %eax
cmpl $0x2, %eax
jne 0x8f01
movq 0x18(%r14), %r14
jmp 0x8ef2
cmpl $0x6, %eax
ja 0x8fba
movl %eax, %eax
leaq 0x2f1d(%rip), %rcx      # 0xbe30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x101, %r15d           # imm = 0x101
je 0x8f97
jmp 0x8fba
cmpl $0x101, %r15d           # imm = 0x101
jne 0x8fba
movq 0x10(%r14), %rax
jmp 0x8f9b
movq 0x10(%r14), %rdi
callq 0x292b
cmpl $-0x1, %eax
je 0x8f78
leaq 0x14f66(%rip), %r12     # 0x1deb8
movq (%r12), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x8ede
movq 0x10(%r14), %rdi
callq 0x292b
cmpl $-0x1, %eax
jne 0x8f52
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x8fba
cmpb $0x0, 0x54(%rax)
je 0x8fd6
movl 0x4(%rax), %ecx
decl %ecx
movl %ecx, 0x50(%rax)
jmp 0x8fba
cmpl %r15d, 0x10(%r14)
jne 0x8fba
movq 0x28(%r14), %rax
movq (%rax), %rcx
movl 0x4(%rbx), %eax
cmpq %rax, %rcx
jae 0x8fc3
movl $0x1, %eax
shlq %cl, %rax
movq 0x8(%rbx), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rcx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25a8
movl $0x0, 0x50(%rax)
jmp 0x8fba
nop
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/gen_dfa.c
// Function: gen_state_enum
void
gen_state_enum(int filde, lexical_spec_t const* spec) {
    size_t size_state = SIZE_VECTOR(spec->state_vect);
    dprintf(filde, ENUM SP BEG_BLOCK NL);

    dprintf(filde, TAB DUMMY_STR COMMA NL);
    for (size_t i = 0; i < size_state; ++i) {
        spec_entry_t* crt_state = (spec_entry_t*)AT_VECTOR(spec->state_vect, i);
        ENUM_STATE_LINE(filde, crt_state->name);
    }
    dprintf(filde, END_BLOCK SEMI NL NL);

    spec_entry_t* init_state = AT_VECTOR(spec->state_vect, spec->start_state);

    dprintf(filde, DEFINE(%s, %zu) NL, MACRO_STATE, size_state + 1);
    dprintf(filde, DEFINE(%s, %s%s%s) NL NL,
                        "INIT_STATE", STATE_PREFIX, SEP, init_state->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %r14
leaq 0x2e4a(%rip), %rsi      # 0xbe4c
xorl %eax, %eax
callq 0x2110
leaq 0x2e44(%rip), %rsi      # 0xbe54
movl %ebx, %edi
xorl %eax, %eax
callq 0x2110
testq %r14, %r14
je 0x904b
leaq 0x2e3e(%rip), %r12      # 0xbe63
xorl %r13d, %r13d
movq 0x10(%r15), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %rax
movq 0x10(%rax), %rdx
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2110
incq %r13
cmpq %r13, %r14
jne 0x9028
leaq 0x3003(%rip), %rsi      # 0xc055
movl %ebx, %edi
xorl %eax, %eax
callq 0x2110
movq 0x10(%r15), %rax
movq (%rax), %rax
movslq 0x18(%r15), %rcx
movq (%rax,%rcx,8), %r15
incq %r14
leaq 0x2df7(%rip), %rsi      # 0xbe6b
leaq 0x2e00(%rip), %rdx      # 0xbe7b
movl %ebx, %edi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2110
movq 0x10(%r15), %r9
leaq 0x2df5(%rip), %rsi      # 0xbe87
leaq 0x2e02(%rip), %rdx      # 0xbe9b
leaq 0x1c47(%rip), %rcx      # 0xace7
leaq 0x1e9f(%rip), %r8       # 0xaf46
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110