LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tests/jtutil.c
// Function: jt_dequeue_sequence
void jt_dequeue_sequence(struct dhara_journal *j, int next, int count)
{
	const int max_garbage = 1 << j->log2_ppc;
	int garbage_count = 0;

	while (count > 0) {
		uint8_t meta[DHARA_META_SIZE];
		uint32_t id;
		dhara_page_t tail = dhara_journal_peek(j);
		dhara_error_t err;

		assert(tail != DHARA_PAGE_NONE);

		jt_check(j);
		if (dhara_journal_read_meta(j, tail, meta, &err) < 0)
			dabort("read_meta", err);

		jt_check(j);
		dhara_journal_dequeue(j);
		id = dhara_r32(meta);

		if (id == 0xffffffff) {
			garbage_count++;
			assert(garbage_count < max_garbage);
		} else {
			const int page_size = 1 << j->nand->log2_page_size;
			uint8_t r[page_size];

			assert(id == next);
			garbage_count = 0;
			next++;
			count--;

			if (dhara_nand_read(j->nand, tail, 0,
					    page_size, r, &err) < 0)
				dabort("nand_read", err);

			seq_assert(id, r, page_size);
		}

		if (count == 1)
			printf("head=%d, tail=%d, root=%d\n",
				j->head, j->tail, j->root);
	}

	jt_check(j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movb 0x10(%rdi), %cl
pushq $0x1
popq %rax
shll %cl, %eax
movl %eax, -0x30(%rbp)
movl %esi, %r13d
xorl %r12d, %r12d
testl %r14d, %r14d
jle 0x2f34
movq %rbx, %rdi
callq 0x1740
cmpl $-0x1, %eax
je 0x2f4b
movl %eax, %r15d
movq %rbx, %rdi
callq 0x2a28
movq %rbx, %rdi
movl %r15d, %esi
leaq -0xd0(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0x16bd
testl %eax, %eax
jns 0x2e6f
movl -0x2c(%rbp), %esi
leaq 0x8c6(%rip), %rdi       # 0x3730
callq 0x29cb
movq %rbx, %rdi
callq 0x2a28
movq %rbx, %rdi
callq 0x17cd
movl -0xd0(%rbp), %eax
cmpl $-0x1, %eax
je 0x2f05
movq (%rbx), %rcx
movb (%rcx), %cl
pushq $0x1
popq %rdx
shlq %cl, %rdx
movq %rsp, -0x40(%rbp)
leaq 0xf(%rdx), %rcx
andq $-0x10, %rcx
movq %rsp, %r12
subq %rcx, %r12
movq %r12, %rsp
movq %r13, %rcx
cmpl %ecx, %eax
jne 0x2f6a
movq (%rbx), %rdi
movslq %edx, %rcx
movl %r15d, %esi
xorl %edx, %edx
movq %rcx, -0x38(%rbp)
movq %r12, %r8
leaq -0x2c(%rbp), %r9
callq 0x25bd
testl %eax, %eax
jns 0x2ee3
movl -0x2c(%rbp), %esi
leaq 0x8f3(%rip), %rdi       # 0x37d1
callq 0x29cb
leal 0x1(%r13), %r15d
decl %r14d
movl %r13d, %edi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
callq 0x2968
xorl %r12d, %r12d
movq -0x40(%rbp), %rsp
movl %r15d, %r13d
jmp 0x2f0e
incl %r12d
cmpl -0x30(%rbp), %r12d
jge 0x2f89
cmpl $0x1, %r14d
jne 0x2e21
movl 0x20(%rbx), %edx
movl 0x24(%rbx), %esi
movl 0x28(%rbx), %ecx
leaq 0x8b3(%rip), %rdi       # 0x37db
xorl %eax, %eax
callq 0x1070
jmp 0x2e21
movq %rbx, %rdi
callq 0x2a28
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x805(%rip), %rdi       # 0x3757
leaq 0x6f9(%rip), %rsi       # 0x3652
leaq 0x80f(%rip), %rcx       # 0x376f
movl $0xb0, %edx
callq 0x1080
leaq 0x855(%rip), %rdi       # 0x37c6
leaq 0x6da(%rip), %rsi       # 0x3652
leaq 0x7f0(%rip), %rcx       # 0x376f
movl $0xc1, %edx
callq 0x1080
leaq 0x81a(%rip), %rdi       # 0x37aa
leaq 0x6bb(%rip), %rsi       # 0x3652
leaq 0x7d1(%rip), %rcx       # 0x376f
movl $0xbc, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/fgfl.c
// Function: gen_dfa_final_tables
static inline void
gen_dfa_final_tables(int filde, lexical_spec_t* spec, nfa_state_t* master,
                                    char const* header, spec_entry_t* state) {
    build_dfa_table(master, spec);

    gen_state_table(filde, spec, header, state);
    gen_ahead_table(filde, spec, header, state);

    GEN_FINAL_TABLE(filde, spec, header, state);
    GEN_ANCHOR_FINAL_TABLE(filde, spec, header, state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movl %edi, %r12d
movq %rdx, %rdi
callq 0x8011
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x897e
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8b15
pushq $0x2
popq %r8
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8c1c
pushq $0x3
popq %r8
movl %r12d, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8c1c
nop
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: del_lexical_spec
void
del_lexical_spec(lexical_spec_t* spec) {
    if (spec) {
        foreach_vector(spec->entry_vect, &del_spec_entry);
        foreach_vector(spec->state_vect, &del_spec_entry);
    
        del_vector(spec->entry_vect);
        del_vector(spec->state_vect);

        del_lexer(spec->lex);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x412d
movq 0x8(%rbx), %rdi
leaq 0x53(%rip), %r14        # 0x4139
movq %r14, %rsi
callq 0x2b98
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2b98
movq 0x8(%rbx), %rdi
callq 0x29c6
movq 0x10(%rbx), %rdi
callq 0x29c6
movq (%rbx), %rdi
callq 0x301d
movq 0x28(%rbx), %rdi
leaq 0x3ec4(%rip), %rsi      # 0x7fe3
callq 0x2b98
movq 0x28(%rbx), %rdi
callq 0x29c6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: del_spec_entry
static void
del_spec_entry(spec_entry_t* entry) {
    if (entry) {
        if (entry->kind == T_TERMINAL) {
            del_regex_node(entry->regex_ast);
            del_trans_list(entry->state_lst);
        }
        FREE(entry->name);
    }
    FREE(entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x4168
cmpl $0x2d, 0x8(%rbx)
jne 0x415f
movq 0x20(%rbx), %rdi
callq 0x751f
movq 0x38(%rbx), %rdi
callq 0x388a
movq 0x10(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_token_section
int
spec_token_section(lexical_spec_t* spec) {
    bool empty = true;
    while (peek_token(spec->lex) != T_EOF) {
        if (spec_token_entry_section(spec) == ERROR)
            { return (ERROR); }
        empty = false;
    }
    if (empty)
        { warnf(0, "Empty file. No output generated."); }
    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movb $0x1, %bl
leaq 0x477(%rip), %r13       # 0x4615
movq (%r15), %rdi
callq 0x3559
cmpl $0x70, %eax
je 0x421d
movq (%r15), %rdi
callq 0x306d
movq %rax, %r12
movb $0x1, %r14b
addl $-0x40, %eax
movq %r13, %rbx
cmpl $0x2, %eax
jb 0x41dc
leal -0x42(%r12), %eax
cmpl $0x1, %eax
ja 0x4298
xorl %r14d, %r14d
leaq 0x829(%rip), %rbx       # 0x4a05
movq (%r15), %rdi
callq 0x306d
cmpq $0x32, %rax
jne 0x423e
movq %r15, %rdi
movl %r12d, %esi
callq *%rbx
cmpl $-0x1, %eax
je 0x42ad
movq (%r15), %rdi
callq 0x306d
cmpq $0x33, %rax
jne 0x4247
movq (%r15), %rdi
callq 0x306d
xorl %ebx, %ebx
cmpq $0x30, %rax
je 0x419e
pushq $0x3b
jmp 0x4249
xorl %r13d, %r13d
testb $0x1, %bl
je 0x42b1
leaq 0x6e2d(%rip), %rsi      # 0xb05d
xorl %r13d, %r13d
xorl %edi, %edi
xorl %eax, %eax
callq 0x3d40
jmp 0x42b1
pushq $-0x1
popq %r13
pushq $0x7b
popq %rdx
jmp 0x424e
pushq $0x7d
popq %rdx
pushq $-0x1
popq %r13
movq (%r15), %rax
cmpl $0x41, %r12d
leaq 0x5ece(%rip), %rcx      # 0xa12a
leaq 0x5ec1(%rip), %r8       # 0xa124
cmoveq %rcx, %r8
cmpl $0x43, %r12d
leaq 0x5ec8(%rip), %rsi      # 0xa13a
leaq 0x5eb8(%rip), %rcx      # 0xa131
cmoveq %rsi, %rcx
movslq 0x28(%rax), %rdi
testb %r14b, %r14b
cmovneq %r8, %rcx
leaq 0x6e62(%rip), %rsi      # 0xb0f1
xorl %eax, %eax
callq 0x3bdc
jmp 0x42b1
movq (%r15), %rax
movslq 0x28(%rax), %rdi
leaq 0x6e34(%rip), %rsi      # 0xb0da
xorl %eax, %eax
callq 0x3bdc
pushq $-0x1
popq %r13
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: parse_lexical_spec
lexical_spec_t*
parse_lexical_spec(int filde) {
    lexical_spec_t* crt_spec = new_lexical_spec(filde);
    if (spec_token_section(crt_spec) == ERROR) {
        del_lexical_spec(crt_spec);
        return (NULL);
    }
    return (crt_spec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
pushq $0x40
popq %rdi
callq 0x372f
movq %rax, %rbx
testq %rax, %rax
je 0x4314
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl %r14d, %edi
callq 0x2fbc
movq %rax, (%rbx)
callq 0x2924
movq %rax, 0x8(%rbx)
callq 0x2924
movq %rax, 0x10(%rbx)
orl $-0x1, 0x18(%rbx)
movb $0x1, 0x1c(%rbx)
movq %rbx, %rdi
callq 0x4184
cmpl $-0x1, %eax
jne 0x432b
movq %rbx, %rdi
callq 0x40cc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: print_token_entry
void
print_token_entry(lexical_spec_t* spec) {
    for (size_t i = 0; i < SIZE_VECTOR(spec->entry_vect); ++i) {
        spec_entry_t* crt_entry = AT_VECTOR(spec->entry_vect, i);
        printf("Token %s, fragment %d.\n",
                                        crt_entry->name, crt_entry->fragment);
        printf("Root node = %p\n", crt_entry->regex_ast);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6aed(%rip), %r14      # 0xb0b2
leaq 0x6afe(%rip), %r15      # 0xb0ca
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %r12
jae 0x4606
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movq 0x10(%r13), %rsi
movzbl 0x18(%r13), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movq 0x20(%r13), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20c0
incq %r12
jmp 0x45cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_state_token_list
int
spec_state_token_list(lexical_spec_t* spec, int kind_section) {
    if (peek_token(spec->lex) == T_RBRACE)
        { return (DONE); }
    else if (advance_token(spec->lex) == T_TERMINAL) {
        spec_entry_t* entry = add_entry_lexeme(spec, kind_section);
        if (!entry)
            { return (ERROR); }

        ++(entry->count);
        if (kind_section == T_STATE)
            { entry->is_defined = true; }

        if (peek_token(spec->lex) == T_BARROW) {
            if (kind_section == T_KEYWORD) {
                errorf(CURRENT_LINE(spec->lex),
                            "A '=>' can't appear in the $KEYWORD section.");
                return (ERROR);
            }

            advance_token(spec->lex);
            if (advance_token(spec->lex) != T_INITIAL) {
                errorf(CURRENT_LINE(spec->lex),
                            "Missing $INITIAL after the '=>' in the $STATE.");
                return (ERROR);
            }
            else if (spec->start_state != -1)
                { warnf(CURRENT_LINE(spec->lex), "Override initial state."); }
            spec->start_state = GET_INDEX(entry);
        }

        if (peek_token(spec->lex) == T_COMMA) {
            advance_token(spec->lex);
            return (spec_state_token_list(spec, kind_section));
        }
    }
    else {
        errorf(CURRENT_LINE(spec->lex),
                            "Expected identifier in the %s section.",
                            STATE_TYPE_LST_SECT(kind_section));
        return (ERROR);
    }
    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
pushq $-0x1
popq %rbx
leaq 0x6cac(%rip), %r12      # 0xb6cf
movq (%r14), %rdi
callq 0x3559
cmpl $0x33, %eax
je 0x4acf
movq (%r14), %rdi
callq 0x306d
cmpq $0x2d, %rax
jne 0x4ad3
movq %r14, %rdi
movl %r15d, %esi
callq 0x4b33
testq %rax, %rax
je 0x4b22
movq %rax, %r13
incq 0x28(%rax)
cmpl $0x43, %r15d
jne 0x4a6c
movb $0x1, 0x20(%r13)
movq (%r14), %rdi
callq 0x3559
cmpl $0x2f, %eax
jne 0x4ab5
movq (%r14), %rdi
cmpl $0x42, %r15d
je 0x4b00
callq 0x306d
movq (%r14), %rdi
callq 0x306d
cmpq $0x45, %rax
jne 0x4b0d
cmpl $-0x1, 0x18(%r14)
je 0x4aad
movq (%r14), %rax
movslq 0x28(%rax), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3d40
movl (%r13), %eax
movl %eax, 0x18(%r14)
movq (%r14), %rdi
callq 0x3559
cmpl $0x31, %eax
jne 0x4acf
movq (%r14), %rdi
callq 0x306d
jmp 0x4a23
xorl %ebx, %ebx
jmp 0x4b22
cmpl $0x43, %r15d
movq (%r14), %rax
movslq 0x28(%rax), %rdi
leaq 0x5655(%rip), %rax      # 0xa13a
leaq 0x5645(%rip), %rdx      # 0xa131
cmoveq %rax, %rdx
leaq 0x6bf0(%rip), %rsi      # 0xb6e7
xorl %eax, %eax
callq 0x3bdc
jmp 0x4b22
movslq 0x28(%rdi), %rdi
leaq 0x6b68(%rip), %rsi      # 0xb673
jmp 0x4b1b
movq (%r14), %rax
movslq 0x28(%rax), %rdi
leaq 0x6b85(%rip), %rsi      # 0xb6a0
xorl %eax, %eax
callq 0x3bdc
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: del_nfa_record
void
del_nfa_record(void) {
    foreach_vector(record_nfa_state, &del_nfa_state);
    del_vector(record_nfa_state);
    foreach_vector(record_nfa_automata, &del_nfa_automaton);
    del_vector(record_nfa_automata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18dbd(%rip), %rdi     # 0x1dec0
leaq 0x31(%rip), %rsi        # 0x513b
callq 0x2b98
movq 0x18daa(%rip), %rdi     # 0x1dec0
callq 0x29c6
movq 0x18da6(%rip), %rdi     # 0x1dec8
leaq 0x46(%rip), %rsi        # 0x516f
callq 0x2b98
movq 0x18d93(%rip), %rdi     # 0x1dec8
popq %rbp
jmp 0x29c6
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: del_nfa_state
static void
del_nfa_state(nfa_state_t* state) {
    if (state) {
        if (state->symbol_edge == EDGE_CLASS)
            { del_bitset(state->class); }
        del_bitset(state->eclos);
    }
    FREE(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5161
cmpl $-0x2, 0x10(%rbx)
jne 0x5158
movq 0x28(%rbx), %rdi
callq 0x2351
movq 0x30(%rbx), %rdi
callq 0x2351
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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 0x57b2
testq %rax, %rax
je 0x5b80
movq %rax, %rbx
movq 0x18(%r14), %rdi
callq 0x57b2
testq %rax, %rax
je 0x5b6b
movq %rax, %r14
pushq $-0x1
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x519a
movq %rax, %r15
pushq $-0x4
popq %rdi
xorl %eax, %eax
callq 0x519a
testq %r15, %r15
setne %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
je 0x5b70
movq 0x28(%rbx), %rcx
cmpl $-0x4, 0x10(%rcx)
movl $0x101, %edx            # imm = 0x101
pushq $-0x3
popq %rsi
movl %esi, %edi
cmovel %edx, %edi
movl %edi, 0x10(%rcx)
movq %rax, 0x18(%rcx)
movq 0x28(%r14), %rcx
cmpl $-0x4, 0x10(%rcx)
cmovel %edx, %esi
movl %esi, 0x10(%rcx)
movq %rax, 0x18(%rcx)
pushq $0x3
popq %rdi
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 0x5567
movq %rbx, %rdi
jmp 0x5b7b
movq %rbx, %rdi
callq 0x516f
movq %r14, %rdi
callq 0x516f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq 0x10(%rdi), %rdi
callq 0x57b2
testq %rax, %rax
je 0x5c0c
movq %rax, %rbx
movq 0x1830d(%rip), %rax     # 0x1dec0
movq 0x10(%rax), %r12
movq 0x18(%r15), %rdi
callq 0x57b2
testq %rax, %rax
je 0x5c04
movq %rax, %r14
movl (%r15), %eax
cmpl $0x5, %eax
jne 0x5bf0
movq 0x182e9(%rip), %rcx     # 0x1dec0
movq 0x10(%rcx), %rdx
cmpq %rdx, %r12
jae 0x5bf0
movq (%rcx), %rsi
movq (%rsi,%r12,8), %rsi
movb $0x1, 0xe(%rsi)
incq %r12
jmp 0x5bdb
movq 0x28(%rbx), %rcx
cmpl $-0x1, 0x10(%rcx)
je 0x5c17
orl $-0x1, 0x10(%rcx)
movq %r14, 0x20(%rcx)
jmp 0x5c1e
movq %rbx, %rdi
callq 0x516f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x28(%rcx)
movl (%r15), %eax
cmpl $0x5, %eax
jne 0x5c2b
movq %r14, %rdi
callq 0x5ca3
movq 0x28(%r14), %rcx
pushq $0x2
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5567
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x4
popq %rdi
xorl %eax, %eax
callq 0x519a
testq %rax, %rax
je 0x5c9c
movq %rax, %rbx
movq %r14, %rdi
callq 0x237f
pushq $-0x2
popq %rdi
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x519a
testq %rax, %rax
je 0x5c94
pushq $0x6
popq %rdi
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5567
movq %rbx, %rdi
callq 0x513b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %r14
movb $0x1, %bl
leaq 0x5c2b(%rip), %rax      # 0xb8e4
movl 0x8(%r14), %ecx
decl %ecx
cmpl $0x5, %ecx
ja 0x5cdd
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x10(%r14), %r14
xorl %ebx, %ebx
jmp 0x5cb9
movq 0x28(%r14), %rax
movb $0x1, 0xd(%rax)
movb $0x1, %al
jmp 0x5d1b
movq 0x20(%r14), %rdi
callq 0x5ca3
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x5ca3
andb %al, %bl
andb %r15b, %bl
jmp 0x5d1d
movq 0x18(%r14), %rdi
callq 0x5ca3
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x5d1b
movq 0x20(%r14), %rdi
callq 0x5ca3
jmp 0x5d1b
xorl %eax, %eax
andb %al, %bl
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, 0x1818c(%rip)     # 0x1ded0
movq %rsi, 0x1818d(%rip)     # 0x1ded8
movq (%rdi), %rdi
callq 0x3559
cmpl $0x18, %eax
jne 0x5d64
movq (%r14), %rdi
callq 0x306d
movb $0x1, 0x19(%rbx)
callq 0x5e3e
testq %rax, %rax
je 0x5dff
movq %rax, %rbx
movq 0x18154(%rip), %rax     # 0x1ded0
movq (%rax), %rdi
callq 0x3559
cmpl $0xb, %eax
jne 0x5dc5
movq 0x18140(%rip), %rax     # 0x1ded0
movq (%rax), %rdi
callq 0x306d
callq 0x5e3e
testq %rax, %rax
je 0x5e03
pushq $0x5
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x71a4
movq %rax, %rbx
movq 0x1811c(%rip), %rax     # 0x1ded8
movb $0x1, 0x1a(%rax)
testq %rbx, %rbx
je 0x5dff
movq (%r14), %rdi
callq 0x3559
cmpl $0x19, %eax
jne 0x5e0c
cmpl $0x5, (%rbx)
jne 0x5e14
movq %rbx, %rdi
callq 0x751f
movq 0x180ea(%rip), %rax     # 0x1ded0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x5bd8(%rip), %rsi      # 0xb9cc
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3bdc
jmp 0x5e0c
xorl %ebx, %ebx
jmp 0x5e0c
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x751f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rdi
callq 0x306d
pushq $0xa
popq %rdi
movl %edi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x71a4
pushq $0x5
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
callq 0x5ec3
testq %rax, %rax
je 0x5e8f
movq %rax, %rbx
movq 0x18078(%rip), %rax     # 0x1ded0
movq (%rax), %rdi
callq 0x3559
cmpl $0x4, %eax
jne 0x5eb9
movq 0x18064(%rip), %rax     # 0x1ded0
movq (%rax), %rdi
callq 0x306d
callq 0x5ec3
testq %rax, %rax
je 0x5e93
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x71a4
jmp 0x5e4e
xorl %ebx, %ebx
jmp 0x5eb9
movq %rbx, %rdi
callq 0x751f
movq 0x1802e(%rip), %rax     # 0x1ded0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x5b3b(%rip), %rsi      # 0xb9eb
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3bdc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x5f53
testq %rax, %rax
je 0x5f3f
movq %rax, %rbx
pushq $0x4
popq %r15
pushq $0x9
popq %r12
pushq $0x19
popq %r13
pushq $0x3
popq %r14
movq 0x17fdb(%rip), %rax     # 0x1ded0
movq (%rax), %rdi
pushq $0xb
popq %rsi
movl %r15d, %edx
movl %r12d, %ecx
movl %r13d, %r8d
movl %r14d, %r9d
xorl %eax, %eax
pushq $-0x1
pushq $0x70
callq 0x3585
popq %rcx
popq %rdx
testb %al, %al
jne 0x5f41
callq 0x5f53
testq %rax, %rax
je 0x5f37
pushq $0x1
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x71a4
movq %rax, %rbx
jmp 0x5eee
movq %rbx, %rdi
callq 0x751f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/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 %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1d, %edi
je 0x67cc
cmpl $0x1e, %edi
je 0x6767
cmpl $0x1f, %edi
jne 0x67f4
movq 0x177a9(%rip), %rax     # 0x1ded0
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movsbl (%rax), %ebx
cmpl $0x5c, %ebx
jne 0x67f7
movzbl 0x1(%rax), %eax
movsbl %al, %ebx
leal -0x6e(%rax), %ecx
cmpl $0x8, %ecx
ja 0x6802
leaq 0x5221(%rip), %rax      # 0xb978
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0xa
jmp 0x67f6
movq 0x17762(%rip), %rax     # 0x1ded0
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %r14
addq $0x2, %r14
xorl %ebx, %ebx
pushq $-0x1
popq %r15
movsbl (%r14), %r12d
testl %r12d, %r12d
je 0x67f7
callq 0x2200
movq (%rax), %rax
movslq %r12d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xb, %eax
jb 0x67b5
btl $0x9, %eax
jb 0x67bb
btl $0x8, %eax
movl %r15d, %eax
jae 0x67c2
addl $-0x37, %r12d
jmp 0x67bf
addl $-0x30, %r12d
jmp 0x67bf
addl $-0x57, %r12d
movl %r12d, %eax
shll $0x4, %ebx
addl %eax, %ebx
incq %r14
jmp 0x6782
movq 0x176fd(%rip), %rax     # 0x1ded0
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
incq %rax
xorl %ebx, %ebx
movsbl (%rax), %ecx
testl %ecx, %ecx
je 0x67f7
leal (%rcx,%rbx,8), %ebx
addl $-0x30, %ebx
incq %rax
jmp 0x67e2
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x61, %eax
je 0x6825
cmpl $0x62, %eax
je 0x6821
cmpl $0x66, %eax
jne 0x67f7
pushq $0xc
jmp 0x67f6
pushq $0xd
jmp 0x67f6
pushq $0xb
jmp 0x67f6
pushq $0x9
jmp 0x67f6
pushq $0x8
jmp 0x67f6
pushq $0x7
jmp 0x67f6
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/fgfl/src/dfa_minimization.c
// Function: input_to_state
static size_t
input_to_state(trans_list_t const* list, size_t input) {
    while (list) {
        if ((size_t)list->input == input)
            { return (list->state); }
        list = list->next;
    }
    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testq %rdi, %rdi
je 0x71a2
movslq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
je 0x719e
movq (%rdi), %rdi
jmp 0x718b
movslq 0xc(%rdi), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7554
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x8, %eax
jae 0x7555
movq 0x10(%rbx), %rdi
callq 0x751f
movq 0x18(%rbx), %rdi
callq 0x751f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
retq
je 0x7567
cmpl $0xc, %eax
jne 0x7546
movq 0x8(%rbx), %rdi
callq 0x2351
jmp 0x7546
movq 0x8(%rbx), %rdi
callq 0x2040
jmp 0x7546
// File: /workspace/github_c_makefile_star2_O2/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 0x75c1
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0xc, %rax
ja 0x75c1
leaq 0x46d4(%rip), %rcx      # 0xbc64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x7572
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x7572
movl (%rbx), %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0xb
popq %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
movq 0x8(%rbx), %rdi
callq 0x237f
movl 0x10(%rbx), %edx
movl 0x14(%rbx), %ecx
pushq $0xc
popq %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
movzbl 0x8(%rbx), %esi
pushq $0x9
popq %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
movzbl 0x8(%rbx), %esi
movzbl 0x9(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movzbl 0xb(%rbx), %r8d
movq 0x10(%rbx), %r9
pushq $0x7
popq %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
movl 0x8(%rbx), %esi
movzbl 0xc(%rbx), %edx
pushq $0xa
popq %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
movq 0x8(%rbx), %rdi
callq 0x21f0
pushq $0x8
popq %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x71a4
// File: /workspace/github_c_makefile_star2_O2/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 0x76a9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
decq %rbx
pushq $0x1
popq %r15
movq %rdi, %r12
subq $0x1, %rbx
jb 0x769d
movq %r14, %rdi
callq 0x7572
movl %r15d, %edi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x71a4
movq %rax, %r12
jmp 0x767a
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0xb
popq %rdi
xorl %eax, %eax
jmp 0x71a4
// File: /workspace/github_c_makefile_star2_O2/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 0x76ed
movl (%r14), %eax
cmpq %r15, %rax
je 0x76f8
cmpl $0x7, %eax
ja 0x76ed
movq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x76b3
movq 0x18(%r14), %r14
jmp 0x76c6
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 0x2a16
// File: /workspace/github_c_makefile_star2_O2/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 0x77f1
cmpl $0x8, (%rbx)
jae 0x77a9
movq 0x10(%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x775f
movq 0x8(%r14), %rax
movq (%rax), %rax
movq 0x10(%rdi), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %r15
callq 0x751f
movq %r15, %rdi
callq 0x7572
movq %rax, %rdi
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x7798
cmpl $0x8, (%rax)
jne 0x7798
movq 0x8(%r14), %rcx
movq (%rcx), %rcx
movq 0x10(%rax), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x20(%rcx), %r15
movq %rax, %rdi
callq 0x751f
movq %r15, %rdi
callq 0x7572
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x7711
movq 0x18(%rbx), %rbx
jmp 0x7721
jne 0x77f1
movq 0x8(%r14), %rax
movq (%rax), %rax
movq 0x10(%rbx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
callq 0x7572
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_O2/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, %rax
testq %rdi, %rdi
je 0x7906
cmpl $0x9, (%rax)
jne 0x7906
movb $0x1, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rax
testq %rdi, %rdi
je 0x793e
cmpl $0xa, (%rax)
jne 0x793e
movl 0x8(%rax), %ecx
cmpq $0x20, %rcx
ja 0x793e
movabsq $0x100000600, %rdx      # imm = 0x100000600
btq %rcx, %rdx
jae 0x793e
cmpb $0x0, 0xc(%rax)
jne 0x793e
movl $0xb, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7a76
movl (%rbx), %eax
pushq $0x1
popq %r15
cmpl $0xc, %eax
je 0x79c5
cmpl $0xa, %eax
jne 0x7a76
callq 0x2200
movq (%rax), %rax
movslq 0x8(%rbx), %r14
testb $0x4, 0x1(%rax,%r14,2)
je 0x79bc
movl $0xc, (%rbx)
callq 0x230c
movq %rax, 0x8(%rbx)
orq $-0x1, 0x10(%rbx)
movl 0x4(%rax), %ecx
cmpq %rcx, %r14
jae 0x79b1
movq %r15, %rdx
movl %r14d, %ecx
shlq %cl, %rdx
movq 0x8(%rax), %rax
shrq $0x6, %r14
orq %rdx, (%rax,%r14,8)
jmp 0x79bc
movq %rax, %rdi
movq %r14, %rsi
callq 0x23f9
cmpl $0xc, (%rbx)
jne 0x7a76
movslq 0x10(%rbx), %rdi
cmpq $-0x1, %rdi
je 0x79dd
leaq 0x42f2(%rip), %rsi      # 0xbcc8
xorl %eax, %eax
callq 0x3d40
movslq 0x14(%rbx), %rdi
cmpq $-0x1, %rdi
je 0x7a4f
leaq 0x4302(%rip), %rsi      # 0xbcf0
xorl %eax, %eax
callq 0x3d40
jmp 0x7a4f
movl %eax, %r14d
callq 0x2200
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xa, %eax
jae 0x7a4f
movl %r14d, %edi
btl $0x9, %eax
jb 0x7a1f
callq 0x2160
jmp 0x7a24
callq 0x2070
movslq %eax, %rcx
movq 0x8(%rbx), %rdi
movl 0x4(%rdi), %eax
cmpq %rax, %rcx
jae 0x7a47
movq %r15, %rax
shlq %cl, %rax
movq 0x8(%rdi), %rdx
shrq $0x6, %rcx
orq %rax, (%rdx,%rcx,8)
jmp 0x7a4f
movq %rcx, %rsi
callq 0x23f9
movq 0x8(%rbx), %rdi
callq 0x273a
cmpl $-0x1, %eax
jne 0x79f7
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x7a76
xorl %ecx, %ecx
cmpb $0x1, 0x54(%rax)
jne 0x7a73
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_O2/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 0x7aab
movq %rdi, %rbx
cmpl $0x7, (%rdi)
ja 0x7aaf
movq 0x10(%rbx), %rdi
cmpl $0x7, (%rdi)
ja 0x7ab8
movq %rsi, %r14
callq 0x7a84
jmp 0x7abd
xorl %ebx, %ebx
jmp 0x7ae0
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 0x7ad9
cmpl $0x7, (%rdi)
ja 0x7ad9
movq %r14, %rsi
callq 0x7a84
jmp 0x7adc
callq *%r14
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %r14
movl $0xdc, %r15d
pushq $0x18
popq %r13
movq %rdi, %r12
testq %r12, %r12
je 0x7b89
movl (%r12), %eax
cmpl $0x7, %eax
ja 0x7b89
btl %eax, %r15d
movq %r14, %rcx
jae 0x7b27
movq (%r12,%rcx), %r12
jmp 0x7b0a
testl %eax, %eax
jne 0x7b3a
movq 0x10(%r12), %rdi
callq 0x7ae8
movq %r13, %rcx
jmp 0x7b21
cmpl $0x1, %eax
jne 0x7b89
movq 0x10(%r12), %r15
movq %r15, %rdi
callq 0x7ae8
movq 0x18(%r12), %r14
movq %r14, %rdi
callq 0x7ae8
movq 0x10(%r12), %rax
cmpl $0x1, (%rax)
jne 0x7b7f
movq 0x18(%rax), %rcx
movq %rcx, 0x18(%r12)
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%r12), %rax
movq %r14, 0x10(%rax)
jmp 0x7b89
movq %r14, 0x10(%r12)
movq %r15, 0x18(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MaoKo[P]FGFX/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 0x2924
movq %rax, %rbx
xorl %r13d, %r13d
callq 0x230c
movq %rax, %r14
xorl %r12d, %r12d
movq 0x8(%r15), %rax
cmpq 0x10(%rax), %r12
jae 0x7c23
movq (%rax), %rax
movq (%rax,%r12,8), %rsi
cmpl $0x2d, 0x8(%rsi)
jne 0x7c1e
cmpb $0x0, 0x18(%rsi)
jne 0x7c1e
testq %r14, %r14
je 0x7c06
movq (%rsi), %rax
movl 0x4(%r14), %ecx
cmpq %rcx, %rax
jae 0x7c06
movq 0x8(%r14), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jb 0x7c1e
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x7c4d
cmpl $-0x1, %eax
cmovel %eax, %r13d
incq %r12
jmp 0x7bc3
cmpl $-0x1, %r13d
jne 0x7c33
movq %rbx, %rdi
callq 0x29c6
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2351
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq