LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: foreach_vector
void
foreach_vector(vector_t* vect, void (*foncteur)()) {
    if (!vect)
        { return; }
    for (size_t i = 0; i < SIZE_VECTOR(vect); ++i)
        { (*foncteur)(AT_VECTOR(vect, i)); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x23b9
jmp 0x23f4
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x23f4
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rdi
movb $0x0, %al
callq *%rcx
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x23c1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: init_vector
void
init_vector(vector_t* vect, size_t size, void* (*constructor)(void)) {
    if (!vect)
        { return; }
    for (size_t i = 0; i < size; ++i)
        { PUSH_BACK_VECTOR(vect, (*constructor)()); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x241d
jmp 0x2464
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2464
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
callq *-0x18(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2070
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2425
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/vector.c
// Function: append_vector
void
append_vector(vector_t* vect, vector_t const* src_vect) {
    if (!vect || !src_vect)
        { return; }
    for (size_t i = 0; i < SIZE_VECTOR(src_vect); ++i)
        { PUSH_BACK_VECTOR(vect, AT_VECTOR(src_vect, i)); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x248e
cmpq $0x0, -0x10(%rbp)
jne 0x2490
jmp 0x24d4
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x24d4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x2070
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2498
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: make_len_buf
static buffer_t*
make_len_buf(size_t len) {
    buffer_t* buf = NEW(buffer_t, 1);
    if (!buf)
        { return (NULL); }
    buf->body = NEW(char, len);
    if (!buf->body)
        { return (NULL); }
    buf->alloc = len;
    buf->index = 0;
    memset(buf->body, 0, buf->alloc);
    return (buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0x38b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x254b
movq $0x0, -0x8(%rbp)
jmp 0x25ac
movq -0x10(%rbp), %rdi
shlq $0x0, %rdi
callq 0x38b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2576
movq $0x0, -0x8(%rbp)
jmp 0x25ac
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %esi, %esi
callq 0x10b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: dup_buffer
buffer_t*
dup_buffer(buffer_t const* buf) {
    if (!buf)
        { return (NULL); }
    buffer_t* new_buf = make_len_buf(buf->alloc);
    if (!new_buf)
        { return (NULL); }
    memcpy(new_buf->body, buf->body, buf->alloc);
    return (new_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25dd
movq $0x0, -0x8(%rbp)
jmp 0x2622
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2520
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x25ff
movq $0x0, -0x8(%rbp)
jmp 0x2622
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x1110
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: write_char_buffer
int
write_char_buffer(buffer_t* buf, char c) {
    if (extend_buffer(buf) == ERROR)
        { return (ERROR); }
    buf->body[SIZE_BUFFER(buf)] = c;
    if (c)
        { ++(buf->index); }
    return (c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26d0
cmpl $-0x1, %eax
jne 0x2689
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26bb
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
cmpb $0x0, -0x11(%rbp)
je 0x26b4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movsbl -0x11(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: extend_buffer
static int
extend_buffer(buffer_t* buf) {
    if (!buf)
        { return (ERROR); }
    if (SIZE_BUFFER(buf) + 1 >= buf->alloc) {
        size_t new_sz = round_up(SIZE_BUFFER(buf) + 1);
        char* nw_body = (char*)REALLOC(buf->body, new_sz);
        if (nw_body) {
            buf->body = nw_body;
            buf->alloc = new_sz;
            memset(buf->body + SIZE_BUFFER(buf), 0,
                                        buf->alloc - SIZE_BUFFER(buf));
        }
        else
            { return (ERROR); }
    }
    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x26ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2786
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x277f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x1, %rdi
callq 0x37d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ed0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2774
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
subq 0x10(%rax), %rdx
xorl %esi, %esi
callq 0x10b0
jmp 0x277d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2786
jmp 0x277f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: write_buffer
int
write_buffer(buffer_t* buf, char const* str) {
    if (!buf || !str)
        { return (ERROR); }
    while (*str) {
        if (write_char_buffer(buf, *str++) == ERROR)
            { return (ERROR); }
    }
    write_char_buffer(buf, '\0');
    return (strlen(str));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27ae
cmpq $0x0, -0x18(%rbp)
jne 0x27b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2804
jmp 0x27b9
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x27ed
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %esi
callq 0x2660
cmpl $-0x1, %eax
jne 0x27eb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2804
jmp 0x27b9
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2660
movq -0x18(%rbp), %rdi
callq 0x1080
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: unget_char_front_buffer
void
unget_char_front_buffer(buffer_t* buf, size_t sz) {
    if (!buf)
        { return; }
    else if (SIZE_BUFFER(buf) <= sz)
        { reset_buffer(buf); }
    else {
        buf->index -= sz;
        memmove(buf->body, buf->body + sz, SIZE_BUFFER(buf));
        memset(buf->body + SIZE_BUFFER(buf), 0, sz);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2879
jmp 0x28e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x2892
movq -0x8(%rbp), %rdi
callq 0x28f0
jmp 0x28de
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
addq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1140
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x10b0
jmp 0x28e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: reset_buffer
void
reset_buffer(buffer_t* buf) {
    if (!buf)
        { return; }
    memset(buf->body, 0, buf->alloc);
    buf->index = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2905
jmp 0x2927
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %esi, %esi
callq 0x10b0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: unget_char_back_buffer
void
unget_char_back_buffer(buffer_t* buf, size_t sz) {
    if (!buf)
        { return; }

    if (sz > SIZE_BUFFER(buf))
        { sz = SIZE_BUFFER(buf); }
    while (sz--)
        { buf->body[--(buf->index)] = '\0'; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2945
jmp 0x2997
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x295f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2961
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2997
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x10(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x10(%rdx)
movb $0x0, -0x1(%rax,%rcx)
jmp 0x2961
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: hash_buffer
int
hash_buffer(buffer_t const* buf) {
    if (!buf)
        { return (0); }
    int sum_char = 0;
    for (size_t i = 0; i < SIZE_BUFFER(buf); ++i)
        { sum_char += buf->body[i]; }
    return (sum_char);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x29b8
movl $0x0, -0x4(%rbp)
jmp 0x29fe
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x29f8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x29c7
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: move_back_buffer
void
move_back_buffer(buffer_t* dst_buff, buffer_t* src_buff, size_t size) {
    if (size > SIZE_BUFFER(src_buff))
        { size = SIZE_BUFFER(src_buff); }
    size_t start_index = SIZE_BUFFER(src_buff) - size;
    for (size_t i = start_index; i < SIZE_BUFFER(src_buff); ++i) {
        int char_at = CHAR_AT(src_buff, i);
        write_char_buffer(dst_buff, char_at);
    }
    unget_char_back_buffer(src_buff, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2a3e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2a93
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movsbl %al, %esi
callq 0x2660
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2a56
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2930
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/buffer.c
// Function: move_front_buffer
void
move_front_buffer(buffer_t* dst_buff, buffer_t* src_buff, size_t size) {
    if (size > SIZE_BUFFER(src_buff))
        { size = SIZE_BUFFER(src_buff); }
    for (size_t i = 0; i < size; ++i) {
        int char_at = CHAR_AT(src_buff, i);
        write_char_buffer(dst_buff, char_at);
    }
    unget_char_front_buffer(src_buff, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2ade
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2b1f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movsbl %al, %esi
callq 0x2660
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2ae6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2860
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: new_lexer
lexer_t*
new_lexer(int filde) {
    lexer_t* lex = NEW(lexer_t, 1);

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

    lex->filde = filde;

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

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

    return (lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x30, %edi
callq 0x38b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2b6a
movq $0x0, -0x8(%rbp)
jmp 0x2bdd
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10b0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
callq 0x2510
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x2510
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0x1, 0x28(%rax)
callq 0x1ee0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x1, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: del_lexer
void
del_lexer(lexer_t* lex) {
    if (lex) {
        del_buffer(lex->push_back);
        del_buffer(lex->last_lexeme);
        del_vector(lex->stack_state);
    }
    FREE(lex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c2a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2630
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2630
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1ff0
movq -0x8(%rbp), %rdi
callq 0x1190
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: check_present_table
bool
check_present_table(int8_t* table, int token) {
    for (size_t i = 0; table[i] != -1; ++i) {
        if (token == table[i])
            { return (true); }
    }
    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $-0x1, %eax
je 0x2c8d
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2c7d
movb $0x1, -0x1(%rbp)
jmp 0x2c91
jmp 0x2c7f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2c53
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: peek_token
int
peek_token(lexer_t* lex) {
    if (!lex)
        { return (-1); }
    if (lex->last_token == -1)
        { lex->last_token = advance_token(lex); }
    return (lex->last_token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32fc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3322
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
jne 0x3318
movq -0x10(%rbp), %rdi
callq 0x2ca0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: in_first
bool
in_first(lexer_t* lex, ...) {
    va_list args;
    va_start(args, lex);
    int token;
    while ((token = va_arg(args, int)) != -1) {
        if (token == peek_token(lex))
            { return (true); }
    }
    va_end(args);
    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x336b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x33f1
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x340e
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $-0x1, %eax
je 0x3448
movl -0x34(%rbp), %eax
movl %eax, -0x10c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32e0
movl %eax, %ecx
movl -0x10c(%rbp), %eax
cmpl %ecx, %eax
jne 0x3443
movb $0x1, -0x1(%rbp)
jmp 0x3450
jmp 0x33b6
leaq -0x30(%rbp), %rax
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: is_final_state
static size_t
is_final_state(int state, uint8_t (*final_table)[2]) {
    size_t i = 0;
    while (*final_table[i]) {
        if (*final_table[i] == state)
            { return (final_table[i][1]); }
        ++i;
    }
    return (T_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx,2)
je 0x3653
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx,2), %eax
cmpl -0xc(%rbp), %eax
jne 0x3645
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rax,%rcx,2), %eax
movq %rax, -0x8(%rbp)
jmp 0x365b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3613
movq $0x6f, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: must_look_ahead
static inline bool
must_look_ahead(int crt_state, int state) {
    if (crt_state == S_BODY_CCL && *fgfx_BODY_CCL_ahead_table[state])
        { return (true); }
    else if (crt_state == S_BODY_REGEX && *fgfx_BODY_REGEX_ahead_table[state])
        { return (true); }
    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x5, -0x8(%rbp)
jne 0x369a
movslq -0xc(%rbp), %rcx
leaq 0x1bc25(%rip), %rax     # 0x1f2b0
movzbl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
je 0x369a
movb $0x1, -0x1(%rbp)
jmp 0x36c0
cmpl $0x3, -0x8(%rbp)
jne 0x36ba
movslq -0xc(%rbp), %rcx
leaq 0x1bb85(%rip), %rax     # 0x1f230
movzbl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
je 0x36ba
movb $0x1, -0x1(%rbp)
jmp 0x36c0
jmp 0x36bc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/lexer.c
// Function: change_state
static inline void
change_state(lexer_t* lex, int last_match, bool* need_recompute) {
    int action = fgfx_action_table[last_match][lex->crt_state];
    if (action) {
        if (action & _BEGIN)
            { lex->crt_state = action ^ _BEGIN; }
        else if (action & _PUSH) {
            PUSH_BACK_VECTOR(lex->stack_state, (void*)lex->crt_state);
            lex->crt_state = action ^ _PUSH;
        }
        else {
            lex->crt_state = (size_t)BACK_VECTOR(lex->stack_state);
            POP_BACK_VECTOR(lex->stack_state);
        }
        (*need_recompute) = true; 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x1bc02(%rip), %rax     # 0x1f2f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x37c3
movl -0x1c(%rbp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x3733
movl -0x1c(%rbp), %eax
xorl $0x1000, %eax           # imm = 0x1000
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x37bc
movl -0x1c(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x3776
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x2070
movl -0x1c(%rbp), %eax
xorl $0x2000, %eax           # imm = 0x2000
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x37ba
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
subq $0x1, %rsi
callq 0x21a0
jmp 0x37bc
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: round_up
size_t
round_up(size_t size) {
    size_t close2 = 1;
    while (close2 <= size)
        { close2 <<= 1; }
    return (close2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
ja 0x37f7
movq -0x10(%rbp), %rax
shlq %rax
movq %rax, -0x10(%rbp)
jmp 0x37e0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: strjoin
char*
strjoin(char const* str1, char const* str2) {
    size_t const s1 = strlen(str1);
    size_t const s2 = strlen(str2);
    char* frame = NEW(char, s1 + s2 + 1);
    if (!frame)
        { return (NULL); }
    memcpy(frame, str1, sizeof(char) * s1);
    memcpy(frame + s1, str2, sizeof(char) * s2);
    frame[s1 + s2] = EOS;
    return (frame);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1080
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1080
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x0, %rdi
addq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x38b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3854
movq $0x0, -0x8(%rbp)
jmp 0x389a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
shlq $0x0, %rdx
callq 0x1110
movq -0x30(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
shlq $0x0, %rdx
callq 0x1110
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: pmalloc
void*
_pmalloc(size_t size) {
    if (!size)
        { size = 1; }
    void* chunk = malloc(size);
#ifndef NDEBUG
    assert(chunk);
#else
    if (!chunk) {
        errorf(0, "No enough memory for this process.");
        errno = ENOMEM;
    }
#endif
    return (chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x38cb
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38e1
jmp 0x3900
leaq 0x89e6(%rip), %rdi      # 0xc2ce
leaq 0x89b2(%rip), %rsi      # 0xc2a1
movl $0xc8, %edx
leaq 0x89b8(%rip), %rcx      # 0xc2b3
callq 0x10a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: get_filename
char const*
get_filename(char const* path) {
    char const* last = path;
    while (*path) {
        if (*path++ == '/')
            { last = path; }
    }
    return (last);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x394a
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x3948
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3920
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: readjust_index
void
readjust_index(vector_t* vect, size_t base, void(*dealloc)(void*)) {
    if (base >= SIZE_VECTOR(vect))
        { return; }
    (*dealloc)(AT_VECTOR(vect, base));
    erase_vector(vect, base);
    for (size_t i = base; i < SIZE_VECTOR(vect); ++i) {
        obj_index_t* obj = (obj_index_t*)AT_VECTOR(vect, i);
        --(obj->index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x3974
jmp 0x39db
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x39db
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x399e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: new_trans_list
trans_list_t*
new_trans_list(int input, int state, trans_list_t* tail) {
    trans_list_t* list = NEW(trans_list_t, 1);
    if (!list)
        { return (NULL); }
    list->input = input;
    list->state = state;
    list->next = tail;
    return (list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, %edi
callq 0x38b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3a21
movq $0x0, -0x8(%rbp)
jmp 0x3a48
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: size_gen_list
size_t
size_gen_list(gen_list_t const* list) {
    size_t crt_size = 0;
    while (list) {
        ++crt_size;
        list = list->next;
    }
    return (crt_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3a90
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a70
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: redirect_trans_list
void
redirect_trans_list(trans_list_t* list, int change, int base) {
    while (list) {
        if (list->state == base)
            { list->state = change; }
        else if (list->state > base)
            { --(list->state); }
        list = list->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3af5
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x3acd
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x3ae8
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x10(%rbp), %eax
jle 0x3ae6
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x3ae8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3aae
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: append_trans_list
void
append_trans_list(trans_list_t* dst, trans_list_t* src) {
    if (!dst)
        { return; }
    while (dst->next)
        { dst = dst->next; }
    dst->next = src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3b15
jmp 0x3b39
jmp 0x3b17
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3b2e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b17
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: del_node_trans_list
void
del_node_trans_list(trans_list_t** list, trans_list_t const* tnode) {
    if (!list || !*list || !tnode)
        { return; }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3b68
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3b68
cmpq $0x0, -0x10(%rbp)
jne 0x3b6a
jmp 0x3bce
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3b87
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3bc5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3bc3
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3bb6
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3bc3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3b92
jmp 0x3bc5
movq -0x10(%rbp), %rdi
callq 0x1190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: del_trans_list
void
del_trans_list(trans_list_t* list) {
    while (list) {
        trans_list_t* next = list->next;
        FREE(list);
        list = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c11
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1190
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3bec
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: trans_list_at
trans_list_t*
trans_list_at(trans_list_t* base, size_t at) {
    size_t count_index = 0;
    while (count_index < at) {
        if (!base)
            { return (NULL); }
        ++count_index;
        base = base->next;
    }
    return (base);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3c68
cmpq $0x0, -0x10(%rbp)
jne 0x3c4f
movq $0x0, -0x8(%rbp)
jmp 0x3c70
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3c34
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/tools/src/utils.c
// Function: cmp_input_trans_list
int
cmp_input_trans_list(trans_list_t const* list, int input) {
    if (!list)
        { return (-1); }
    size_t count_index = 0;
    while (list) {
        if (list->input == input)
            { return (count_index); }
        ++count_index;
        list = list->next;
    }
    return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3c9b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cdf
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3cd8
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x3cbf
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x3cdf
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3ca3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: cmp_trans_list
bool
cmp_trans_list(trans_list_t const* t1, trans_list_t const* t2) {
    while (t1 && t2) {
        if ((t1->input != t2->input) || (t1->state != t2->state))
            { return (false); }
        t1 = t1->next;
        t2 = t2->next;
    }
    return (!t1 && !t2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x3d13
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3d1c
jmp 0x3d5a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x3d3c
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
je 0x3d42
movb $0x0, -0x1(%rbp)
jmp 0x3d7b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3cfc
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1a(%rbp)
jne 0x3d73
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: contiguous_range
trans_list_t const*
contiguous_range(trans_list_t const* t) {
    while (t && t->next) {
        if (((t->input - 1) != (t->next->input))
                || (t->state != t->next->state))
            { break;  }
        t = t->next;
    }
    return (t); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x3db2
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x3dbb
jmp 0x3df3
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jne 0x3de4
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
je 0x3de6
jmp 0x3df3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3d98
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: hash_str
size_t
hash_str(char const* str) {
    size_t posc = EOS;
    while (*str)
        { posc += *(str++); }
    return (posc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3e36
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbq (%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3e10
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: open_new_file
int
open_new_file(char const* path_name) {
    int filde = open(path_name, O_WRONLY | O_CREAT | O_EXCL, 0644);
    if ((filde == -1) && (EEXIST == errno))
        { filde = open(path_name, O_WRONLY | O_TRUNC); }
    return (filde);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xc1, %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x1150
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x3ebe
callq 0x1030
movq %rax, %rcx
movl $0x11, %eax
cmpl (%rcx), %eax
jne 0x3ebe
movq -0x8(%rbp), %rdi
movl $0x201, %esi            # imm = 0x201
movb $0x0, %al
callq 0x1150
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/utils.c
// Function: prealloc
void*
_prealloc(void* ptr, size_t size) {
    if (!size) {
        FREE(ptr);
        return (NULL);
    }
    void* new_chunk = realloc(ptr, size);
#ifndef NDEBUG
    assert(new_chunk);
#else
    if (!chunck) {
        errorf(0, "The reallocation has failed.\n");
        errno = ENOMEM;
    }
#endif
    return (new_chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3efa
movq -0x10(%rbp), %rdi
callq 0x1190
movq $0x0, -0x8(%rbp)
jmp 0x3f3b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3f14
jmp 0x3f33
leaq 0x83af(%rip), %rdi      # 0xc2ca
leaq 0x837f(%rip), %rsi      # 0xc2a1
movl $0xda, %edx
leaq 0x83a6(%rip), %rcx      # 0xc2d4
callq 0x10a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/gen.c
// Function: min_size_type
uint8_t
min_size_type(size_t size, bool unsign) {
    if ((unsign && size <= UCHAR_MAX) || (!unsign && size <= SCHAR_MAX))
        { return (BYTE); }
    else if ((unsign && size > UCHAR_MAX && size <= USHRT_MAX)
            || (!unsign && size > SCHAR_MAX && size <= SHRT_MAX))
        { return (SHORT); }
    return (LONG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x3f70
cmpq $0xff, -0x10(%rbp)
jbe 0x3f7d
testb $0x1, -0x11(%rbp)
jne 0x3f83
cmpq $0x7f, -0x10(%rbp)
ja 0x3f83
movb $0x8, -0x1(%rbp)
jmp 0x3fc0
testb $0x1, -0x11(%rbp)
je 0x3f9d
cmpq $0xff, -0x10(%rbp)
jbe 0x3f9d
cmpq $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jbe 0x3fb4
testb $0x1, -0x11(%rbp)
jne 0x3fba
cmpq $0x7f, -0x10(%rbp)
jbe 0x3fba
cmpq $0x7fff, -0x10(%rbp)    # imm = 0x7FFF
ja 0x3fba
movb $0x10, -0x1(%rbp)
jmp 0x3fc0
jmp 0x3fbc
movb $0x20, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/gen.c
// Function: gen_include_macro
void
gen_include_macro(int filde, char const* header) {
    write(filde, SEP, 1);
    while (*header) {
        char c;
        if (isalnum(*header))
            { c = toupper(*header); }
        else
            { c = '_'; }    
        write(filde, &c, 1);
        ++header;
    }
    dprintf(filde, SEP HEADER_SUF SEP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq 0x830d(%rip), %rsi      # 0xc2f6
movl $0x1, %edx
callq 0x1070
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x404e
callq 0x1180
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x402b
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x1040
movb %al, -0x11(%rbp)
jmp 0x402f
movb $0x5f, -0x11(%rbp)
movl -0x4(%rbp), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x1070
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3ff3
movl -0x4(%rbp), %edi
leaq 0x829c(%rip), %rsi      # 0xc2f4
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/gen.c
// Function: gen_require_macro
void
gen_require_macro(int filde, char const* header) {
    dprintf(filde, "#ifndef ");
    gen_include_macro(filde, header);
    dprintf(filde, NL "#define ");
    gen_include_macro(filde, header);
    dprintf(filde, NL NL);
    dprintf(filde, INCLUDE_SYS(stdint.h) NL);
    dprintf(filde, INCLUDE_SYS(stdbool.h) NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq 0x826f(%rip), %rsi      # 0xc2f8
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x3fd0
movl -0x4(%rbp), %edi
leaq 0x825b(%rip), %rsi      # 0xc301
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x3fd0
movl -0x4(%rbp), %edi
leaq 0x8c7d(%rip), %rsi      # 0xcd40
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x8237(%rip), %rsi      # 0xc30b
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
leaq 0x823b(%rip), %rsi      # 0xc320
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/gen.c
// Function: gen_verbatim_file
void
gen_verbatim_file(int filde, char const* header) {
    if (isdigit(*header))
        { write(filde, "_", 1); }
    while (*header && (isalnum(*header) || (*header == '_')))
        { write(filde, header++, 1); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1180
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x4193
movl -0x4(%rbp), %edi
leaq 0x816d(%rip), %rsi      # 0xc2f6
movl $0x1, %edx
callq 0x1070
jmp 0x4195
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x41df
callq 0x1180
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x41d9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x41e8
jmp 0x4206
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edx
callq 0x1070
jmp 0x4195
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/tools/src/error.c
// Function: print_error
static void
print_error(size_t lineno, char const* label, char const* color,
                                char const* format, va_list args) {
    // Color Output
    int tty = isatty(STDERR_FILENO);
    if (tty)
        { fprintf(stderr, "%s", color); }
    fprintf(stderr, "(%s", label);
    if (lineno)
        { fprintf(stderr, ":%zu", lineno); }
    fprintf(stderr, ") ");
    vfprintf(stderr, format, args);
    fprintf(stderr, "\n");
    if (tty)
        { fprintf(stderr, NO_COLOR); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x2, %edi
callq 0x1060
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x430b
movq 0xcd02(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x805e(%rip), %rsi      # 0xc362
movb $0x0, %al
callq 0x1100
movq 0xcce6(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x8041(%rip), %rsi      # 0xc361
movb $0x0, %al
callq 0x1100
cmpq $0x0, -0x8(%rbp)
je 0x434a
movq 0xccc3(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x8022(%rip), %rsi      # 0xc365
movb $0x0, %al
callq 0x1100
movq 0xcca7(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x800f(%rip), %rsi      # 0xc36a
movb $0x0, %al
callq 0x1100
movq 0xcc8f(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1160
movq 0xcc78(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x8a84(%rip), %rsi      # 0xce0e
movb $0x0, %al
callq 0x1100
cmpl $0x0, -0x2c(%rbp)
je 0x43af
movq 0xcc5a(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x7fc5(%rip), %rsi      # 0xc36d
movb $0x0, %al
callq 0x1100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/fgfp.c
// Function: main
int main(int argc, char* argv[]) {
	if (argc <= 1)
		{ return (EXIT_FAILURE); }

	int filde = open(argv[1], O_RDONLY);
	if (filde == -1) {
		errorf(0, "Can't open %s.", argv[1]);
		return (EXIT_FAILURE);
	}

	cfg_t* cfg = parse_cfg(filde);
	if (!cfg)
		{ return (EXIT_FAILURE); }

	augment_grammar(cfg);
	if (cfg_sanity_check(cfg) == ERROR) {
		del_cfg(cfg);
		return (EXIT_FAILURE);
	}

//	print_production(cfg);
	int exit_st = gen_fgfp_file(cfg, get_filename(argv[1]));

#if 0

	print_production(cfg);
	print_non_terminal(cfg);
	print_nullable(cfg);
	print_first_set(cfg);
	print_follow_set(cfg);

#endif	

	del_cfg(cfg);

	if (close(filde) == -1) {
		errorf(0, "Can't close %s.", argv[1]);
		return (EXIT_FAILURE);
	}

	return (exit_st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x4498
movl $0x1, -0x4(%rbp)
jmp 0x4583
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1150
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x44d8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x7ead(%rip), %rsi      # 0xc372
movb $0x0, %al
callq 0x4210
movl $0x1, -0x4(%rbp)
jmp 0x4583
movl -0x14(%rbp), %edi
callq 0x49a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x44f7
movl $0x1, -0x4(%rbp)
jmp 0x4583
movq -0x20(%rbp), %rdi
callq 0x4a60
movq -0x20(%rbp), %rdi
callq 0x4d00
cmpl $-0x1, %eax
jne 0x4520
movq -0x20(%rbp), %rdi
callq 0x4820
movl $0x1, -0x4(%rbp)
jmp 0x4583
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3910
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4590
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4820
movl -0x14(%rbp), %edi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x457d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x7e14(%rip), %rsi      # 0xc381
movb $0x0, %al
callq 0x4210
movl $0x1, -0x4(%rbp)
jmp 0x4583
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)