LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: nextChar
char nextChar() {               /* 次の１文字を返す関数                 */
    char ch;
    if (lineIndex == -1){
        if (fgets(line, MAXLINE, fpi) != NULL){
            /* puts(line); */   /* 通常のエラーメッセージの出力の場合（参考まで） */
            lineIndex = 0;
        } else
            errorF("end of file\n"); /* end of fileならコンパイル終了   */
    }
    if ((ch = line[lineIndex++]) == '\n'){ /* chに次の１文字            */
        lineIndex = -1;         /* それが改行文字なら次の行の入力準備   */
        return '\n';            /* 文字としては改行文字を返す           */
    }
    return ch;
}

// Assembly:
pushq %rax
cmpl $-0x1, 0x600b(%rip)     # 0x9d80
jne 0x3d9e
movq 0x5ff2(%rip), %rdx      # 0x9d70
leaq 0x644b(%rip), %rdi      # 0xa1d0
movl $0x78, %esi
callq 0x20e0
testq %rax, %rax
je 0x3dc4
movl $0x0, 0x5fe2(%rip)      # 0x9d80
movslq 0x5fdb(%rip), %rax      # 0x9d80
leal 0x1(%rax), %ecx
leaq 0x6421(%rip), %rdx      # 0xa1d0
movb (%rax,%rdx), %al
cmpb $0xa, %al
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovnel %ecx, %edx
movl %edx, 0x5fbe(%rip)      # 0x9d80
popq %rcx
retq
leaq 0x1744(%rip), %rdi      # 0x550f
callq 0x3953
// File: /workspace/github_c_makefile_star2_O1/tyabu12[P]pl0compiler/getSource.c
// Function: printSpaces
static void printSpaces() {     /* 空白や改行の印字                     */
    while (CR-- > 0)
        fprintf(fphtml, "\n");
    while (spaces-- > 0)
        fprintf(fphtml, " ");
    CR = 0; spaces = 0;
}

// Assembly:
pushq %rax
movl 0x5fe1(%rip), %eax      # 0x9db8
leal -0x1(%rax), %ecx
movl %ecx, 0x5fd8(%rip)      # 0x9db8
testl %eax, %eax
jle 0x3e08
movq 0x5f8d(%rip), %rsi      # 0x9d78
movl $0xa, %edi
callq 0x20d0
jmp 0x3dd1
movq 0x5f7a(%rip), %rsi      # 0x9d78
movl $0x20, %edi
callq 0x20d0
movl 0x5fa6(%rip), %eax      # 0x9db4
leal -0x1(%rax), %ecx
movl %ecx, 0x5f9d(%rip)      # 0x9db4
testl %eax, %eax
jg 0x3df7
xorl %eax, %eax
movl %eax, 0x5f95(%rip)      # 0x9db8
movl %eax, 0x5f8b(%rip)      # 0x9db4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpb $0x1, 0x5f55(%rip)      # 0x9d88
jne 0x3e3e
movb $0x0, 0x5f4c(%rip)      # 0x9d88
popq %rbx
retq
movslq 0x5f47(%rip), %rbx      # 0x9d8c
movb $0x1, 0x5f3c(%rip)      # 0x9d88
callq 0x3dd0
cmpl $0xd, %ebx
jg 0x3e7b
movq 0x5f1b(%rip), %rdi      # 0x9d78
shlq $0x4, %rbx
leaq 0x3d68(%rip), %rax      # 0x7bd0
movq (%rbx,%rax), %rdx
leaq 0x16a9(%rip), %rsi      # 0x551c
xorl %eax, %eax
popq %rbx
jmp 0x2110
cmpl $0x1e, %ebx
jg 0x3e9c
movq 0x5ef1(%rip), %rsi      # 0x9d78
shlq $0x4, %rbx
leaq 0x3d3e(%rip), %rax      # 0x7bd0
movq (%rbx,%rax), %rdi
popq %rbx
jmp 0x20b0
cmpl $0x21, %ebx
je 0x3ed2
cmpl $0x20, %ebx
jne 0x3e3c
movl 0x6314(%rip), %eax      # 0xa1c0
cmpq $0x3, %rax
ja 0x3e3c
leaq 0x1453(%rip), %rcx      # 0x530c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x5eaf(%rip), %rdi      # 0x9d78
leaq 0x1656(%rip), %rsi      # 0x5526
jmp 0x3f0c
movq 0x5e9f(%rip), %rdi      # 0x9d78
movl 0x5eb1(%rip), %edx      # 0x9d90
leaq 0x12a6(%rip), %rsi      # 0x518c
xorl %eax, %eax
popq %rbx
jmp 0x2110
movq 0x5e83(%rip), %rsi      # 0x9d78
leaq 0x5e94(%rip), %rdi      # 0x9d90
jmp 0x3e96
movq 0x5e73(%rip), %rdi      # 0x9d78
leaq 0x1624(%rip), %rsi      # 0x5530
leaq 0x5e7d(%rip), %rdx      # 0x9d90
jmp 0x3e73
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl 0x40(%rdi), %edi
movq %rsp, %r14
movl $0x80, %edx
movq %r14, %rsi
callq 0x5a14
movq 0x16a7c(%rip), %r12     # 0x17ff0
movq (%r12), %rdi
movq 0x48(%rbx), %rdx
movq 0x50(%rbx), %rcx
leaq 0xe32d(%rip), %rsi      # 0xf8b4
movq %r14, %r8
xorl %eax, %eax
callq 0x1100
movl (%rbx), %edi
cmpl $0x26, %edi
je 0x15cf
addq $0x4, %rbx
movq %rsp, %r14
leaq 0xe345(%rip), %r15      # 0xf8eb
movl $0x80, %edx
movq %r14, %rsi
callq 0x5a14
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1100
movl (%rbx), %edi
addq $0x4, %rbx
cmpl $0x26, %edi
jne 0x15a6
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x10c0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xafca(%rip), %rsi      # 0xf39b
callq 0x10f0
testl %eax, %eax
je 0x441b
leaq 0xac68(%rip), %rsi      # 0xf049
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x4424
leaq 0xafad(%rip), %rsi      # 0xf3a1
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x442d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1170
testq %rax, %rax
jne 0x4437
movq %r14, %rdi
movq %rbx, %rsi
callq 0x140e
movq 0x13ba6(%rip), %rax     # 0x17fc8
jmp 0x4434
movq 0x13b95(%rip), %rax     # 0x17fc0
jmp 0x4434
movq 0x13bbc(%rip), %rax     # 0x17ff0
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x1040
leaq 0xaf1b(%rip), %rsi      # 0xf39b
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x44a0
leaq 0xb23e(%rip), %rsi      # 0xf6d1
movq %r14, %rdi
callq 0x43c0
movq %rax, %r15
jmp 0x44aa
movq 0x13b21(%rip), %rax     # 0x17fc8
movq (%rax), %r15
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1150
movq %r15, %rdi
callq 0x1110
movq %rax, 0x8(%rbx)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1150
movq 0x8(%rbx), %r12
leaq 0x1(%r12), %r13
movq %r13, %rdi
callq 0x1130
movq %rax, (%rbx)
testq %rax, %rax
je 0x4528
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1060
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x4530
movq (%rbx), %rax
movb $0x0, (%rax,%rcx)
movups (%rbx), %xmm0
movups %xmm0, 0x110(%rbx)
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1070
movq %r13, %rdi
callq 0x148a
movq %r14, %rdi
callq 0x1466
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rdi
movl $0x100, %edx            # imm = 0x100
movq %rax, %rsi
callq 0x1040
movq %r14, %rdi
callq 0x1080
movq %rax, %r15
movq %rax, 0x8(%rbx)
leaq 0x1(%rax), %r12
movq %r12, %rdi
callq 0x1130
movq %rax, (%rbx)
testq %rax, %rax
je 0x45ad
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1040
movb $0x0, (%r13,%r15)
movq %r13, 0x110(%rbx)
movq %r15, 0x118(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x14b8
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa8fd(%rip), %rdi      # 0xf62c
movl $0x27, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
leaq 0xa90c(%rip), %rdi      # 0xf654
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x45b5
movq (%r15), %rdi
cmpl $0x26, (%rdi)
je 0x4dbf
leaq 0x10(%rsp), %r15
leaq 0xa8e0(%rip), %r12      # 0xf65e
leaq 0x8(%rsp), %r13
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rsi
callq 0x52bb
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1100
movq 0x8(%rsp), %rdi
callq 0x53b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x45b5
movq 0x8(%rsp), %rdi
cmpl $0x26, (%rdi)
jne 0x4d83
callq 0x53b0
leaq 0xa898(%rip), %rdi      # 0xf663
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1190
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rsp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x4e0c
movq %rax, %r15
movl %ebp, (%rax)
movl $0x0, 0x4(%rax)
testq %r12, %r12
je 0x4ea5
leaq 0x30(%rsp), %r13
movq %rsp, %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x54d1
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
decq %r12
jne 0x4e78
movq 0x20(%r14), %rax
movq %rax, 0x28(%r15)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, 0x30(%r15)
movups %xmm1, 0x40(%r15)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%r15)
movq %r15, (%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rsp, %r12
movq %rax, 0x20(%r12)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%r12)
movaps %xmm0, (%r12)
callq 0x4e0c
movq %rax, %r14
movabsq $0x20000001d, %rax      # imm = 0x20000001D
movq %rax, (%r14)
movq %r12, %rdi
callq 0x5425
testl %eax, %eax
je 0x4f7d
leaq 0x30(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x54d1
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r13, %rdi
callq 0x5425
testl %eax, %eax
jne 0x4f49
movq %rsp, %rdi
callq 0x53ee
xorl %ebp, %ebp
cmpl $0x2e, %eax
jne 0x5010
leaq 0x30(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x54d1
movq 0x20(%r12), %rax
movq %rax, 0x20(%r13)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm1, 0x10(%r13)
movaps %xmm0, (%r13)
movq %r13, %rdi
callq 0x5425
testl %eax, %eax
je 0x500b
leaq 0x30(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x54d1
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r13, %rdi
callq 0x5425
testl %eax, %eax
jne 0x4fd5
jmp 0x5010
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x20(%r15), %rax
movq %rax, 0x28(%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, 0x30(%r14)
movups %xmm1, 0x40(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%r14)
movl 0x50(%r14), %ecx
movq 0x28(%r14), %r8
subl %r8d, %ecx
addq 0x8(%r14), %r8
leaq 0xa639(%rip), %rdx      # 0xf696
leaq 0x30(%rsp), %r15
movl $0x40, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
movq %r15, %rdi
callq 0x10e0
movq %rax, 0x58(%r14)
movq %r14, (%rbx)
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rsp, %r12
movq %rax, 0x20(%r12)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%r12)
movaps %xmm0, (%r12)
callq 0x4e0c
movq %rax, %r14
movabsq $0x10000000c, %rax      # imm = 0x10000000C
movq %rax, (%r14)
leaq 0x28(%rsp), %r13
movq %r12, %rdi
callq 0x5425
testl %eax, %eax
jne 0x50f4
movq %r12, %rdi
callq 0x543b
testl %eax, %eax
je 0x511e
movq %r13, %rdi
movq %r12, %rsi
callq 0x54d1
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
jmp 0x50dc
movq 0x20(%r15), %r8
movq %r8, 0x28(%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, 0x30(%r14)
movups %xmm1, 0x40(%r14)
movq 0x20(%rsp), %rcx
movq %rcx, 0x50(%r14)
movq %r14, %rdi
addq $0x58, %rdi
subl %r8d, %ecx
addq 0x8(%r14), %r8
leaq 0xa52c(%rip), %rdx      # 0xf696
movl $0x20, %esi
xorl %eax, %eax
callq 0x10b0
movq %r14, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x4e0c
movl %ebp, (%rax)
movl $0x3, 0x4(%rax)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x8(%rax)
movups %xmm1, 0x18(%rax)
movq 0x20(%r14), %rcx
movq %rcx, 0x28(%rax)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, 0x30(%rax)
movups %xmm1, 0x40(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rsp, %r12
movq %rax, 0x20(%r12)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%r12)
movaps %xmm0, (%r12)
callq 0x4e0c
movq %rax, %r15
movq %r12, %rdi
callq 0x5462
testl %eax, %eax
je 0x5266
leaq 0x28(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x54d1
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r13, %rdi
callq 0x5462
testl %eax, %eax
jne 0x5232
movabsq $0x400000027, %rax      # imm = 0x400000027
movq %rax, (%r15)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x8(%r15)
movups %xmm1, 0x18(%r15)
movq 0x20(%r14), %rax
movq %rax, 0x28(%r15)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, 0x30(%r15)
movups %xmm1, 0x40(%r15)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%r15)
movq %r15, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/lexer/token.c
// Function: token_to_xml_string
void token_to_xml_string(const struct TOKEN*tok, char*str, size_t len)
{
    switch (tok->group_type) {
    case GROUP_TYPE_KEYWORDS:
        TOKEN_GEN_STR("keyword");
        break;
    case GROUP_TYPE_IDENTS:
        TOKEN_GEN_STR("ident");
        break;
    case GROUP_TYPE_NUMBERS:
        TOKEN_GEN_STR("number");
        break;
    case GROUP_TYPE_OPS:
        TOKEN_GEN_STR("operator");
        break;
    case GROUP_TYPE_AUX:
        TOKEN_GEN_STR("aux");
        break;
    }
}

// Assembly:
pushq %rax
movl 0x4(%rdi), %eax
cmpq $0x4, %rax
ja 0x53ae
leaq 0xa3a0(%rip), %rcx      # 0xf670
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
movl 0x50(%rdi), %r10d
movq 0x28(%rdi), %r11
subl %r11d, %r10d
addq 0x8(%rdi), %r11
subq $0x8, %rsp
leaq 0xa3c3(%rip), %rcx      # 0xf6be
jmp 0x538e
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
movl 0x50(%rdi), %r10d
movq 0x28(%rdi), %r11
subl %r11d, %r10d
addq 0x8(%rdi), %r11
subq $0x8, %rsp
leaq 0xa3ba(%rip), %rcx      # 0xf6dc
jmp 0x538e
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
movl 0x50(%rdi), %r10d
movq 0x28(%rdi), %r11
subl %r11d, %r10d
addq 0x8(%rdi), %r11
subq $0x8, %rsp
leaq 0xa386(%rip), %rcx      # 0xf6cc
jmp 0x538e
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
movl 0x50(%rdi), %r10d
movq 0x28(%rdi), %r11
subl %r11d, %r10d
addq 0x8(%rdi), %r11
subq $0x8, %rsp
leaq 0xa369(%rip), %rcx      # 0xf6d3
jmp 0x538e
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
movl 0x50(%rdi), %r10d
movq 0x28(%rdi), %r11
subl %r11d, %r10d
addq 0x8(%rdi), %r11
subq $0x8, %rsp
leaq 0xa338(%rip), %rcx      # 0xf6c6
leaq 0xa306(%rip), %rax      # 0xf69b
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
pushq %rcx
pushq %r11
pushq %r10
callq 0x10b0
addq $0x20, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rdi), %rsi
movq 0x20(%rdi), %r8
movzbl (%rsi,%r8), %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
je 0x54d0
cmpl $0x20, %ecx
je 0x54d0
leaq (%rsi,%r8), %rdx
cmpl $0xd, %ecx
jne 0x5494
leaq 0x1(%r8), %r9
cmpq 0x8(%rdi), %r9
leaq 0x1(%rsi,%r8), %rsi
cmovbq %rsi, %rdx
movl %ecx, %esi
andb $-0x21, %sil
addb $-0x5b, %sil
cmpb $-0x1b, %sil
ja 0x54d0
leal -0x3a(%rcx), %esi
cmpb $-0xb, %sil
ja 0x54d0
cmpb $0xa, (%rdx)
je 0x54d0
xorl %eax, %eax
leaq 0xa225(%rip), %rdx      # 0xf6e0
xorl %esi, %esi
cmpb (%rsi,%rdx), %cl
je 0x54d0
incq %rsi
cmpq $0x13, %rsi
jne 0x54bd
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rdi
movq 0x20(%rsi), %r8
movq %rcx, %r9
addq $-0x1, %r9
setb %r10b
cmpq %r9, %r8
setne %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x553e
pushq %rbx
movq (%rsi), %r9
leaq (%r9,%r8), %r10
leaq 0x1(%r8), %r11
cmpq %rcx, %r11
leaq 0x1(%r9,%r8), %rbx
cmovaeq %r10, %rbx
cmpb $0xd, (%r9,%r8)
cmovneq %r10, %rbx
incq %rdi
xorl %r8d, %r8d
cmpb $0xa, (%rbx)
sete %r8b
movl $0x1, %r9d
cmoveq %r9, %rdi
addq %r8, %rdx
movq %r11, %r8
popq %rbx
movq (%rsi), %rsi
movq %rsi, (%rax)
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rdi, 0x18(%rax)
movq %r8, 0x20(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rsp)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %rdx, %rdx
je 0x55d6
movq %rdx, %rbx
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
movq %rsp, %r13
xorl %ebp, %ebp
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movb (%rax,%rcx), %al
cmpb (%r14,%rbp), %al
jne 0x5607
movq %r12, %rdi
movq %r13, %rsi
callq 0x54d1
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
incq %rbp
cmpq %rbp, %rbx
jne 0x5594
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movb (%rax,%rcx), %al
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jb 0x5604
leal -0x5b(%rax), %ecx
cmpb $-0x1a, %cl
setb %cl
addb $-0x3a, %al
cmpb $-0xa, %al
setb %al
movl $0x1, %r15d
testb %al, %cl
jne 0x5607
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x5c30
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
testq %rsi, %rsi
je 0x5c96
movl -0x80(%rsp), %eax
movq -0x70(%rsp), %rcx
movq -0x78(%rsp), %r8
xorl %edx, %edx
cmpl $0x28, %eax
ja 0x5c7a
movq %r8, %r9
movl %eax, %r8d
addq %rcx, %r8
addl $0x8, %eax
movl %eax, -0x80(%rsp)
jmp 0x5c83
leaq 0x8(%r8), %r9
movq %r9, -0x78(%rsp)
movl (%r8), %r8d
movl %r8d, 0x10(%rdi,%rdx,4)
incq %rdx
movq %r9, %r8
cmpq %rdx, %rsi
jne 0x5c63
movl $0x26, 0x10(%rdi,%rsi,4)
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl %ecx, 0x50(%rdi)
movq 0x18(%rax), %rcx
movq %rcx, 0x58(%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x60(%rdi)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0xc, (%rax)
jne 0x5d00
leaq 0x8(%rbx), %r15
leaq 0x58(%rax), %rdi
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
callq 0xad3f
movq %rax, (%r14)
movq 0x8(%rbx), %rdi
callq 0x53b0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x45b5
xorl %eax, %eax
jmp 0x5d20
movl $0x1, %esi
movq %rbx, %rdi
movl $0xc, %edx
xorl %eax, %eax
callq 0x5bec
movq $0x0, (%r14)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movq 0x8(%rdi), %rdi
cmpl $0x1b, (%rdi)
jne 0x6898
movq %rdx, %r15
leaq 0x8(%r14), %r12
callq 0x53b0
movq (%r14), %rdi
movq %r12, %rsi
callq 0x45b5
movq 0x8(%r14), %rax
cmpl $0x1c, (%rax)
je 0x68b6
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x70dd
testl %eax, %eax
je 0x68b6
movl %eax, %ebp
jmp 0x691a
xorl %r15d, %r15d
movl $0x1, %esi
movq %r14, %rdi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x5bec
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x691d
movq (%r12), %rdi
cmpl $0x1c, (%rdi)
jne 0x68ef
callq 0x53b0
movq (%r14), %rdi
movq %r12, %rsi
callq 0x45b5
movq 0x8(%rsp), %rsi
movq 0x8(%r14), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq %r15, %rdi
callq 0xab73
movq %rax, %r15
xorl %ebp, %ebp
jmp 0x691d
xorl %r15d, %r15d
movl $0x1, %esi
movq %r14, %rdi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x5bec
movq 0x8(%rsp), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x691d
callq 0x9c8c
xorl %r15d, %r15d
movq %r15, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/parser.c
// Function: args_list_ast_read
static enum PARSER_CODES args_list_ast_read(struct PARSER*parser, struct ARGS_LIST_AST**args_list)
{
    enum PARSER_CODES r;
    struct ASSIGNMENT_EXPR_AST**assignment_exprs = NULL;
    size_t assignment_exprs_len = 0;
    size_t assignment_exprs_cap = 0;

    struct ASSIGNMENT_EXPR_AST*assignment_expr;

    r = assignment_expr_ast_read(parser, &assignment_expr);
    if (r != PARSER_OK) {
        goto err0;
    }
    
    PUSH_BACK(assignment_exprs, assignment_expr);    
    
    while ((parser->tok)->token_type == TOKEN_TYPE_COMMA) {
        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));

        r = assignment_expr_ast_read(parser, &assignment_expr);
        if (r != PARSER_OK) {
            goto err1;
        }
        
        PUSH_BACK(assignment_exprs, assignment_expr);    
    }

    (*args_list) = create_args_list_ast(assignment_exprs, assignment_exprs_len,
                                        (parser->tok)->frag.starting.line,
                                        (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    {
        size_t i;
        for (i = 0; i < assignment_exprs_len; i++) {
            assignment_expr_ast_free(assignment_exprs[i]);
        }
        SAFE_FREE(assignment_exprs);
    }
 err0:
    (*args_list) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rsi
callq 0x6b48
testl %eax, %eax
je 0x7108
movl %eax, %ebx
xorl %eax, %eax
jmp 0x71ea
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x7239
movq %rax, %r14
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movq 0x8(%r12), %rdi
movl $0x1, %r15d
cmpl $0x22, (%rdi)
jne 0x71d0
leaq 0x8(%r12), %r13
movl $0x1, %ebp
callq 0x53b0
movq (%r12), %rdi
movq %r13, %rsi
callq 0x45b5
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x6b48
testl %eax, %eax
jne 0x71ff
cmpq %rbp, %r15
jne 0x71b7
testq %rbp, %rbp
je 0x719c
movq %rbp, %rbx
shlq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1160
testq %rax, %rax
je 0x722c
movq %rax, %r14
addq %rbp, %rbp
jmp 0x71b7
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x7234
movq %rax, %r14
movl $0x1, %ebp
movq 0x8(%rsp), %rax
movq %rax, (%r14,%r15,8)
incq %r15
movq (%r13), %rdi
cmpl $0x22, (%rdi)
je 0x7149
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xacf5
xorl %ebx, %ebx
movq 0x10(%rsp), %r13
movq %rax, (%r13)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
testq %r15, %r15
movq 0x10(%rsp), %r13
je 0x721f
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x8aae
incq %r12
cmpq %r12, %r15
jne 0x720e
movq %r14, %rdi
callq 0x1030
jmp 0x7101
movq %rbx, %rdi
callq 0x1860
callq 0x1890
callq 0x18c1
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/parser.c
// Function: logical_or_expr_ast_read
static enum PARSER_CODES logical_or_expr_ast_read(struct PARSER*parser, struct LOGICAL_OR_EXPR_AST**logical_or_expr)
{
    enum PARSER_CODES r;

    struct LOGICAL_AND_EXPR_AST**logical_and_exprs = NULL;
    size_t logical_and_exprs_len = 0;
    size_t logical_and_exprs_cap = 0;
    
    struct LOGICAL_AND_EXPR_AST*logical_and_expr;


    r = logical_and_expr_ast_read(parser, &logical_and_expr);
    if (r != PARSER_OK) {
        goto err0;
    }

    PUSH_BACK(logical_and_exprs, logical_and_expr);

    while ((parser->tok)->token_type == TOKEN_TYPE_OR) {
        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));

        r = logical_and_expr_ast_read(parser, &logical_and_expr);
        if (r != PARSER_OK) {
            goto err1;
        }

        PUSH_BACK(logical_and_exprs, logical_and_expr);
    }

    (*logical_or_expr) = create_logical_or_expr_ast(logical_and_exprs, logical_and_exprs_len,
                                                    (parser->tok)->frag.starting.line,
                                                    (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    {
        size_t i;
        for (i = 0; i < logical_and_exprs_len; i++) {
            logical_and_expr_ast_free(logical_and_exprs[i]);
        }
        SAFE_FREE(logical_and_exprs);
    }
 err0:
    (*logical_or_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rsi
callq 0x739f
testl %eax, %eax
je 0x7269
movl %eax, %ebx
xorl %eax, %eax
jmp 0x734b
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x739a
movq %rax, %r14
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movq 0x8(%r12), %rdi
movl $0x1, %r15d
cmpl $0xd, (%rdi)
jne 0x7331
leaq 0x8(%r12), %r13
movl $0x1, %ebp
callq 0x53b0
movq (%r12), %rdi
movq %r13, %rsi
callq 0x45b5
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x739f
testl %eax, %eax
jne 0x7360
cmpq %rbp, %r15
jne 0x7318
testq %rbp, %rbp
je 0x72fd
movq %rbp, %rbx
shlq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1160
testq %rax, %rax
je 0x738d
movq %rax, %r14
addq %rbp, %rbp
jmp 0x7318
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x7395
movq %rax, %r14
movl $0x1, %ebp
movq 0x8(%rsp), %rax
movq %rax, (%r14,%r15,8)
incq %r15
movq (%r13), %rdi
cmpl $0xd, (%rdi)
je 0x72aa
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9cd0
xorl %ebx, %ebx
movq 0x10(%rsp), %r13
movq %rax, (%r13)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
testq %r15, %r15
movq 0x10(%rsp), %r13
je 0x7380
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x9e43
incq %r12
cmpq %r12, %r15
jne 0x736f
movq %r14, %rdi
callq 0x1030
jmp 0x7262
movq %rbx, %rdi
callq 0x18f2
callq 0x1922
callq 0x1953
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/parser.c
// Function: logical_and_expr_ast_read
static enum PARSER_CODES logical_and_expr_ast_read(struct PARSER*parser, struct LOGICAL_AND_EXPR_AST**logical_and_expr)
{
    enum PARSER_CODES r;

    struct EQ_EXPR_AST**eq_exprs = NULL;
    size_t eq_exprs_len = 0;
    size_t eq_exprs_cap = 0;
    
    struct EQ_EXPR_AST*eq_expr;


    r = eq_expr_ast_read(parser, &eq_expr);
    if (r != PARSER_OK) {
        goto err0;
    }

    PUSH_BACK(eq_exprs, eq_expr);

    while ((parser->tok)->token_type == TOKEN_TYPE_AND) {
        token_free((parser->tok));
        lexer_next_token(parser->lexer, &(parser->tok));

        r = eq_expr_ast_read(parser, &eq_expr);
        if (r != PARSER_OK) {
            goto err1;
        }

        PUSH_BACK(eq_exprs, eq_expr);
    }

    (*logical_and_expr) = create_logical_and_expr_ast(eq_exprs, eq_exprs_len,
                                                      (parser->tok)->frag.starting.line,
                                                      (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    {
        size_t i;
        for (i = 0; i < eq_exprs_len; i++) {
            eq_expr_ast_free(eq_exprs[i]);
        }
        SAFE_FREE(eq_exprs);
    }
 err0:
    (*logical_and_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rsi
callq 0x7500
testl %eax, %eax
je 0x73ca
movl %eax, %ebx
xorl %eax, %eax
jmp 0x74ac
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x74fb
movq %rax, %r14
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movq 0x8(%r12), %rdi
movl $0x1, %r15d
cmpl $0xe, (%rdi)
jne 0x7492
leaq 0x8(%r12), %r13
movl $0x1, %ebp
callq 0x53b0
movq (%r12), %rdi
movq %r13, %rsi
callq 0x45b5
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7500
testl %eax, %eax
jne 0x74c1
cmpq %rbp, %r15
jne 0x7479
testq %rbp, %rbp
je 0x745e
movq %rbp, %rbx
shlq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1160
testq %rax, %rax
je 0x74ee
movq %rax, %r14
addq %rbp, %rbp
jmp 0x7479
movl $0x8, %edi
callq 0x1130
testq %rax, %rax
je 0x74f6
movq %rax, %r14
movl $0x1, %ebp
movq 0x8(%rsp), %rax
movq %rax, (%r14,%r15,8)
incq %r15
movq (%r13), %rdi
cmpl $0xe, (%rdi)
je 0x740b
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9e87
xorl %ebx, %ebx
movq 0x10(%rsp), %r13
movq %rax, (%r13)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
testq %r15, %r15
movq 0x10(%rsp), %r13
je 0x74e1
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x9ffa
incq %r12
cmpq %r12, %r15
jne 0x74d0
movq %r14, %rdi
callq 0x1030
jmp 0x73c3
movq %rbx, %rdi
callq 0x1984
callq 0x19b4
callq 0x19e5
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/parser.c
// Function: eq_expr_ast_read
static enum PARSER_CODES eq_expr_ast_read(struct PARSER*parser, struct EQ_EXPR_AST**eq_expr)
{
    enum PARSER_CODES r;

    struct RELATIONAL_EXPR_AST*left = NULL;
    enum AST_EQ_OP eq_op = AST_EQ_OP_EQEQ;
    struct RELATIONAL_EXPR_AST*right = NULL;

    r = relational_expr_ast_read(parser, &left);
    if (r != PARSER_OK) {
        goto err0;
    }

    if (((parser->tok)->token_type == TOKEN_TYPE_EQEQ) || ((parser->tok)->token_type == TOKEN_TYPE_NEQ)) {
        if ((parser->tok)->token_type == TOKEN_TYPE_EQEQ) {
            eq_op = AST_EQ_OP_EQEQ;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_NEQ) {
            eq_op = AST_EQ_OP_NEQ;
        }

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

        r = relational_expr_ast_read(parser, &right);
        if (r != PARSER_OK) {
            goto err1;
        }
    }

    (*eq_expr) = create_eq_expr_ast(left, eq_op, right,
                                    (parser->tok)->frag.starting.line,
                                    (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    relational_expr_ast_free(left);
 err0:
    (*eq_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movq %r14, 0x8(%rsp)
callq 0x75b7
movl %eax, %ebp
testl %eax, %eax
jne 0x75a3
leaq 0x8(%r15), %r12
movq 0x8(%r15), %rdi
movl (%rdi), %eax
leal -0xf(%rax), %ecx
cmpl $0x1, %ecx
ja 0x7580
xorl %r14d, %r14d
cmpl $0x10, %eax
sete %r13b
callq 0x53b0
movq (%r15), %rdi
movq %r12, %rsi
callq 0x45b5
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x75b7
testl %eax, %eax
je 0x757d
movl %eax, %ebp
movq 0x10(%rsp), %rdi
callq 0xa198
xorl %r14d, %r14d
jmp 0x75a3
movb %r13b, %r14b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq (%r12), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %r8
movl %r14d, %esi
callq 0xa01d
movq %rax, %r14
xorl %ebp, %ebp
movq %r14, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/parser.c
// Function: relational_expr_ast_read
static enum PARSER_CODES relational_expr_ast_read(struct PARSER*parser, struct RELATIONAL_EXPR_AST**relational_expr)
{
    enum PARSER_CODES r;

    struct ADDITIVE_EXPR_AST*left = NULL;
    enum AST_REL_OP rel_op = AST_REL_OP_LT;
    struct ADDITIVE_EXPR_AST*right = NULL;

    r = additive_expr_ast_read(parser, &left);
    if (r != PARSER_OK) {
        goto  err0;
    }

    if (((parser->tok)->token_type == TOKEN_TYPE_LT) || ((parser->tok)->token_type == TOKEN_TYPE_GT) ||
        ((parser->tok)->token_type == TOKEN_TYPE_LE) || ((parser->tok)->token_type == TOKEN_TYPE_GE)) {
        if ((parser->tok)->token_type == TOKEN_TYPE_LT) {
            rel_op = AST_REL_OP_LT;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_GT) {
            rel_op = AST_REL_OP_GT;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_LE) {
            rel_op = AST_REL_OP_LE;
        } else if ((parser->tok)->token_type == TOKEN_TYPE_GE) {
            rel_op = AST_REL_OP_GE;
        }

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

        r = additive_expr_ast_read(parser, &right);
        if (r != PARSER_OK) {
            goto err1;
        }
    }

    (*relational_expr) = create_relational_expr_ast(left, rel_op, right,
                                                    (parser->tok)->frag.starting.line,
                                                    (parser->tok)->frag.starting.pos);

    return PARSER_OK;

 err1:
    additive_expr_ast_free(left);
 err0:
    (*relational_expr) = NULL;
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %r14, (%rsp)
callq 0x7666
movl %eax, %ebp
testl %eax, %eax
jne 0x7654
leaq 0x8(%r15), %r12
movq 0x8(%r15), %rdi
movl (%rdi), %ecx
leal -0x11(%rcx), %eax
cmpl $0x3, %eax
ja 0x7632
addl $-0x12, %ecx
xorl %r14d, %r14d
cmpl $0x3, %ecx
cmovbl %eax, %r14d
callq 0x53b0
movq (%r15), %rdi
movq %r12, %rsi
callq 0x45b5
movq %rsp, %rsi
movq %r15, %rdi
callq 0x7666
testl %eax, %eax
je 0x7632
movl %eax, %ebp
movq 0x8(%rsp), %rdi
callq 0xa315
xorl %r14d, %r14d
jmp 0x7654
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movq (%r12), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %r8
movl %r14d, %esi
callq 0xa1bb
movq %rax, %r14
xorl %ebp, %ebp
movq %r14, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: create_unit_ast
struct UNIT_AST*create_unit_ast(struct FUNCTION_DECL_AST**functions, size_t functions_len,
                                size_t line, size_t pos)
{
    struct UNIT_AST*unit_ast;
    SAFE_MALLOC(unit_ast, 1);
    unit_ast->functions = functions;
    unit_ast->functions_len = functions_len;
    
    unit_ast->line = line;
    unit_ast->pos = pos;
    
    return unit_ast;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x1130
testq %rax, %rax
je 0x818e
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1d1f
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: unit_ast_free
void unit_ast_free(struct UNIT_AST*ast)
{
    size_t i;
    for (i = 0; i < ast->functions_len; i++) {
        function_decl_ast_free(ast->functions[i]);
    }
    SAFE_FREE(ast->functions);
    SAFE_FREE(ast);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x823b
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x8259
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x8226
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/masyagin1998[P]GCI/src/parser/ast.c
// Function: function_decl_ast_free
void function_decl_ast_free(struct FUNCTION_DECL_AST*ast)
{
    ident_ast_free(ast->function_name);
    if (ast->formal_parameters_list != NULL) {
        formal_parameters_list_ast_free(ast->formal_parameters_list);
    }
    body_ast_free(ast->body);
    SAFE_FREE(ast);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x8273
callq 0x8421
movq 0x10(%rbx), %rdi
callq 0x8465
movq %rbx, %rdi
popq %rbx
jmp 0x1030