LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tyabu12[P]pl0compiler/getSource.c
// Function: printcToken
void printcToken() {            /* 現在のトークンの印字                 */
    int i = (int)cToken.kind;
    if (printed){
        printed = 0; return;
    }
    printed = 1;
    printSpaces();              /* トークンの前の空白や改行印字         */
    if (i < end_of_KeyWd)       /* 予約語                               */
        fprintf(fphtml, "<b>%s</b>", KeyWdT[i].word);
    else if (i < end_of_KeySym) /* 演算子か区切り記号                   */
        fprintf(fphtml, "%s", KeyWdT[i].word);
    else if (i == (int)Id) {    /* Identfier                            */
        switch (idKind) {
        case varId:
            fprintf(fphtml, "%s", cToken.u.id); return;
        case parId:
            fprintf(fphtml, "<i>%s</i>", cToken.u.id); return;
        case funcId:
            fprintf(fphtml, "<i>%s</i>", cToken.u.id); return;
        case constId:
            fprintf(fphtml, "<tt>%s</tt>", cToken.u.id); return;
        }
    } else if (i == (int)Num)   /* Num                                  */
        fprintf(fphtml, "%d", cToken.u.value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x5f4e(%rip), %eax      # 0xaf7c
movl %eax, -0x4(%rbp)
cmpl $0x0, 0x5f40(%rip)      # 0xaf78
je 0x5049
movl $0x0, 0x5f34(%rip)      # 0xaf78
jmp 0x51a8
movl $0x1, 0x5f25(%rip)      # 0xaf78
callq 0x4fa0
cmpl $0xe, -0x4(%rbp)
jge 0x508d
movq 0x5f03(%rip), %rdi      # 0xaf68
movslq -0x4(%rbp), %rcx
leaq 0x4060(%rip), %rax      # 0x90d0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x14d6(%rip), %rsi      # 0x6557
movb $0x0, %al
callq 0x20d0
jmp 0x51a8
cmpl $0x1f, -0x4(%rbp)
jge 0x50c2
movq 0x5ece(%rip), %rdi      # 0xaf68
movslq -0x4(%rbp), %rcx
leaq 0x402b(%rip), %rax      # 0x90d0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x14ab(%rip), %rsi      # 0x6561
movb $0x0, %al
callq 0x20d0
jmp 0x51a6
cmpl $0x20, -0x4(%rbp)
jne 0x5181
movl 0x62de(%rip), %eax      # 0xb3b0
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x517f
movq -0x10(%rbp), %rax
leaq 0x1249(%rip), %rcx      # 0x6334
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x5e6d(%rip), %rdi      # 0xaf68
leaq 0x145f(%rip), %rsi      # 0x6561
leaq 0x5e73(%rip), %rdx      # 0xaf7c
addq $0x4, %rdx
movb $0x0, %al
callq 0x20d0
jmp 0x51a8
movq 0x5e48(%rip), %rdi      # 0xaf68
leaq 0x143d(%rip), %rsi      # 0x6564
leaq 0x5e4e(%rip), %rdx      # 0xaf7c
addq $0x4, %rdx
movb $0x0, %al
callq 0x20d0
jmp 0x51a8
movq 0x5e26(%rip), %rdi      # 0xaf68
leaq 0x141b(%rip), %rsi      # 0x6564
leaq 0x5e2c(%rip), %rdx      # 0xaf7c
addq $0x4, %rdx
movb $0x0, %al
callq 0x20d0
jmp 0x51a8
movq 0x5e04(%rip), %rdi      # 0xaf68
leaq 0x1403(%rip), %rsi      # 0x656e
leaq 0x5e0a(%rip), %rdx      # 0xaf7c
addq $0x4, %rdx
movb $0x0, %al
callq 0x20d0
jmp 0x51a8
jmp 0x51a4
cmpl $0x21, -0x4(%rbp)
jne 0x51a2
movq 0x5dda(%rip), %rdi      # 0xaf68
movl 0x5dec(%rip), %edx      # 0xaf80
leaq 0xfcd(%rip), %rsi       # 0x6168
movb $0x0, %al
callq 0x20d0
jmp 0x51a4
jmp 0x51a6
jmp 0x51a8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/interpreter.c
// Function: print_version
static void print_version(char*interpreter_name)
{
    fprintf(stderr, "%s\n", interpreter_name);
    fprintf(stderr, "GCI V0.1\n");
    fprintf(stderr, "GCI is interpreter of tiny JavaScript-like language with garbage collector and objects.\n");
    fprintf(stderr, "It supports JavaScript-like objects, numbers, if-else-stmts and while loops.\n");
    fprintf(stderr, "Functionality:\n");
    fprintf(stderr, "  - lexer;\n");
    fprintf(stderr, "  - parser;\n");
    fprintf(stderr, "  - bytecode generator;\n");
    fprintf(stderr, "  - vm;\n");
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1da2d(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x170de(%rip), %rsi     # 0x186af
movb $0x0, %al
callq 0x1100
movq 0x1da11(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16a98(%rip), %rsi     # 0x18081
movb $0x0, %al
callq 0x1100
movq 0x1d9f9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16a8a(%rip), %rsi     # 0x1808b
movb $0x0, %al
callq 0x1100
movq 0x1d9e1(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16acb(%rip), %rsi     # 0x180e4
movb $0x0, %al
callq 0x1100
movq 0x1d9c9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16b01(%rip), %rsi     # 0x18132
movb $0x0, %al
callq 0x1100
movq 0x1d9b1(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16af9(%rip), %rsi     # 0x18142
movb $0x0, %al
callq 0x1100
movq 0x1d999(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16aed(%rip), %rsi     # 0x1814e
movb $0x0, %al
callq 0x1100
movq 0x1d981(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16ae2(%rip), %rsi     # 0x1815b
movb $0x0, %al
callq 0x1100
movq 0x1d969(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x16ae3(%rip), %rsi     # 0x18174
movb $0x0, %al
callq 0x1100
xorl %edi, %edi
callq 0x1170
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/utils/utils.c
// Function: file_open
FILE*file_open(const char*fname, const char*mode)
{
    if (strcmp(fname, "stdin") == 0) {
        return stdin;
    } else if (strcmp(fname, "stdout") == 0) {
        return stdout;
    } else if (strcmp(fname, "stderr") == 0) {
        return stderr;
    } else {
        FILE*f = fopen(fname, mode);
        if (f == NULL) {
            fprintf(stderr, "Unable to open file \"%s\" with mode \"%s\"",
                    fname, mode);
            exit(EXIT_FAILURE);
        }
        return f;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x16780(%rip), %rsi     # 0x1837b
callq 0x10f0
cmpl $0x0, %eax
jne 0x1c18
movq 0x1d3bc(%rip), %rax     # 0x1efc8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1cac
movq -0x10(%rbp), %rdi
leaq 0x16406(%rip), %rsi     # 0x18029
callq 0x10f0
cmpl $0x0, %eax
jne 0x1c3d
movq 0x1d38c(%rip), %rax     # 0x1efc0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1cac
movq -0x10(%rbp), %rdi
leaq 0x16739(%rip), %rsi     # 0x18381
callq 0x10f0
cmpl $0x0, %eax
jne 0x1c62
movq 0x1d397(%rip), %rax     # 0x1eff0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1cac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ca4
movq 0x1d36f(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x166f5(%rip), %rsi     # 0x18388
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
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/masyagin1998[P]GCI/src/lexer/lexer.c
// Function: lexer_conf_from_file
void lexer_conf_from_file(lexer_type_t lexer, const char*fname)
{
    FILE*f;

    size_t read;
    
    strncpy(lexer->program_name, fname, sizeof(lexer->program_name));

    if (strcmp(fname, "stdin") == 0) {
        f = stdin;
    } else {
        f = file_open(fname, "r");
    }

    fseek(f, 0, SEEK_END);
    lexer->program_len = ftell(f);
    fseek(f, 0, SEEK_SET);

    SAFE_MALLOC(lexer->program, lexer->program_len + 1);

    read = fread(lexer->program, sizeof(char), lexer->program_len, f);
    if (read != lexer->program_len) {
        fprintf(stderr, "Unable to read input file \"%s\"", fname);
        exit(EXIT_FAILURE);
    }
    lexer->program[lexer->program_len] = '\0';

    lexer->cur.program = lexer->program;
    lexer->cur.program_len = lexer->program_len;

    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x1040
movq -0x10(%rbp), %rdi
leaq 0x1661a(%rip), %rsi     # 0x1837b
callq 0x10f0
cmpl $0x0, %eax
jne 0x1d7b
movq 0x1d256(%rip), %rax     # 0x1efc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1d8f
movq -0x10(%rbp), %rdi
leaq 0x1699b(%rip), %rsi     # 0x18721
callq 0x1be0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1140
movq -0x18(%rbp), %rdi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1130
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1e24
movq 0x1d203(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
addq $0x1, %r8
shlq $0x0, %r8
leaq 0x16807(%rip), %rsi     # 0x1860e
leaq 0x167ee(%rip), %rdx     # 0x185fc
movl $0x44, %ecx
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x1e26
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x1050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x1e7b
movq 0x1d194(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x167c8(%rip), %rsi     # 0x18632
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x18(%rbp), %rdi
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/lexer.c
// Function: lexer_conf_from_buf
void lexer_conf_from_buf(lexer_type_t lexer, const char*text, const char*program_name)
{
    strncpy(lexer->program_name, program_name, sizeof(lexer->program_name));

    lexer->program_len = strlen(text);

    SAFE_MALLOC(lexer->program, lexer->program_len + 1);

    strncpy(lexer->program, text, lexer->program_len + 1);
    lexer->program[lexer->program_len] = '\0';

    lexer->cur.program = lexer->program;
    lexer->cur.program_len = lexer->program_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1130
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1f6e
movq 0x1d0b9(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
addq $0x1, %r8
shlq $0x0, %r8
leaq 0x166bd(%rip), %rsi     # 0x1860e
leaq 0x166a4(%rip), %rdx     # 0x185fc
movl $0x59, %ecx
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
jmp 0x1f70
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x1, %rdx
callq 0x1040
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x118(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/lexer.c
// Function: dump_lexer_to_xml_file
void dump_lexer_to_xml_file(FILE*f, lexer_type_t lexer)
{
    struct TOKEN*tok;
    char tmp_str[4096];

    fprintf(f, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
    fprintf(f, "<tokens>\n");

    lexer_next_token(lexer, &tok);
    while (tok->token_type != TOKEN_TYPE_EOF) {
        token_to_xml_string(tok, tmp_str, sizeof(tmp_str));
        fprintf(f, "\t%s\n", tmp_str);
        token_free(tok);
        lexer_next_token(lexer, &tok);
    }
    token_free(tok);

    fprintf(f, "</tokens>\n");        
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x15d1e(%rip), %rsi     # 0x1867c
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0x15d34(%rip), %rsi     # 0x186a4
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1fd0
movq -0x18(%rbp), %rax
cmpl $0x26, (%rax)
je 0x29d3
movq -0x18(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2f60
movq -0x8(%rbp), %rdi
leaq -0x1020(%rbp), %rdx
leaq 0x15cfa(%rip), %rsi     # 0x186ae
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rdi
callq 0x31b0
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1fd0
jmp 0x2984
movq -0x18(%rbp), %rdi
callq 0x31b0
movq -0x8(%rbp), %rdi
leaq 0x15ccc(%rip), %rsi     # 0x186b3
movb $0x0, %al
callq 0x1100
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/token.c
// Function: token_read_keyword
void token_read_keyword(struct TOKEN**tok, const struct POS*pos, enum TOKEN_TYPE tok_type, const char*keyword, size_t keyword_len)
{
    struct TOKEN*new_tok;
    struct POS p = (*pos);
    size_t i;

    PREFIX_UNUSED(keyword);
    
    new_tok = create_token();

    new_tok->token_type = tok_type;
    new_tok->group_type = GROUP_TYPE_KEYWORDS;

    i = 0;
    while (i != keyword_len) {
        p = pos_next(&p);
        i++;
    }

    new_tok->frag.starting = (*pos);
    new_tok->frag.following = p;

    (*tok) = new_tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x28, %edx
callq 0x1120
callq 0x2a40
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rax)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x2b42
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x34a0
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x2b05
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x28, %rdi
leaq -0x58(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/token.c
// Function: token_read_number
int token_read_number(struct TOKEN**tok, const struct POS*pos)
{
    enum LEXER_CODES r = LEXER_OK;
    
    struct TOKEN*new_tok;
    struct POS p = (*pos);
    
    new_tok = create_token();

    new_tok->token_type = TOKEN_TYPE_NUMBER;
    new_tok->group_type = GROUP_TYPE_NUMBERS;

    while (pos_is_digit(&p)) {
        p = pos_next(&p);
    }
    if (pos_get_code(&p) == '.') {
        r = LEXER_INVALID_TOKEN;
        p = pos_next(&p);
        while (pos_is_digit(&p)) {
            r = LEXER_OK;
            p = pos_next(&p);
        }
    }

    new_tok->frag.starting = (*pos);
    new_tok->frag.following = p;

    char tmp_str[64];
    snprintf(tmp_str, sizeof(tmp_str),
             "%.*s",
             (int) (new_tok->frag.following.index - new_tok->frag.starting.index),
             new_tok->frag.starting.program + new_tok->frag.starting.index);

    new_tok->int_val = atoll(tmp_str);

    (*tok) = new_tok;

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movl $0x28, %edx
callq 0x1120
callq 0x2a40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1d, (%rax)
movq -0x20(%rbp), %rax
movl $0x2, 0x4(%rax)
leaq -0x48(%rbp), %rdi
callq 0x3310
cmpl $0x0, %eax
je 0x2c09
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x34a0
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
jmp 0x2bda
leaq -0x48(%rbp), %rdi
callq 0x3270
cmpl $0x2e, %eax
jne 0x2c81
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x34a0
leaq -0x48(%rbp), %rdi
leaq -0x98(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
leaq -0x48(%rbp), %rdi
callq 0x3310
cmpl $0x0, %eax
je 0x2c7f
movl $0x0, -0x14(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x34a0
leaq -0x48(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
jmp 0x2c43
jmp 0x2c81
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
addq $0x28, %rdi
leaq -0x48(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
leaq -0x100(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x28(%rcx), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x20(%rbp), %rax
addq 0x28(%rax), %r8
movl $0x40, %esi
leaq 0x15a00(%rip), %rdx     # 0x186e6
movb $0x0, %al
callq 0x10a0
leaq -0x100(%rbp), %rdi
callq 0x10e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/token.c
// Function: token_read_ident
void token_read_ident(struct TOKEN**tok,  const struct POS*pos)
{
    struct TOKEN*new_tok;
    struct POS p = (*pos);
    
    new_tok = create_token();

    new_tok->token_type = TOKEN_TYPE_IDENT;
    new_tok->group_type = GROUP_TYPE_IDENTS;

    while (pos_is_digit(&p) || pos_is_letter(&p)) {
        p = pos_next(&p);
    }    

    new_tok->frag.starting = (*pos);
    new_tok->frag.following = p;

    snprintf(new_tok->str_val, sizeof(new_tok->str_val),
             "%.*s",
             (int) (new_tok->frag.following.index - new_tok->frag.starting.index),
             new_tok->frag.starting.program + new_tok->frag.starting.index);

    (*tok) = new_tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
callq 0x1120
callq 0x2a40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xc, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
leaq -0x40(%rbp), %rdi
callq 0x3310
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x69(%rbp)
jne 0x2d87
leaq -0x40(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
setne %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x2d90
jmp 0x2db1
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x34a0
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
jmp 0x2d60
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x28(%rcx), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x18(%rbp), %rax
addq 0x28(%rax), %r8
movl $0x20, %esi
leaq 0x158cf(%rip), %rdx     # 0x186e6
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/token.c
// Function: token_read_op
void token_read_op(struct TOKEN**tok, enum TOKEN_TYPE tok_type, const struct POS*starting, const struct POS*following)
{
    struct TOKEN*new_tok = create_token();

    new_tok->token_type = tok_type;
    new_tok->group_type = GROUP_TYPE_OPS;
    new_tok->frag.starting = (*starting);
    new_tok->frag.following = (*following);

    (*tok) = new_tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x2a40
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/token.c
// Function: token_read_unknown
void token_read_unknown(struct TOKEN**tok, const struct POS*pos)
{
    struct TOKEN*new_tok;
    struct POS p = (*pos);

    new_tok = create_token();

    while (pos_is_unknown(&p)) {
        p = pos_next(&p);
    }

    new_tok->token_type = TOKEN_TYPE_UNKNOWN;
    new_tok->group_type = GROUP_TYPE_AUX;
    new_tok->frag.starting = (*pos);
    new_tok->frag.following = p;

    (*tok) = new_tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
callq 0x1120
callq 0x2a40
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33d0
cmpl $0x0, %eax
je 0x2f0a
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x34a0
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
jmp 0x2edb
movq -0x18(%rbp), %rax
movl $0x27, (%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x4(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/pos.c
// Function: pos_is_newline
__inline__ int pos_is_newline(const struct POS*pos)
{
    if ((pos->program[pos->index] == '\r') &&
        (pos->index + 1 < pos->program_len)) {
        return (pos->program[pos->index + 1] == '\n');
    }

    return (pos->program[pos->index] == '\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x32ea
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x32ea
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x330b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/pos.c
// Function: pos_is_unknown
int pos_is_unknown(const struct POS*pos)
{
    size_t i;
    const char symbols[] = { '|', '&', '=', '!', '<', '>', '+', '-', '*', '/', '%', '(', ')', '{', '}', ',', ';', '.', ':' };
    
    if (pos_is_whitespace(pos) || pos_is_newline(pos) || pos_is_digit(pos) || pos_is_letter(pos)) {
        return 0;
    }

    for (i = 0; i < sizeof(symbols) / sizeof(char); i++) {
        if (symbols[i] == pos_get_code(pos)) {
            return 0;
        }
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1534d(%rip), %rax     # 0x18730
movq %rax, -0x30(%rbp)
movq 0x1534a(%rip), %rax     # 0x18738
movq %rax, -0x28(%rbp)
movw 0x15347(%rip), %ax      # 0x18740
movw %ax, -0x20(%rbp)
movb 0x1533f(%rip), %al      # 0x18742
movb %al, -0x1e(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3220
cmpl $0x0, %eax
jne 0x343e
movq -0x10(%rbp), %rdi
callq 0x3290
cmpl $0x0, %eax
jne 0x343e
movq -0x10(%rbp), %rdi
callq 0x3310
cmpl $0x0, %eax
jne 0x343e
movq -0x10(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
je 0x3447
movl $0x0, -0x4(%rbp)
jmp 0x3494
movq $0x0, -0x18(%rbp)
cmpq $0x13, -0x18(%rbp)
jae 0x348d
movq -0x18(%rbp), %rax
movsbl -0x30(%rbp,%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3270
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jne 0x347d
movl $0x0, -0x4(%rbp)
jmp 0x3494
jmp 0x347f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x344f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/pos.c
// Function: pos_next
struct POS pos_next(const struct POS*pos)
{
    size_t new_line = pos->line;
    size_t new_pos = pos->pos;
    size_t new_index = pos->index;

    if (!pos_is_eof(pos)) {
        if (pos_is_newline(pos)) {
            new_line++;
            new_pos = 1;
        } else {
            new_pos++;
        }
        new_index++;
    }

    return (struct POS) {
        .program     = pos->program,
        .program_len = pos->program_len,
        .line        = new_line,
        .pos         = new_pos,    
        .index       = new_index,
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
cmpl $0x0, %eax
jne 0x3522
movq -0x8(%rbp), %rdi
callq 0x3290
cmpl $0x0, %eax
je 0x350a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
jmp 0x3516
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq (%rdx), %rdx
movq %rdx, (%rcx)
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rcx)
movq -0x10(%rbp), %rdx
movq %rdx, 0x10(%rcx)
movq -0x18(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq -0x20(%rbp), %rdx
movq %rdx, 0x20(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/lexer/pos.c
// Function: pos_check_keyword
int pos_check_keyword(const struct POS*pos, const char*keyword, size_t keyword_len)
{
    size_t i = 0;

    struct POS p = (*pos);

    while (i != keyword_len) {
        if (keyword[i] != pos_get_code(&p)) {
            return 0;
        }
        p = pos_next(&p);
        i++;
    }

    if (!pos_is_letter(&p) && !pos_is_digit(&p)) {
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x28, %edx
callq 0x1120
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x35f2
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3270
movl %eax, %ecx
movl -0x7c(%rbp), %eax
cmpl %ecx, %eax
je 0x35c5
movl $0x0, -0x4(%rbp)
jmp 0x361e
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x34a0
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x28, %edx
callq 0x1120
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3591
leaq -0x50(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
jne 0x3617
leaq -0x50(%rbp), %rdi
callq 0x3310
cmpl $0x0, %eax
jne 0x3617
movl $0x1, -0x4(%rbp)
jmp 0x361e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: parser_parse
enum PARSER_CODES parser_parse(parser_type_t parser, struct UNIT_AST**unit)
{
    enum PARSER_CODES r;
    lexer_next_token(parser->lexer, &(parser->tok));
    r = unit_ast_read(parser, unit);
    token_free(parser->tok);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3710
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: print_parser_error
void print_parser_error(const struct PARSER_ERROR*err)
{
    size_t i;
    
    char tmp[128];

    token_type_to_str(err->get_tok, tmp, sizeof(tmp));
    fprintf(stderr, "%zu:%zu: error: invalid token: \"%s\"; expected tokens: ",
            err->line, err->pos, tmp);

    i = 0;
    while (err->exp_toks[i] != TOKEN_TYPE_EOF) {
        token_type_to_str(err->exp_toks[i], tmp, sizeof(tmp));        
        fprintf(stderr, "\"%s\" ", tmp);
        i++;
    }

    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edi
leaq -0x90(%rbp), %rsi
movl $0x80, %edx
callq 0x3960
movq 0x1b242(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
leaq -0x90(%rbp), %r8
leaq 0x14b89(%rip), %rsi     # 0x18958
movb $0x0, %al
callq 0x1100
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpl $0x26, (%rax,%rcx,4)
je 0x3e35
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
leaq -0x90(%rbp), %rsi
movl $0x80, %edx
callq 0x3960
movq 0x1b1e1(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq -0x90(%rbp), %rdx
leaq 0x14b6f(%rip), %rsi     # 0x1898f
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3dde
movq 0x1b1b4(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
leaq 0x15ca8(%rip), %rsi     # 0x19aee
movb $0x0, %al
callq 0x1100
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: set_parser_error
static void set_parser_error(struct PARSER*parser, size_t n, ...)
{
    size_t i;
    
    va_list args;
    va_start(args, n);
    for (i = 0; i < n; i++) {
        parser->err.exp_toks[i] = va_arg(args, enum TOKEN_TYPE);
    }
    va_end(args);
    parser->err.exp_toks[n] = TOKEN_TYPE_EOF;
    parser->err.get_tok = (parser->tok)->token_type;
    parser->err.line = (parser->tok)->frag.starting.line;
    parser->err.pos = (parser->tok)->frag.starting.pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
testb %al, %al
je 0x4068
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4140
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x40fd
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x411a
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x40b8
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x26, 0x10(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x60(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: ident_ast_read
static enum PARSER_CODES ident_ast_read(struct PARSER*parser, struct IDENT_AST**ident)
{
    enum PARSER_CODES r;
    
    if ((parser->tok)->token_type != TOKEN_TYPE_IDENT) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_IDENT);
        goto err0;
    }
    
    (*ident) = create_ident_ast((parser->tok)->str_val,
                                (parser->tok)->frag.starting.line,
                                (parser->tok)->frag.starting.pos);

    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    return PARSER_OK;

 err0:
    (*ident) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xc, (%rax)
je 0x41cb
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0xc, %edx
movb $0x0, %al
callq 0x4030
jmp 0x4228
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdx
callq 0xd670
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movl $0x0, -0x4(%rbp)
jmp 0x4239
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%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/masyagin1998[P]GCI/src/parser/parser.c
// Function: function_call_ast_read
static enum PARSER_CODES function_call_ast_read(struct PARSER*parser, struct FUNCTION_CALL_AST**function_call, struct IDENT_AST*function_name)
{
    enum PARSER_CODES r;

    struct ARGS_LIST_AST*args_list = NULL;

    if ((parser->tok)->token_type != TOKEN_TYPE_LPAREN) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_LPAREN);
        goto err0;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    if ((parser->tok)->token_type != TOKEN_TYPE_RPAREN) {
        r = args_list_ast_read(parser, &args_list);
        if (r != PARSER_OK) {
            goto err0;
        }
    }

    if ((parser->tok)->token_type != TOKEN_TYPE_RPAREN) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_RPAREN);
        goto err1;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));    
    
    (*function_call) = create_function_call_ast(function_name, args_list,
                                                (parser->tok)->frag.starting.line,
                                                (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    if (args_list != NULL) {
        args_list_ast_free(args_list);
    }
 err0:
    (*function_call) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1b, (%rax)
je 0x4e7a
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1b, %edx
movb $0x0, %al
callq 0x4030
jmp 0x4f5b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1c, (%rax)
je 0x4ec5
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6030
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4ec3
jmp 0x4f5b
jmp 0x4ec5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1c, (%rax)
je 0x4ef0
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1c, %edx
movb $0x0, %al
callq 0x4030
jmp 0x4f49
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
callq 0xd360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4f6c
cmpq $0x0, -0x30(%rbp)
je 0x4f59
movq -0x30(%rbp), %rdi
callq 0xb840
jmp 0x4f5b
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: assignment_expr_ast_read
static enum PARSER_CODES assignment_expr_ast_read(struct PARSER*parser, struct ASSIGNMENT_EXPR_AST**assignment_expr)
{
    enum PARSER_CODES r;

    switch ((parser->tok)->token_type) {
    case TOKEN_TYPE_LBRACE: {
        struct OBJECT_LITERAL_AST*object_literal;
        r = object_literal_ast_read(parser, &object_literal);
        if (r != PARSER_OK) {
            goto err0;
        }
        (*assignment_expr) = create_assignment_expr_ast(object_literal, AST_ASSIGNMENT_EXPR_TYPE_OBJECT_LITERAL);
        break;
    }
    case TOKEN_TYPE_LBRACKET: {
        struct ARRAY_LITERAL_AST*array_literal;
        r = array_literal_ast_read(parser, &array_literal);
        if (r != PARSER_OK) {
            goto err0;
        }
        (*assignment_expr) = create_assignment_expr_ast(array_literal, AST_ASSIGNMENT_EXPR_TYPE_ARRAY_LITERAL);
        break;
    }
    default: {
        struct LOGICAL_OR_EXPR_AST*logical_or_expr;
        r = logical_or_expr_ast_read(parser, &logical_or_expr);
        if (r != PARSER_OK) {
            goto err0;
        }
        (*assignment_expr) = create_assignment_expr_ast(logical_or_expr, AST_ASSIGNMENT_EXPR_TYPE_LOGICAL_OR_EXPR);
        break;
    }
    }

    return PARSER_OK;

 err0:
    (*assignment_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x1e, %eax
je 0x51f0
jmp 0x51b4
movl -0x3c(%rbp), %eax
subl $0x20, %eax
jne 0x5222
jmp 0x51be
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8180
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x51d9
jmp 0x525b
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xaea0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5252
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8440
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5208
jmp 0x525b
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xaea0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5252
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x64c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x523a
jmp 0x525b
movq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0xaea0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x526c
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: break_stmt_ast_read
static enum PARSER_CODES break_stmt_ast_read(struct PARSER*parser, struct BREAK_STMT_AST**break_stmt)
{
    enum PARSER_CODES r;

    size_t line;
    size_t pos;
    
    if ((parser->tok)->token_type != TOKEN_TYPE_BREAK) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_BREAK);
        goto err0;
    }
    line = (parser->tok)->frag.starting.line;
    pos = (parser->tok)->frag.starting.pos;
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    if ((parser->tok)->token_type != TOKEN_TYPE_SEMI) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_SEMI);
        goto err0;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    (*break_stmt) = create_break_stmt_ast(line, pos);

    return PARSER_OK;

 err0:
    (*break_stmt) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x5, (%rax)
je 0x582e
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
movb $0x0, %al
callq 0x4030
jmp 0x58db
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x23, (%rax)
je 0x589a
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x23, %edx
movb $0x0, %al
callq 0x4030
jmp 0x58db
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa2d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x58ec
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: continue_stmt_ast_read
static enum PARSER_CODES continue_stmt_ast_read(struct PARSER*parser, struct CONTINUE_STMT_AST**continue_stmt)
{
    enum PARSER_CODES r;

    size_t line;
    size_t pos;
    
    if ((parser->tok)->token_type != TOKEN_TYPE_CONTINUE) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_CONTINUE);
        goto err0;
    }
    line = (parser->tok)->frag.starting.line;
    pos = (parser->tok)->frag.starting.pos;
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    if ((parser->tok)->token_type != TOKEN_TYPE_SEMI) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_SEMI);
        goto err0;
    }
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    (*continue_stmt) = create_continue_stmt_ast(line, pos);

    return PARSER_OK;

 err0:
    (*continue_stmt) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x6, (%rax)
je 0x593e
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
movb $0x0, %al
callq 0x4030
jmp 0x59eb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x23, (%rax)
je 0x59aa
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x23, %edx
movb $0x0, %al
callq 0x4030
jmp 0x59eb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa3d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x59fc
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/parser/parser.c
// Function: return_stmt_ast_read
static enum PARSER_CODES return_stmt_ast_read(struct PARSER*parser, struct RETURN_STMT_AST**return_stmt)
{
    enum PARSER_CODES r;    
    struct ASSIGNMENT_EXPR_AST*assignment_expr;
    
    if ((parser->tok)->token_type != TOKEN_TYPE_RETURN) {
        
    }    
    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    if ((parser->tok)->token_type == TOKEN_TYPE_SEMI) {
        assignment_expr = NULL;
    } else {
        r = assignment_expr_ast_read(parser, &assignment_expr);
        if (r != PARSER_OK) {
            goto err0;
        }
    }

    if ((parser->tok)->token_type != TOKEN_TYPE_SEMI) {
        r = PARSER_INVALID_TOKEN;
        set_parser_error(parser, 1, TOKEN_TYPE_SEMI);
        goto err1;
    }

    token_free((parser->tok));
    lexer_next_token(parser->lexer, &(parser->tok));

    (*return_stmt) = create_return_stmt_ast(assignment_expr,
                                            (parser->tok)->frag.starting.line,
                                            (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    if (assignment_expr != NULL) {
        assignment_expr_ast_free(assignment_expr);
    }
 err0:
    (*return_stmt) = NULL;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xb, (%rax)
je 0x5f2f
jmp 0x5f2f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x23, (%rax)
jne 0x5f67
movq $0x0, -0x28(%rbp)
jmp 0x5f84
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5190
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5f82
jmp 0x6016
jmp 0x5f84
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x23, (%rax)
je 0x5faf
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x23, %edx
movb $0x0, %al
callq 0x4030
jmp 0x6004
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1fd0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdx
callq 0xa810
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6027
cmpq $0x0, -0x28(%rbp)
je 0x6014
movq -0x28(%rbp), %rdi
callq 0x9810
jmp 0x6016
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq