LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/dfa_minimization.c
// Function: merge_dfa_state
static void
merge_dfa_state(lexical_spec_t* spec, vector_t* groups) {
    vector_t* new_states = new_vector();
    PUSH_BACK_VECTOR(new_states, NULL_DFA_STATE);

    for (size_t i = 0; i < SIZE_VECTOR(groups); ++i) {
        bitset_t* crt_group = (bitset_t*)AT_VECTOR(groups, i);
        dfa_state_t* crt_state = DFA_STATE_AT(spec, (size_t)IT_NEXT(crt_group));

        trans_list_t* list = crt_state->trans;
        while (list) {
            dfa_state_t* out_state = DFA_STATE_AT(spec, list->state);
            if (out_state)
                { list->state = out_state->group; }
            list = list->next;
        }

        dfa_state_t* new_state = new_dfa_state(NULL_BITSET, new_states);
        memcpy(new_state, crt_state, sizeof(*crt_state));

        new_state->set_state = NULL_BITSET;
        crt_state->trans = NULL_TRANS_LST;
    }

    foreach_vector(spec->states, &del_dfa_state);
    del_vector(spec->states);

    foreach_vector(groups, &del_bitset);
    del_vector(groups);

    spec->states = new_states;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1f00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2090
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x9bb0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1ac0
movl %eax, %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x9b64
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x9b57
movq -0x40(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x9b20
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xb790
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x30, %edx
callq 0x1100
movq -0x48(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9ac6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq 0x1c91(%rip), %rsi      # 0xb850
callq 0x23c0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2010
movq -0x10(%rbp), %rdi
leaq -0x88bc(%rip), %rsi     # 0x1320
callq 0x23c0
movq -0x10(%rbp), %rdi
callq 0x2010
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa436
movq -0x8(%rbp), %rax
cmpl $0xc, (%rax)
jne 0xa3af
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1320
jmp 0xa42d
movq -0x8(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xa3c7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
jmp 0xa42b
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
je 0xa40f
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
je 0xa40f
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xa40f
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0xa40f
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa40f
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
je 0xa40f
movq -0x8(%rbp), %rax
cmpl $0x7, (%rax)
je 0xa40f
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xa429
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa380
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa380
jmp 0xa42b
jmp 0xa42d
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa679
movl $0xb, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x8(%rbp)
jmp 0xa6d1
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa6c9
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa440
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movl $0x1, %edi
movb $0x0, %al
callq 0x9c00
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa689
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa700
jmp 0xa799
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpq -0x10(%rbp), %rax
jne 0xa723
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rdx
callq 0x2090
jmp 0xa797
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
je 0xa76b
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
je 0xa76b
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0xa76b
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0xa76b
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa76b
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
je 0xa76b
movq -0x8(%rbp), %rax
cmpl $0x7, (%rax)
je 0xa76b
movq -0x8(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xa795
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa6e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa6e0
jmp 0xa797
jmp 0xa799
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xab39
movq $0x0, -0x8(%rbp)
jmp 0xab54
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0xab4a
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0xab4c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xab79
movq $0x0, -0x8(%rbp)
jmp 0xabbe
movq -0x10(%rbp), %rax
cmpl $0xa, (%rax)
jne 0xabb4
movq -0x10(%rbp), %rax
cmpl $0x20, 0x8(%rax)
je 0xaba0
movq -0x10(%rbp), %rax
cmpl $0x9, 0x8(%rax)
je 0xaba0
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jne 0xabb4
movq -0x10(%rbp), %rax
testb $0x1, 0xc(%rax)
jne 0xabb4
movq -0x10(%rbp), %rax
movl $0xb, (%rax)
jmp 0xabb6
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb050
movq $0x0, -0x8(%rbp)
jmp 0xb14e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xb119
jmp 0xb063
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0xb092
jmp 0xb06d
movl -0x24(%rbp), %eax
addl $-0x2, %eax
subl $0x3, %eax
jb 0xb135
jmp 0xb07e
movl -0x24(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0xb135
jmp 0xb144
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb030
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb030
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
je 0xb0db
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xb117
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xb146
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb030
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb030
jmp 0xb146
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb030
jmp 0xb146
jmp 0xb146
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1f00
movq %rax, -0x10(%rbp)
callq 0x12b0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb267
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x2d, 0x8(%rax)
jne 0xb1ce
movq -0x30(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0xb1d3
jmp 0xb256
cmpq $0x0, -0x18(%rbp)
je 0xb1ed
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0xb1f5
xorl %eax, %eax
testb $0x1, %al
jne 0xb22b
jmp 0xb22d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0xb22d
jmp 0xb256
jmp 0xb22f
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0xb2a0
cmpl $-0x1, %eax
jne 0xb254
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0xb256
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb18d
cmpl $-0x1, -0x1c(%rbp)
jne 0xb27e
movq -0x10(%rbp), %rdi
callq 0x2010
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1320
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb160
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xb4f4
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb4f2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xa7a0
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xa950
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb48e
jmp 0xb4fb
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x2010
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x30, %edi
callq 0x38d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb7c2
movq $0x0, -0x8(%rbp)
jmp 0xb846
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10b0
cmpq $0x0, -0x10(%rbp)
je 0xb7f9
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1bb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2090
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb87d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1320
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3c00
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/dfa.c
// Function: build_dfa_table
void
build_dfa_table(nfa_state_t* master, lexical_spec_t* spec) {
    if (!master || !spec)
        { return; }

    precompute_epsilon_closure();
    if (spec->states) {
        foreach_vector(spec->states, &del_dfa_state);
        del_vector(spec->states);
    }

    spec->states = build_state_table(master);

    build_ahead_table(spec->states);
    build_final_table(spec->states);

//  minimizing_dfa(spec);
    spec->size_final = spec->size_final_anchor = 0;
    
    for (size_t i = 1; i < SIZE_VECTOR(spec->states); ++i) {
        dfa_state_t* crt_state =  DFA_STATE_AT(spec, i);
        if (!crt_state->is_final)
            { continue; }

        if (crt_state->final_entry != NO_FINAL)
            { ++(spec->size_final); }
        else
            { ++(spec->size_final_anchor); }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb8ae
cmpq $0x0, -0x10(%rbp)
jne 0xb8b3
jmp 0xb9a3
callq 0xb9b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xb8e4
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x82(%rip), %rsi       # 0xb850
callq 0x23c0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2010
movq -0x8(%rbp), %rdi
callq 0xbaa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xbc60
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xbd70
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb9a3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x22(%rax)
jne 0xb967
jmp 0xb995
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x24(%rax)
je 0xb983
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0xb993
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
jmp 0xb995
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb932
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/dfa.c
// Function: precompute_epsilon_closure
static void
precompute_epsilon_closure(void) {
    if (do_eclos)
        { return; }

    for (size_t i = 0; i < MAX_SIZE_STATE; ++i) {
        nfa_state_t* state = NFA_STATE_AT(i);
        if (state->eclos)
            { continue; }

        bitset_t* result_set = new_bitset();
        ADD_BITSET(result_set, GET_INDEX(state));
        state->eclos = epsilon_closure(result_set);
    }

    do_eclos = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testb $0x1, 0x16411(%rip)     # 0x21dd0
je 0xb9c6
jmp 0xba94
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x163d7(%rip), %rcx     # 0x21db0
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0xba8d
leaq 0x163c3(%rip), %rax     # 0x21db0
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xba0c
jmp 0xba7c
callq 0x12b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0xba3a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1440
jmp 0xba68
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
callq 0xbef0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb9ce
movb $0x1, 0x1633c(%rip)     # 0x21dd0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/dfa.c
// Function: build_ahead_table
static void
build_ahead_table(vector_t* states) {
    for (size_t i = 1; i < SIZE_VECTOR(states); ++i) {
        dfa_state_t* crt_state = (dfa_state_t*)AT_VECTOR(states, i);
        int j;

        bool in_look_machine = false;
        while ((j = IT_NEXT(crt_state->set_state)) != IT_NULL) {
            nfa_state_t* nfa_state = NFA_STATE_AT(j);
            if (nfa_state->beg_lookahead)
                { crt_state->must_ahead = true; }
            if (!nfa_state->in_look_machine)
                { in_look_machine = true; }
        }
        IT_RESET(crt_state->set_state);

        if ((in_look_machine) && (crt_state->must_ahead))
            { crt_state->must_reload = true; }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xbd68
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ac0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0xbced
leaq 0x160f7(%rip), %rax     # 0x21db0
movq (%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0xd(%rax)
je 0xbcdd
movq -0x18(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x28(%rbp), %rax
testb $0x1, 0xe(%rax)
jne 0xbceb
movb $0x1, -0x1d(%rbp)
jmp 0xbc9d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xbcfa
jmp 0xbd3d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x54(%rax)
jne 0xbd1e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xbd3a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
testb $0x1, -0x1d(%rbp)
je 0xbd55
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0xbd55
movq -0x18(%rbp), %rax
movb $0x1, 0x21(%rax)
jmp 0xbd57
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbc74
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/dfa.c
// Function: dfa_edge
static bitset_t*
dfa_edge(bitset_t* states, int symbol) {
    bitset_t* target = new_bitset();

    int i;
    while ((i = IT_NEXT(states)) != IT_NULL)
        { nfa_state_edges(NFA_STATE_AT(i), symbol, target); }
    IT_RESET(states);

    if (is_empty_bitset(target)) {
        del_bitset(target);
        return (NULL_BITSET);
    }

    return (epsilon_closure(target));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x12b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ac0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0xc5cc
leaq 0x15800(%rip), %rax     # 0x21db0
movq (%rax), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0xc0e0
jmp 0xc598
cmpq $0x0, -0x10(%rbp)
jne 0xc5d5
jmp 0xc608
movq -0x10(%rbp), %rax
testb $0x1, 0x54(%rax)
jne 0xc5f1
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0xc605
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
movl %eax, 0x50(%rcx)
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rdi
callq 0x16c0
testb $0x1, %al
jne 0xc617
jmp 0xc62a
movq -0x20(%rbp), %rdi
callq 0x1320
movq $0x0, -0x8(%rbp)
jmp 0xc637
movq -0x20(%rbp), %rdi
callq 0xbef0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0x2b9f(%rip), %rsi      # 0xf218
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x2b96(%rip), %rsi      # 0xf220
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xc6e1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x2b63(%rip), %rsi      # 0xf22f
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc699
movl -0x4(%rbp), %edi
leaq 0x2d36(%rip), %rsi      # 0xf421
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
leaq 0x2b18(%rip), %rsi      # 0xf237
leaq 0x2b21(%rip), %rdx      # 0xf247
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %r9
leaq 0x2b14(%rip), %rsi      # 0xf253
leaq 0x2b21(%rip), %rdx      # 0xf267
leaq 0x194a(%rip), %rcx      # 0xe097
leaq 0x1ba2(%rip), %r8       # 0xe2f6
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/gen_dfa.c
// Function: gen_token_enum
void
gen_token_enum(int filde, lexical_spec_t const* spec) {
    size_t size_entry = SIZE_VECTOR(spec->entry_vect);
    dprintf(filde, ENUM SP BEG_BLOCK NL);

    for (size_t i = 0; i < size_entry; ++i) {
        spec_entry_t* entry = (spec_entry_t*)AT_VECTOR(spec->entry_vect, i);
        ENUM_TOKEN_LINE(filde, entry->name);
    }

    ENUM_TOKEN_LINE(filde, "ERROR");
    ENUM_TOKEN_LINE(filde, "EOF");

    dprintf(filde, END_BLOCK SEMI NL NL);
    dprintf(filde, DEFINE(%s, %zu) NL NL, MACRO_TOKEN, size_entry + 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0x2a7f(%rip), %rsi      # 0xf218
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xc7f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x2a97(%rip), %rsi      # 0xf272
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc7a8
movl -0x4(%rbp), %edi
leaq 0x2a78(%rip), %rsi      # 0xf272
leaq 0x1b41(%rip), %rdx      # 0xe342
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x2a60(%rip), %rsi      # 0xf272
leaq 0x1db1(%rip), %rdx      # 0xe5ca
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x2bf7(%rip), %rsi      # 0xf421
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rcx
addq $0x2, %rcx
leaq 0x2a37(%rip), %rsi      # 0xf27a
leaq 0x2a41(%rip), %rdx      # 0xf28b
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/gen_dfa.c
// Function: gen_token_name
void
gen_token_name(int filde, lexical_spec_t const* spec, char const* header) {
    PRINT_IF_0(filde);
    size_t size_entry = SIZE_VECTOR(spec->entry_vect);

    dprintf(filde, STATIC SP CHAR SP CONST STAR NL);
    gen_verbatim_file(filde, header);

    dprintf(filde, SEP "token_name_table[%zu] = " BEG_BLOCK NL, size_entry + 2);
    for (size_t i = 0; i < size_entry; ++i) {
        spec_entry_t* crt_entry = (spec_entry_t*)AT_VECTOR(spec->entry_vect, i);
        dprintf(filde, TAB "\"%s\"" COMMA NL, crt_entry->name);
    }

    dprintf(filde, TAB "\"ERROR\"" COMMA NL);
    dprintf(filde, TAB "\"EOF\"" COMMA NL);

    dprintf(filde, END_BLOCK SEMI NL NL);
    PRINT_END_IF(filde);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0x2a1a(%rip), %rsi      # 0xf297
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq 0x2a01(%rip), %rsi      # 0xf29f
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4170
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rdx
addq $0x2, %rdx
leaq 0x29f0(%rip), %rsi      # 0xf2b3
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xc91a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x29ca(%rip), %rsi      # 0xf2cf
movb $0x0, %al
callq 0x10d0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xc8d2
movl -0x4(%rbp), %edi
leaq 0x29b3(%rip), %rsi      # 0xf2d7
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x29ad(%rip), %rsi      # 0xf2e2
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x2adb(%rip), %rsi      # 0xf421
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x2994(%rip), %rsi      # 0xf2eb
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/gen_dfa.c
// Function: gen_ahead_table
void
gen_ahead_table(int filde, lexical_spec_t const* spec,
                            char const* header, spec_entry_t const* state) {
    bool first_seen = false;
    size_t size_states = SIZE_VECTOR(spec->states);

    for (size_t i = 1; i < size_states; ++i) {
        dfa_state_t* crt_state = (dfa_state_t*)AT_VECTOR(spec->states, i);
        if (!crt_state->must_ahead)
            { continue; }
        else if (!first_seen) {
            dprintf(filde, STATIC SP "uint8_t" NL);
            gen_verbatim_file(filde, header);

            dprintf(filde, SEP);
            gen_state_name(filde, state);

            dprintf(filde, "ahead_table[%zu][2] = " BEG_BLOCK NL, size_states);
            first_seen = true;
        }
        dprintf(filde, TAB "[%ld]" SP "=" SP BEG_BLOCK SP "true" COMMA SP
                        "%s" COMMA SP END_BLOCK COMMA NL, i,
                        (crt_state->must_reload) ? SP "true" : "false");
    }
    if (first_seen)
        { dprintf(filde, END_BLOCK SEMI NL NL); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xccd6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0xcc37
jmp 0xccc5
testb $0x1, -0x21(%rbp)
jne 0xcc90
movl -0x4(%rbp), %edi
leaq 0x26ee(%rip), %rsi      # 0xf335
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4170
movl -0x4(%rbp), %edi
leaq 0x1692(%rip), %rsi      # 0xe2f6
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xcb50
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rdx
leaq 0x26c0(%rip), %rsi      # 0xf345
movb $0x0, %al
callq 0x10d0
movb $0x1, -0x21(%rbp)
jmp 0xcc92
movl -0x4(%rbp), %edi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rax
movb 0x21(%rax), %sil
leaq 0x26d5(%rip), %rcx      # 0xf37d
leaq 0x26c8(%rip), %rax      # 0xf377
testb $0x1, %sil
cmovneq %rax, %rcx
leaq 0x26a0(%rip), %rsi      # 0xf35e
movb $0x0, %al
callq 0x10d0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xcc03
testb $0x1, -0x21(%rbp)
je 0xcced
movl -0x4(%rbp), %edi
leaq 0x273b(%rip), %rsi      # 0xf421
movb $0x0, %al
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/gen_dfa.c
// Function: gen_action_state_enum_macro
static inline void
gen_action_state_enum_macro(int filde) {
    // Gen enum
	dprintf(filde, ENUM SP BEG_BLOCK NL);
	dprintf(filde, TAB "_BEGIN"  TAB "= 0x1000" COMMA NL);
	dprintf(filde, TAB "_PUSH" TAB "= 0x2000" COMMA NL);
	dprintf(filde, TAB "POP"   TAB "= 0x4000" COMMA NL);
	dprintf(filde, END_BLOCK SEMI NL NL);

    // Gen macro
	dprintf(filde, DEFINE(BEGIN(x),(x | _BEGIN)) NL);
	dprintf(filde, DEFINE(PUSH(x),(x | _PUSH)) NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x20d3(%rip), %rsi      # 0xf218
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x22f9(%rip), %rsi      # 0xf44f
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x22fb(%rip), %rsi      # 0xf462
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x22fc(%rip), %rsi      # 0xf474
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x2298(%rip), %rsi      # 0xf421
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x22ea(%rip), %rsi      # 0xf484
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x22f8(%rip), %rsi      # 0xf4a3
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/gen_dfa.c
// Function: gen_action_entry
static inline void
gen_action_entry(int filde, lexical_spec_t* spec, spec_entry_t* crt_entry,
                    int action, bool* already_print, char const* state_name) {

    if (!(*already_print)) {
        dprintf(filde, TAB);
        (*already_print) = true;
    }

    
    spec_entry_t* out_state = NULL;
    if (action != POP) {
        out_state = (spec_entry_t*)AT_VECTOR(spec->state_vect,
                        action ^ ((action & _BEGIN) ? _BEGIN : _PUSH));
    }

    dprintf(filde, "[" TOKEN_PREFIX SEP "%s]", crt_entry->name);
    dprintf(filde, "[" STATE_PREFIX SEP "%s] = ", state_name);

    if (action != POP) {
        dprintf(filde, "%s(" STATE_PREFIX SEP "%s)",
                    (action & _BEGIN) ? "BEGIN" : "PUSH", out_state->name);
    }
    else
        { dprintf(filde, "POP"); }
    dprintf(filde, COMMA SP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, (%rax)
jne 0xd1ff
movl -0x4(%rbp), %edi
leaq 0x22cf(%rip), %rsi      # 0xf4c0
movb $0x0, %al
callq 0x10d0
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movq $0x0, -0x38(%rbp)
cmpl $0x4000, -0x1c(%rbp)    # imm = 0x4000
je 0xd244
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movl -0x1c(%rbp), %edi
andl $0x1000, %edi           # imm = 0x1000
movl $0x2000, %edx           # imm = 0x2000
movl $0x1000, %esi           # imm = 0x1000
cmpl $0x0, %edi
cmovnel %esi, %edx
xorl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x226c(%rip), %rsi      # 0xf4c2
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rdx
leaq 0x225e(%rip), %rsi      # 0xf4c9
movb $0x0, %al
callq 0x10d0
cmpl $0x4000, -0x1c(%rbp)    # imm = 0x4000
je 0xd2b4
movl -0x4(%rbp), %edi
movl -0x1c(%rbp), %ecx
andl $0x1000, %ecx           # imm = 0x1000
leaq 0xddf(%rip), %rdx       # 0xe06d
leaq 0xdd1(%rip), %rax       # 0xe066
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x2228(%rip), %rsi      # 0xf4d3
movb $0x0, %al
callq 0x10d0
jmp 0xd2c5
movl -0x4(%rbp), %edi
leaq 0xdb5(%rip), %rsi       # 0xe073
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x2063(%rip), %rsi      # 0xf332
movb $0x0, %al
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-parsing.c
// Function: main
int main(int argc, char **argv)
{
	struct symbol_list * list;
	struct string_list * filelist = NULL;
	char *file;

	list = sparse_initialize(argc, argv, &filelist);

	// Simplification
	clean_up_symbols(list);

#if 1
	show_symbol_list(list);
	printf("\n\n");
#endif

	FOR_EACH_PTR(filelist, file) {
		list = sparse(file);

		// Simplification
		clean_up_symbols(list);

#if 1
		// Show the end result.
		show_symbol_list(list);
		printf("\n\n");
#endif
	} END_FOR_EACH_PTR(file);

#if 0
	// And show the allocation statistics
	show_ident_alloc();
	show_token_alloc();
	show_symbol_alloc();
	show_expression_alloc();
	show_statement_alloc();
	show_string_alloc();
	show_bytes_alloc();
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x17350
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11550
movq -0x18(%rbp), %rdi
callq 0x29670
leaq 0x50b89(%rip), %rdi     # 0x62004
movb $0x0, %al
callq 0x110f0
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x114a6
jmp 0x11543
jmp 0x114a8
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1152b
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x114f3
cmpq $0x0, -0x28(%rbp)
jne 0x114f3
jmp 0x11520
movq -0x28(%rbp), %rdi
callq 0x177c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11550
movq -0x18(%rbp), %rdi
callq 0x29670
leaq 0x50aeb(%rip), %rdi     # 0x62004
movb $0x0, %al
callq 0x110f0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x114af
jmp 0x1152d
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x114a8
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-parsing.c
// Function: clean_up_symbols
static void clean_up_symbols(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		expand_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1157d
jmp 0x115f2
jmp 0x1157f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x115de
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x115ca
cmpq $0x0, -0x10(%rbp)
jne 0x115ca
jmp 0x115d3
movq -0x10(%rbp), %rdi
callq 0x11a90
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11586
jmp 0x115e0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x1157f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ammarfaizi2[P]hashtable/src/no_hash.c
// Function: tdiff
long long tdiff(struct timespec clock1, struct timespec clock2)
{
  clock2.tv_sec -= clock1.tv_sec;
  clock2.tv_nsec -= clock1.tv_nsec;
  if (clock2.tv_nsec < 0) {
    clock2.tv_sec -= 1;
    clock2.tv_nsec += 1000000000;
  }
  return 1000000000*clock2.tv_sec + clock2.tv_nsec;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rcx
movq -0x18(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jge 0x11be
movq -0x20(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x18(%rsp)
imulq $0x3b9aca00, -0x20(%rsp), %rax # imm = 0x3B9ACA00
addq -0x18(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ammarfaizi2[P]hashtable/src/no_hash.c
// Function: main
int
main()
{
  const char *data = NULL;
  struct timespec clock1, clock2;

  clock_gettime(CLOCK_MONOTONIC, &clock1);
  for (size_t i = 0; i < (sizeof(list)/sizeof(list[0])); i++) {
    if (!strcmp(list[i][0], "SutNmukuaOWUZJaHtaayfBrwXkEvyURBdwiTXneTIvsVSkPlhWbYBxRmUhWaFnbdWqyAnqsxXqifoZsJIDiFqWVvlBrilzUbqcgR")) {
      data = list[i][1];
      break;
    }
  }
  clock_gettime(CLOCK_MONOTONIC, &clock2);
  printf("%8lli ms\n", tdiff(clock1, clock2)/1000000);

  if (data != NULL) {
    printf("%s\n", data);
  } else {
    printf("Not Found\n");
  }
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
movl $0x1, %edi
leaq 0x18(%rsp), %rsi
callq 0x1030
movq $0x0, (%rsp)
cmpq $0x186a0, (%rsp)        # imm = 0x186A0
jae 0x1258
movq 0x2ddb(%rip), %rdi      # 0x3fe8
imulq $0x190, (%rsp), %rax    # imm = 0x190
addq %rax, %rdi
leaq 0xde5(%rip), %rsi       # 0x2004
callq 0x1050
cmpl $0x0, %eax
jne 0x1248
movq 0x2db8(%rip), %rax      # 0x3fe8
imulq $0x190, (%rsp), %rcx    # imm = 0x190
addq %rcx, %rax
addq $0xc8, %rax
movq %rax, 0x28(%rsp)
jmp 0x1258
jmp 0x124a
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x11fc
movl $0x1, %edi
leaq 0x8(%rsp), %rsi
callq 0x1030
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x1160
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %rsi
leaq 0xdd5(%rip), %rdi       # 0x2069
movb $0x0, %al
callq 0x1040
cmpq $0x0, 0x28(%rsp)
je 0x12b8
movq 0x28(%rsp), %rsi
leaq 0xdc4(%rip), %rdi       # 0x2073
movb $0x0, %al
callq 0x1040
jmp 0x12c6
leaq 0xdb8(%rip), %rdi       # 0x2077
movb $0x0, %al
callq 0x1040
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/example/main.c
// Function: usage
void usage(void) {
	fprintf(stderr, "Usage example:\n");
	fprintf(stderr, "-h host [default 127.0.0.1] \n");
	fprintf(stderr, "-p port [default 3000]\n");
	fprintf(stderr, "-n namespace [default test]\n");
	fprintf(stderr, "-b bin [default value]\n");
	fprintf(stderr, "-m milliseconds timeout [default 200]\n");
	fprintf(stderr, "-f do not follow cluster [default do follow]\n");
	fprintf(stderr, "-r use shared memory [default false]\n");
	fprintf(stderr, "-v is verbose\n");
}

// Assembly:
pushq %rax
movq 0x1a588(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x14759(%rip), %rsi     # 0x1a1bb
movb $0x0, %al
callq 0x5380
movq 0x1a570(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x14751(%rip), %rsi     # 0x1a1cb
movb $0x0, %al
callq 0x5380
movq 0x1a558(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x14757(%rip), %rsi     # 0x1a1e9
movb $0x0, %al
callq 0x5380
movq 0x1a540(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x14757(%rip), %rsi     # 0x1a201
movb $0x0, %al
callq 0x5380
movq 0x1a528(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x1475c(%rip), %rsi     # 0x1a21e
movb $0x0, %al
callq 0x5380
movq 0x1a510(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x1475c(%rip), %rsi     # 0x1a236
movb $0x0, %al
callq 0x5380
movq 0x1a4f8(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x1476b(%rip), %rsi     # 0x1a25d
movb $0x0, %al
callq 0x5380
movq 0x1a4e0(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x14781(%rip), %rsi     # 0x1a28b
movb $0x0, %al
callq 0x5380
movq 0x1a4c8(%rip), %rax     # 0x1ffe0
movq (%rax), %rdi
leaq 0x1478f(%rip), %rsi     # 0x1a2b1
movb $0x0, %al
callq 0x5380
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vi[P]simple_cbor_stream_parse/roundtrip.cpp
// Function: main
int main() {
    // Note; on Windows you should also set std::cin to binary mode
    std::ios::sync_with_stdio(false);
    
    scsp::Generator gen(std::cout);
    if (!scsp::parse_from_istream(std::cin, gen)) {
        std::cerr << "Error" << std::endl;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
callq 0x2050
leaq -0x18(%rbp), %rdi
movq 0x4d17(%rip), %rsi      # 0x6fc8
callq 0x2310
movq 0x4d1b(%rip), %rdi      # 0x6fd8
leaq -0x18(%rbp), %rsi
callq 0x24a0
testb $0x1, %al
jne 0x22f5
movq 0x4d1f(%rip), %rdi      # 0x6ff0
leaq 0x2d2c(%rip), %rsi      # 0x5004
callq 0x2080
movq %rax, %rdi
movq 0x4cd1(%rip), %rsi      # 0x6fb8
callq 0x20b0
movl $0x1, -0x4(%rbp)
jmp 0x22fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop