LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetOperator(Token*, unsigned long*, Buffer*)
bool GetOperator(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(ofs);
    assert(buffer);

    for (int i = 0; i < NUM_OPERATORS; ++i)
    {
        if (strncmp(buffer->str, OPERATORS[i].rus_name, OPERATORS[i].rus_len) == 0)
        {
            VALUE.op = i;
            TYPE     = TYPE_OP;
            STR      = buffer->str;

            buffer->str += OPERATORS[i].rus_len;
            (*ofs)++;
            return true;
        }

        if (OPERATORS[i].eng_name != nullptr)
        {
            if (strncmp(buffer->str, OPERATORS[i].eng_name, OPERATORS[i].eng_len) == 0)
            {
                VALUE.op = i;
                TYPE     = TYPE_OP;
                STR      = buffer->str;

                buffer->str += OPERATORS[i].eng_len;
                (*ofs)++;
                return true;
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x5454
testq %rsi, %rsi
je 0x5473
movq %rdx, %r14
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
testq %rdx, %rdx
je 0x5492
movq (%r14), %r12
leaq 0x86ef(%rip), %r15      # 0xdab8
xorl %ebx, %ebx
cmpq $0x19, %rbx
je 0x543e
movq -0x18(%r15), %rsi
movq -0x10(%r15), %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x2090
testl %eax, %eax
je 0x540c
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x5403
movq (%r15), %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x2090
testl %eax, %eax
je 0x540c
incq %rbx
addq $0x20, %r15
jmp 0x53cb
movq -0x38(%rbp), %rsi
imulq $0x18, (%rsi), %rax
movq -0x30(%rbp), %rdi
movl %ebx, 0x8(%rdi,%rax)
movq (%rsi), %rax
imulq $0x18, %rax, %rcx
movl $0x2, (%rdi,%rcx)
movq (%r14), %rdx
movq %rdx, 0x10(%rdi,%rcx)
addq %rdx, %r13
movq %r13, (%r14)
incq %rax
movq %rax, (%rsi)
cmpq $0x19, %rbx
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x41d0(%rip), %rdi      # 0x962b
leaq 0x3f50(%rip), %rsi      # 0x93b2
leaq 0x409b(%rip), %rcx      # 0x9504
movl $0xd0, %edx
callq 0x20b0
leaq 0x3856(%rip), %rdi      # 0x8cd0
leaq 0x3f31(%rip), %rsi      # 0x93b2
leaq 0x407c(%rip), %rcx      # 0x9504
movl $0xd1, %edx
callq 0x20b0
leaq 0x3e0f(%rip), %rdi      # 0x92a8
leaq 0x3f12(%rip), %rsi      # 0x93b2
leaq 0x405d(%rip), %rcx      # 0x9504
movl $0xd2, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetToken(Token*, unsigned long*, Buffer*)
void GetToken(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(ofs);
    assert(buffer);

    if (GetNumber(tokens, ofs, buffer))
    {
        return;
    }

    if (GetOperator(tokens, ofs, buffer))
    {
        return;
    }

    int len = 0;

    VALUE.name = (char*)calloc(MAX_NAME_LEN, sizeof(char));
    sscanf(buffer->str, "%[A-Za-z_]%n", VALUE.name, &len);

    TYPE = TYPE_ID;
    STR  = buffer->str;
    buffer->str += len;

    (*ofs)++;
    // printf("%s\n", buffer->str);
    // getchar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x5573
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5592
movq %rdx, %r14
testq %rdx, %rdx
je 0x55b1
movq %rdi, %r15
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5267
testb %al, %al
jne 0x5566
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5388
testb %al, %al
jne 0x5566
leaq -0x24(%rbp), %r12
andl $0x0, (%r12)
pushq $0x20
popq %rdi
pushq $0x1
popq %rsi
callq 0x20c0
imulq $0x18, (%rbx), %rcx
movq %rax, 0x8(%r15,%rcx)
movq (%r14), %rdi
imulq $0x18, (%rbx), %rax
movq 0x8(%r15,%rax), %rdx
leaq 0x4028(%rip), %rsi      # 0x955d
movq %r12, %rcx
xorl %eax, %eax
callq 0x20f0
movq (%rbx), %rax
imulq $0x18, %rax, %rcx
movl $0x1, (%r15,%rcx)
movq (%r14), %rdx
movq %rdx, 0x10(%r15,%rcx)
movslq (%r12), %rcx
addq %rdx, %rcx
movq %rcx, (%r14)
incq %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40b1(%rip), %rdi      # 0x962b
leaq 0x3e31(%rip), %rsi      # 0x93b2
leaq 0x3faa(%rip), %rcx      # 0x9532
movl $0xf5, %edx
callq 0x20b0
leaq 0x3737(%rip), %rdi      # 0x8cd0
leaq 0x3e12(%rip), %rsi      # 0x93b2
leaq 0x3f8b(%rip), %rcx      # 0x9532
movl $0xf6, %edx
callq 0x20b0
leaq 0x3cf0(%rip), %rdi      # 0x92a8
leaq 0x3df3(%rip), %rsi      # 0x93b2
leaq 0x3f6c(%rip), %rcx      # 0x9532
movl $0xf7, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetTokens(Token*, unsigned long*, Buffer*)
void GetTokens(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(buffer);

    while (size_t(buffer->str - buffer->original_str) < buffer->lenght && SYMBOL != EOF)
    {
        IgnoreSpaces(buffer);

        if (isdigit(SYMBOL))
        {
            printf("I HATE DIGITS!!!!\n");
            buffer->str++;
        }
        else
        {
            GetToken(tokens, ofs, buffer);
        }

        IgnoreSpaces(buffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5652
movq %rdx, %rbx
testq %rdx, %rdx
je 0x5671
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4315(%rip), %r12      # 0x990e
movq (%rbx), %rax
movq %rax, %rcx
subq 0x8(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jae 0x5649
cmpb $-0x1, (%rax)
je 0x5649
movq %rbx, %rdi
callq 0x51f6
movq (%rbx), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x5631
movq %r12, %rdi
callq 0x21a0
incq (%rbx)
jmp 0x563f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x54b1
movq %rbx, %rdi
callq 0x51f6
jmp 0x55f9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3fd2(%rip), %rdi      # 0x962b
leaq 0x3d52(%rip), %rsi      # 0x93b2
leaq 0x3f03(%rip), %rcx      # 0x956a
movl $0x113, %edx            # imm = 0x113
callq 0x20b0
leaq 0x3c30(%rip), %rdi      # 0x92a8
leaq 0x3d33(%rip), %rsi      # 0x93b2
leaq 0x3ee4(%rip), %rcx      # 0x956a
movl $0x114, %edx            # imm = 0x114
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/parser.cpp
// Function: FillTokens(Token*, Buffer*)
size_t FillTokens(Token* tokens, Buffer* buffer)
{
    assert(tokens);
    assert(buffer);

    size_t ofs = 0;

    GetTokens(tokens, &ofs, buffer);

    return ofs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x56bd
movq %rsi, %rdx
testq %rsi, %rsi
je 0x56dc
leaq -0x10(%rbp), %rbx
andq $0x0, (%rbx)
movq %rbx, %rsi
callq 0x55d0
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3f67(%rip), %rdi      # 0x962b
leaq 0x3ce7(%rip), %rsi      # 0x93b2
leaq 0x3ec4(%rip), %rcx      # 0x9596
movl $0x12a, %edx            # imm = 0x12A
callq 0x20b0
leaq 0x3bc5(%rip), %rdi      # 0x92a8
leaq 0x3cc8(%rip), %rsi      # 0x93b2
leaq 0x3ea5(%rip), %rcx      # 0x9596
movl $0x12b, %edx            # imm = 0x12B
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/parser.cpp
// Function: Parse(char const*)
Parser* Parse(const char* input)
{
    assert(input);

    Buffer* buffer = GetBuffer(input);

    Token* tokens = NewTokensBuffer();

    size_t ofs = FillTokens(tokens, buffer);

    Parser* parser = (Parser*)calloc(1, sizeof(Parser));

    parser->tokens = tokens;
    parser->size = ofs;
    parser->original_buffer = buffer->original_str;

    Delete(buffer);

    return parser;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5787
callq 0x5018
movq %rax, %rbx
callq 0x508c
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5690
movq %rax, %r15
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x20c0
movq %rax, %r12
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x56fb
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c7b(%rip), %rdi      # 0x9409
leaq 0x3c1d(%rip), %rsi      # 0x93b2
leaq 0x3e35(%rip), %rcx      # 0x95d1
movl $0x13d, %edx            # imm = 0x13D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/parser.cpp
// Function: DestructParser(Parser*)
void DestructParser(Parser* parser)
{
    assert(parser);
    assert(parser->original_buffer);
    assert(parser->tokens);

    free(parser->original_buffer);
    free(parser->tokens);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x57d6
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x57f5
cmpq $0x0, (%rbx)
je 0x5814
callq 0x2140
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
leaq 0x3c99(%rip), %rdi      # 0x9476
leaq 0x3bce(%rip), %rsi      # 0x93b2
leaq 0x3e02(%rip), %rcx      # 0x95ed
movl $0x152, %edx            # imm = 0x152
callq 0x20b0
leaq 0x3e0f(%rip), %rdi      # 0x960b
leaq 0x3baf(%rip), %rsi      # 0x93b2
leaq 0x3de3(%rip), %rcx      # 0x95ed
movl $0x153, %edx            # imm = 0x153
callq 0x20b0
leaq 0x3e08(%rip), %rdi      # 0x9623
leaq 0x3b90(%rip), %rsi      # 0x93b2
leaq 0x3dc4(%rip), %rcx      # 0x95ed
movl $0x154, %edx            # imm = 0x154
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/parser.cpp
// Function: ParserDump(Parser*)
void ParserDump(Parser* parser)
{
    assert(parser);

    for (size_t i = 0; i < parser->size; ++i)
    {
        printf("[%lu] ", i);
        switch (parser->tokens[i].type)
        {
            case TYPE_NUMB :
            {
                printf("type number,   value = %d\n", parser->tokens[i].value.number);
                break;
            }
            case TYPE_ID :
            {
                printf("type ID,       value = '%s'\n", parser->tokens[i].value.name);
                break;
            }
            case TYPE_OP :
            {
                printf("type operator, value = '%s'[%d]\n", OPERATORS[parser->tokens[i].value.op].rus_name, parser->tokens[i].value.op);
                break;
            }
            default :
            {
                printf("Unknown type, line = %d\n", __LINE__);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x592c
movq %rdi, %rbx
pushq $0x8
popq %r13
leaq 0x3de4(%rip), %r14      # 0x9668
leaq 0x3e3d(%rip), %r15      # 0x96c8
xorl %r12d, %r12d
cmpq 0x8(%rbx), %r12
jae 0x591d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movl -0x8(%rax,%r13), %ecx
cmpl $0x2, %ecx
je 0x58dc
cmpl $0x1, %ecx
je 0x58c8
testl %ecx, %ecx
jne 0x5902
movl (%rax,%r13), %esi
leaq 0x3da9(%rip), %rdi      # 0x966f
jmp 0x590a
movq (%rax,%r13), %rsi
leaq 0x3db7(%rip), %rdi      # 0x968a
xorl %eax, %eax
callq 0x2040
jmp 0x5911
movslq (%rax,%r13), %rdx
movq %rdx, %rax
shlq $0x5, %rax
leaq 0x81b2(%rip), %rcx      # 0xdaa0
movq (%rax,%rcx), %rsi
leaq 0x3dae(%rip), %rdi      # 0x96a7
xorl %eax, %eax
callq 0x2040
jmp 0x5911
movq %r15, %rdi
movl $0x17b, %esi            # imm = 0x17B
xorl %eax, %eax
callq 0x2040
incq %r12
addq $0x18, %r13
jmp 0x588e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b43(%rip), %rdi      # 0x9476
leaq 0x3a78(%rip), %rsi      # 0x93b2
leaq 0x3d0d(%rip), %rcx      # 0x964e
movl $0x163, %edx            # imm = 0x163
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/dot_dump.h
// Function: GetJPGNumber()
size_t GetJPGNumber()
{
    FILE* numjpgs = fopen(DUMP_FILE_NAME, "r");

    size_t num = 0;
    
    if (numjpgs != nullptr)
    {
        fscanf(numjpgs, "%lu", &num);
        fclose(numjpgs);
    }

    numjpgs = fopen(DUMP_FILE_NAME, "w");
    fprintf(numjpgs, "%lu", num + 1);
    fclose(numjpgs);
    
    return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8893(%rip), %rdi      # 0xe210
leaq 0x3929(%rip), %rsi      # 0x92ad
callq 0x2130
andq $0x0, -0x10(%rbp)
testq %rax, %rax
je 0x59b3
movq %rax, %rbx
leaq 0x4075(%rip), %rsi      # 0x9a12
leaq -0x10(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
callq 0x2100
movq 0x8856(%rip), %rdi      # 0xe210
leaq 0x2f39(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %rbx
movq -0x10(%rbp), %rdx
incq %rdx
leaq 0x403b(%rip), %rsi      # 0x9a12
movq %rax, %rdi
xorl %eax, %eax
callq 0x2180
movq %rbx, %rdi
callq 0x2100
movq -0x10(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/dot_dump.h
// Function: GetNames(char*, char*)
void GetNames(char* dot_cmd, char* jpg_cmd)
{
    assert(dot_cmd);
    assert(jpg_cmd);

    size_t num = GetJPGNumber();

    char num_str[NUM_STR_LEN] = "";
    snprintf(num_str, NUM_STR_LEN, "%lu", num);
    char extension[] = ".svg";

    strcat(dot_cmd, num_str);
    strcat(dot_cmd, extension);
    
    strcat(jpg_cmd, num_str);
    strcat(jpg_cmd, extension);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5a92
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5aab
movq %rdi, %r14
callq 0x5970
xorl %r12d, %r12d
leaq -0x30(%rbp), %r15
movb %r12b, 0x4(%r15)
andl $0x0, (%r15)
leaq 0x3fdd(%rip), %rdx      # 0x9a12
pushq $0x5
popq %rsi
movq %r15, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x21b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2080
movl $0x6776732e, %r13d      # imm = 0x6776732E
movl %r13d, (%r14,%rax)
movb %r12b, 0x4(%r14,%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2080
movl %r13d, (%rbx,%rax)
movb %r12b, 0x4(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f7d(%rip), %rdi      # 0x9a16
leaq 0x3f7e(%rip), %rsi      # 0x9a1e
leaq 0x3f90(%rip), %rcx      # 0x9a37
pushq $0x30
jmp 0x5ac2
leaq 0x3fa3(%rip), %rdi      # 0x9a55
leaq 0x3f65(%rip), %rsi      # 0x9a1e
leaq 0x3f77(%rip), %rcx      # 0x9a37
pushq $0x31
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/dot_dump.h
// Function: TreeDump(Tree*)
void TreeDump(Tree* tree)
{
    assert(tree);

    system("mkdir -p log");
    FILE* dump_file = fopen(STANDARD_DOT_TXT_FILE_NAME, "w");

    fprintf(dump_file, "digraph G{\n");
    fprintf(dump_file, "node [shape=\"circle\"]\n");

    PrintNodes(tree, tree->root, dump_file);

    fprintf(dump_file, "}");

    fclose(dump_file);

    char dot_cmd[DOT_CMD_SIZE] = "";
    snprintf(dot_cmd, DOT_CMD_SIZE, "dot -Tsvg %s -o log/Dump", STANDARD_DOT_TXT_FILE_NAME);
    char jpg_cmd[JPG_CMD_SIZE] = "chromium log/Dump";
    GetNames(dot_cmd, jpg_cmd);

    system(dot_cmd);
    system(jpg_cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x5e5e
movq %rdi, %rbx
leaq 0x41b2(%rip), %rdi      # 0x9f34
callq 0x20e0
movq 0x847a(%rip), %rdi      # 0xe208
leaq 0x2b65(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %r14
leaq 0x419d(%rip), %rdi      # 0x9f41
pushq $0xb
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rax, %rcx
callq 0x21f0
leaq 0x4190(%rip), %rdi      # 0x9f4d
pushq $0x16
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x21f0
movq (%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5ac8
pushq $0x7d
popq %rdi
movq %r14, %rsi
callq 0x2150
movq %r14, %rdi
callq 0x2100
xorps %xmm0, %xmm0
leaq -0x80(%rbp), %rbx
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq 0x83ff(%rip), %rcx      # 0xe208
leaq 0x4154(%rip), %rdx      # 0x9f64
pushq $0x40
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21b0
movaps 0x465c(%rip), %xmm0     # 0xa480
leaq -0x40(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0x463c(%rip), %xmm0     # 0xa470
movaps %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x59f4
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2df5(%rip), %rdi      # 0x8c5a
leaq 0x3bb2(%rip), %rsi      # 0x9a1e
leaq 0x40ab(%rip), %rcx      # 0x9f1e
movl $0xc6, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: NewNode()
Node* NewNode()
{
    Node* node = (Node*)calloc(1, sizeof(Node));
    assert(node);

    node->left   = nullptr;
    node->right  = nullptr;
    node->parent = nullptr;

    return node; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x20c0
testq %rax, %rax
je 0x5ec6
popq %rbp
retq
leaq 0x40db(%rip), %rdi      # 0x9fa8
leaq 0x40ad(%rip), %rsi      # 0x9f81
leaq 0x40d2(%rip), %rcx      # 0x9fad
pushq $0x37
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: ConstructNode(NodeType, Value, Node*, Node*)
Node* ConstructNode(NodeType type, Value value, Node* left, Node* right)
{
    Node* node = (Node*)calloc(1, sizeof(Node));
    assert(node);

    node->type  = type;
    node->value = value;

    node->left  = left;
    node->right = right;

    if (type == MATH_TYPE)
    {
        node->value.op = MathTokenToNode(value.op);
    }

    if (left != nullptr)
    {
        left->parent = node;
    }

    if (right != nullptr)
    {
        right->parent = node;
    }

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %r13d
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x20c0
testq %rax, %rax
je 0x5f55
movq %rax, %r15
movl %r13d, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
cmpl $0xe, %r13d
jne 0x5f31
movl %r12d, %edi
callq 0x5f72
movl %eax, 0x8(%r15)
testq %r14, %r14
je 0x5f3a
movq %r15, 0x10(%r14)
testq %rbx, %rbx
je 0x5f43
movq %r15, 0x10(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x404c(%rip), %rdi      # 0x9fa8
leaq 0x401e(%rip), %rsi      # 0x9f81
leaq 0x4053(%rip), %rcx      # 0x9fbd
pushq $0x43
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: DestuctSubtree(Node*)
void DestuctSubtree(Node* node)
{
    if (node == nullptr)
    {
        return;
    }

    DestuctSubtree(node->left);
    DestuctSubtree(node->right);
    free(node);
}

// Assembly:
testq %rdi, %rdi
je 0x601a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x5fec
movq 0x20(%rbx), %rdi
callq 0x5fec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
retq
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetTree(Parser*)
Tree* GetTree(Parser* parser)
{
    assert(parser);

    Tree* tree = NewTree();

    size_t ofs = 0;

    tree->root = GetData(parser, &ofs);

    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x607f
movq %rdi, %rbx
callq 0x5e7d
movq %rax, %r14
leaq -0x18(%rbp), %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x609e
movq %rax, (%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x33f0(%rip), %rdi      # 0x9476
leaq 0x3ef4(%rip), %rsi      # 0x9f81
leaq 0x3f90(%rip), %rcx      # 0xa024
movl $0x8e, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetData(Parser*, unsigned long*)
Node* GetData(Parser* parser, size_t* ofs)
{
    assert(parser);

    bool is_void = (VALUE.op == VOID_FUNC);

    Node* result = ConstructNode(D_TYPE, nullptr, GetDefinition(parser, ofs));
    Node* last = result;
    last->value.is_void = is_void;

    while (*ofs < parser->size)
    {
        is_void = (VALUE.op == VOID_FUNC);
        last->left = ConstructNode(D_TYPE, nullptr, GetDefinition(parser, ofs));

        last->left->parent = last;
        last = last->left;
        last->value.is_void = is_void;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x612f
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
imulq $0x18, (%rsi), %rcx
movl 0x8(%rax,%rcx), %r12d
callq 0x614e
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rdx
callq 0x5f8e
movq %rax, %r15
cmpl $0x1, %r12d
sete 0x8(%rax)
movq %rax, %r12
movq (%rbx), %rax
cmpq 0x8(%r14), %rax
jae 0x611d
movq (%r14), %rcx
imulq $0x18, %rax, %rax
movl 0x8(%rcx,%rax), %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x614e
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rdx
callq 0x5f8e
cmpl $0x1, %r13d
movq %rax, 0x18(%r12)
movq %r12, 0x10(%rax)
jmp 0x60db
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3340(%rip), %rdi      # 0x9476
leaq 0x3e44(%rip), %rsi      # 0x9f81
leaq 0x3ef8(%rip), %rcx      # 0xa03c
movl $0x9b, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetDefinition(Parser*, unsigned long*)
Node* GetDefinition(Parser* parser, size_t* ofs)
{
    assert(parser);
    assert(ofs);

    if (TYPE != TYPE_OP || (VALUE.op != DECLARATOR && VALUE.op != VOID_FUNC))
    {
        parser->status = TYPE_ERROR;
        CompilationError(parser, ofs);
    }

    (*ofs)++;

    Node* tmp  = ID(nullptr, nullptr);
    tmp->right = GetArgs(parser, ofs);
    tmp->left  = GetCompound(parser, ofs);

    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x61ed
movq %rsi, %rbx
testq %rsi, %rsi
je 0x620c
movq %rdi, %r14
movq (%rdi), %rax
movq (%rbx), %rcx
imulq $0x18, %rcx, %rdx
cmpl $0x2, (%rax,%rdx)
jne 0x6189
addq %rax, %rdx
cmpl $0x2, 0x8(%rdx)
jb 0x61a2
movl $0x1, 0x18(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rcx
movq (%r14), %rax
leaq 0x2(%rcx), %rdx
movq %rdx, (%rbx)
imulq $0x18, %rcx, %rcx
movq 0x20(%rcx,%rax), %rsi
pushq $0x4
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5ee3
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x622b
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x62fb
movq %rax, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3282(%rip), %rdi      # 0x9476
leaq 0x3d86(%rip), %rsi      # 0x9f81
leaq 0x3e5c(%rip), %rcx      # 0xa05e
movl $0xb2, %edx
callq 0x20b0
leaq 0x2abd(%rip), %rdi      # 0x8cd0
leaq 0x3d67(%rip), %rsi      # 0x9f81
leaq 0x3e3d(%rip), %rcx      # 0xa05e
movl $0xb3, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetArgs(Parser*, unsigned long*)
Node* GetArgs(Parser* parser, size_t* ofs)
{
    assert(parser);

    CheckOpeningRoundBracket(parser, ofs);

    Node* result = nullptr;

    if (TYPE == TYPE_ID)
    {
        result = ID(nullptr, nullptr);
        Node* last = result;

        while (TYPE == TYPE_OP && VALUE.op == COMMA)
        {
            (*ofs)++;

            last->right = ID(nullptr, nullptr);
            last->right->parent = last;
            last = last->right;
        }
    }

    CheckClosingRoundBracket(parser, ofs);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x62dc
movq %rsi, %rbx
movq %rdi, %r14
callq 0x639f
movq (%r14), %rax
movq (%rbx), %rcx
imulq $0x18, %rcx, %rdx
cmpl $0x1, (%rax,%rdx)
jne 0x62bc
addq %rdx, %rax
incq %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
pushq $0x4
popq %r12
movl %r12d, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5ee3
movq %rax, %r15
movq %rax, %r13
movq (%r14), %rax
movq (%rbx), %rcx
imulq $0x18, %rcx, %rdx
cmpl $0x2, (%rax,%rdx)
jne 0x62bf
leaq (%rax,%rdx), %rsi
cmpl $0x18, 0x8(%rsi)
jne 0x62bf
addq $0x2, %rcx
movq %rcx, (%rbx)
movq 0x20(%rdx,%rax), %rsi
movl %r12d, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5ee3
movq %rax, 0x20(%r13)
movq %r13, 0x10(%rax)
jmp 0x627d
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6404
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3193(%rip), %rdi      # 0x9476
leaq 0x3c97(%rip), %rsi      # 0x9f81
leaq 0x3d95(%rip), %rcx      # 0xa086
movl $0xc6, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetCompound(Parser*, unsigned long*)
Node* GetCompound(Parser* parser, size_t* ofs)
{
    assert(parser);

    CheckOpeningBrace(parser, ofs);

    Node* result = ConstructNode(COMP_TYPE);
    Node* last = result;

    while (TYPE != TYPE_OP || VALUE.op != CLOSING_BRACE)
    {
        last->right = ConstructNode(STAT_TYPE, GetStatement(parser, ofs), nullptr);
        last->right->parent = last;
        last = last->right;
    }
 
    CheckClosingBrace(parser, ofs);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6380
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6469
pushq $0x6
popq %rdi
callq 0x5fae
movq %rax, %r15
pushq $0x7
popq %r12
movq %rax, %r13
movq (%r14), %rax
imulq $0x18, (%rbx), %rcx
cmpl $0x2, (%rax,%rcx)
jne 0x6341
addq %rcx, %rax
cmpl $0x8, 0x8(%rax)
je 0x6363
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64ce
movl %r12d, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x5f8e
movq %rax, 0x20(%r13)
movq %r13, 0x10(%rax)
jmp 0x6328
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65f5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30ef(%rip), %rdi      # 0x9476
leaq 0x3bf3(%rip), %rsi      # 0x9f81
leaq 0x3d13(%rip), %rcx      # 0xa0a8
movl $0xe2, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckOpeningRoundBracket(Parser*, unsigned long*)
void CheckOpeningRoundBracket(Parser* parser, size_t* ofs)
{
    assert(parser);

    if (TYPE != TYPE_OP || VALUE.op != OPENING_ROUND_BRACKET)
    {
        parser->status = MISSED_BRACE;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x63e5
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x63c6
addq %rdx, %rcx
cmpl $0x13, 0x8(%rcx)
je 0x63d8
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x308a(%rip), %rdi      # 0x9476
leaq 0x3b8e(%rip), %rsi      # 0x9f81
leaq 0x3f2b(%rip), %rcx      # 0xa325
movl $0x21f, %edx            # imm = 0x21F
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckClosingRoundBracket(Parser*, unsigned long*)
void CheckClosingRoundBracket(Parser* parser, size_t* ofs)
{
    assert(parser);
 
    if (TYPE != TYPE_OP || VALUE.op != CLOSING_ROUND_BRACKET)
    {
        parser->status = MISSED_BRACE;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x644a
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x642b
addq %rdx, %rcx
cmpl $0x14, 0x8(%rcx)
je 0x643d
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3025(%rip), %rdi      # 0x9476
leaq 0x3b29(%rip), %rsi      # 0x9f81
leaq 0x3ef8(%rip), %rcx      # 0xa357
movl $0x22c, %edx            # imm = 0x22C
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckOpeningBrace(Parser*, unsigned long*)
void CheckOpeningBrace(Parser* parser, size_t* ofs)
{
    assert(parser);

    if (TYPE != TYPE_OP || VALUE.op != OPENING_BRACE)
    {
        parser->status = MISSED_BRACE;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x64af
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6490
addq %rdx, %rcx
cmpl $0x7, 0x8(%rcx)
je 0x64a2
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2fc0(%rip), %rdi      # 0x9476
leaq 0x3ac4(%rip), %rsi      # 0x9f81
leaq 0x3e0b(%rip), %rcx      # 0xa2cf
movl $0x205, %edx            # imm = 0x205
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetStatement(Parser*, unsigned long*)
Node* GetStatement(Parser* parser, size_t* ofs)
{
    assert(parser);

    if (TYPE == TYPE_OP && VALUE.op == DECLARATOR) // Initialization
    {
        (*ofs)++;
        if (NEXT_TYPE == TYPE_OP && NEXT_VALUE.op == OPENING_SQUARE_BRACKET)
        {
            Node* tmp = GetArrayDeclaration(parser, ofs);
            CheckSemicolon(parser, ofs);
            return tmp;
        }

        Node* tmp = GetAssignment(parser, ofs);
        tmp->type = DECL_TYPE;
        CheckSemicolon(parser, ofs);
        return tmp;
    }

    if (TYPE == TYPE_ID && NEXT_TYPE == TYPE_OP &&
       (NEXT_VALUE.op == ASSIGNMENT || NEXT_VALUE.op == OPENING_SQUARE_BRACKET))
    {
        Node* tmp = GetAssignment(parser, ofs);
        CheckSemicolon(parser, ofs);
        return tmp;
    }

    if (TYPE == TYPE_OP && VALUE.op == RET) // return
    {
        Node* tmp = GetJump(parser, ofs);
        CheckSemicolon(parser, ofs);
        return tmp;
    }

    if (TYPE == TYPE_OP && VALUE.op == IF)
    {
        return GetCondition(parser, ofs);
    }

    if (TYPE == TYPE_OP && VALUE.op == LOOP)
    {
        return GetLoop(parser, ofs);
    }

    Node* tmp = GetExpression(parser, ofs);
    CheckSemicolon(parser, ofs);
    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x65d6
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
movq (%rsi), %rcx
imulq $0x18, %rcx, %rsi
leaq (%rdx,%rsi), %rax
movl (%rdx,%rsi), %edx
cmpl $0x1, %edx
je 0x6542
cmpl $0x2, %edx
jne 0x6562
movl 0x8(%rax), %edx
cmpq $0x4, %rdx
ja 0x6562
leaq 0x3476(%rip), %rsi      # 0x9988
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
incq %rcx
movq %rcx, (%rbx)
cmpl $0x2, 0x30(%rax)
jne 0x65c0
cmpl $0x15, 0x38(%rax)
jne 0x65c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x665a
jmp 0x656d
cmpl $0x2, 0x18(%rax)
jne 0x6562
movl 0x20(%rax), %eax
cmpl $0x15, %eax
je 0x6555
cmpl $0x6, %eax
jne 0x6562
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6753
jmp 0x656d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66ee
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67bd
jmp 0x656d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x68e9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x681b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6753
movq %rax, %r15
movl $0x1, (%rax)
jmp 0x6570
leaq 0x2e99(%rip), %rdi      # 0x9476
leaq 0x399d(%rip), %rsi      # 0x9f81
leaq 0x3ae3(%rip), %rcx      # 0xa0ce
movl $0xf7, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckClosingBrace(Parser*, unsigned long*)
void CheckClosingBrace(Parser* parser, size_t* ofs)
{
    assert(parser);
 
    if (TYPE != TYPE_OP || VALUE.op != CLOSING_BRACE)
    {
        parser->status = MISSED_BRACE;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x663b
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x661c
addq %rdx, %rcx
cmpl $0x8, 0x8(%rcx)
je 0x662e
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2e34(%rip), %rdi      # 0x9476
leaq 0x3938(%rip), %rsi      # 0x9f81
leaq 0x3caa(%rip), %rcx      # 0xa2fa
movl $0x212, %edx            # imm = 0x212
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetArrayDeclaration(Parser*, unsigned long*)
Node* GetArrayDeclaration(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* id = ID(nullptr, nullptr);
    
    CheckOpeningSquareBracket(parser, ofs);
    Node* expression = GetExpression(parser, ofs);
    CheckClosingSquareBracket(parser, ofs);
        
    return ConstructNode(ADECL_TYPE, id, expression);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x66cf
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
imulq $0x18, %rcx, %rcx
movq 0x8(%rax,%rcx), %rsi
pushq $0x4
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5ee3
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a07
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a6c
pushq $0x2
popq %rdi
movq %r15, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5f8e
leaq 0x2da0(%rip), %rdi      # 0x9476
leaq 0x38a4(%rip), %rsi      # 0x9f81
leaq 0x3a11(%rip), %rcx      # 0xa0f5
movl $0x129, %edx            # imm = 0x129
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckSemicolon(Parser*, unsigned long*)
void CheckSemicolon(Parser* parser, size_t* ofs)
{
    assert(parser);
 
    if (TYPE != TYPE_OP || VALUE.op != SEMICOLON)
    {
        parser->status = MISSED_SMCLN;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6734
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6715
addq %rdx, %rcx
cmpl $0x17, 0x8(%rcx)
je 0x6727
movl $0x3, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2d3b(%rip), %rdi      # 0x9476
leaq 0x383f(%rip), %rsi      # 0x9f81
leaq 0x3ca6(%rip), %rcx      # 0xa3ef
movl $0x253, %edx            # imm = 0x253
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetAssignment(Parser*, unsigned long*)
Node* GetAssignment(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* lval = GetLValue(parser, ofs);//ID(nullptr, nullptr);
    CheckAssigment(parser, ofs);

    return ConstructNode(ASSG_TYPE, lval, GetExpression(parser, ofs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x679e
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6ad1
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6b8b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
pushq $0xb
popq %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5f8e
leaq 0x2cd1(%rip), %rdi      # 0x9476
leaq 0x37d5(%rip), %rsi      # 0x9f81
leaq 0x3970(%rip), %rcx      # 0xa123
movl $0x136, %edx            # imm = 0x136
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetJump(Parser*, unsigned long*)
Node* GetJump(Parser* parser, size_t* ofs)
{
    assert(parser);

    (*ofs)++;

    Node* tmp = nullptr;
    if (TYPE != TYPE_OP && VALUE.op != SEMICOLON)
    {
        tmp = GetExpression(parser, ofs);
    }

    return ConstructNode(JUMP_TYPE, nullptr, tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x67fc
movq (%rsi), %rcx
incq %rcx
movq %rcx, (%rsi)
movq (%rdi), %rax
imulq $0x18, %rcx, %rcx
cmpl $0x2, (%rax,%rcx)
je 0x67e5
addq %rcx, %rax
cmpl $0x17, 0x8(%rax)
jne 0x67e9
xorl %edx, %edx
jmp 0x67f1
callq 0x696c
movq %rax, %rdx
pushq $0xd
popq %rdi
xorl %esi, %esi
popq %rbp
jmp 0x5f8e
leaq 0x2c73(%rip), %rdi      # 0x9476
leaq 0x3777(%rip), %rsi      # 0x9f81
leaq 0x3a2f(%rip), %rcx      # 0xa240
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetCondition(Parser*, unsigned long*)
Node* GetCondition(Parser* parser, size_t* ofs)
{
    assert(parser);

    (*ofs)++;
    CheckOpeningRoundBracket(parser, ofs);

    Node* result = ConstructNode(COND_TYPE, GetExpression(parser, ofs), nullptr);

    CheckClosingRoundBracket(parser, ofs);

    result->right = ConstructNode(IFEL_TYPE, GetCompound(parser, ofs), nullptr);

    if (TYPE == TYPE_OP && VALUE.op == ELSE)
    {
        (*ofs)++;
        result->right->right = GetCompound(parser, ofs);
        result->right->right->parent = result->right;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x68ca
movq %rsi, %rbx
movq %rdi, %r14
incq (%rsi)
callq 0x639f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
pushq $0x8
popq %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x5f8e
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6404
movq %r14, %rdi
movq %rbx, %rsi
callq 0x62fb
pushq $0x9
popq %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x5f8e
movq %rax, 0x20(%r15)
movq (%r14), %rcx
movq (%rbx), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x68bc
addq %rdx, %rcx
cmpl $0x5, 0x8(%rcx)
jne 0x68bc
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x62fb
movq 0x20(%r15), %rcx
movq %rax, 0x20(%rcx)
movq 0x20(%r15), %rax
movq 0x20(%rax), %rcx
movq %rax, 0x10(%rcx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ba5(%rip), %rdi      # 0x9476
leaq 0x36a9(%rip), %rsi      # 0x9f81
leaq 0x39c9(%rip), %rcx      # 0xa2a8
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetLoop(Parser*, unsigned long*)
Node* GetLoop(Parser* parser, size_t* ofs)
{
    assert(parser);

    (*ofs)++;

    CheckOpeningRoundBracket(parser, ofs);
    Node* result = ConstructNode(LOOP_TYPE, GetExpression(parser, ofs), nullptr);
    CheckClosingRoundBracket(parser, ofs);

    result->right = GetCompound(parser, ofs);
    result->right->parent = result;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x694d
movq %rsi, %rbx
movq %rdi, %r14
incq (%rsi)
callq 0x639f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
pushq $0xa
popq %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x5f8e
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6404
movq %r14, %rdi
movq %rbx, %rsi
callq 0x62fb
movq %rax, 0x20(%r15)
movq %r15, 0x10(%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b22(%rip), %rdi      # 0x9476
leaq 0x3626(%rip), %rsi      # 0x9f81
leaq 0x3924(%rip), %rcx      # 0xa286
movl $0x1de, %edx            # imm = 0x1DE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetExpression(Parser*, unsigned long*)
Node* GetExpression(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* result = GetSimpleExpression(parser, ofs);

    while (IsComparison(parser, ofs))
    {
        Value op = VALUE;        
        (*ofs)++;

        result = ConstructNode(MATH_TYPE, op, result, GetSimpleExpression(parser, ofs));
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x69e8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6bf0
movq %rax, %r12
pushq $0xe
popq %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c91
testb %al, %al
je 0x69d6
movq (%r14), %rax
movq (%rbx), %rcx
imulq $0x18, %rcx, %rdx
movq 0x8(%rax,%rdx), %r13
incq %rcx
movq %rcx, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6bf0
movl %r15d, %edi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x5ee3
movq %rax, %r12
jmp 0x6991
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a87(%rip), %rdi      # 0x9476
leaq 0x358b(%rip), %rsi      # 0x9f81
leaq 0x3772(%rip), %rcx      # 0xa16f
movl $0x151, %edx            # imm = 0x151
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckOpeningSquareBracket(Parser*, unsigned long*)
void CheckOpeningSquareBracket(Parser* parser, size_t* ofs)
{
    assert(parser);
 
    if (TYPE != TYPE_OP || VALUE.op != OPENING_SQUARE_BRACKET)
    {
        parser->status = MISSED_BRACKET;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6a4d
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6a2e
addq %rdx, %rcx
cmpl $0x15, 0x8(%rcx)
je 0x6a40
movl $0x4, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2a22(%rip), %rdi      # 0x9476
leaq 0x3526(%rip), %rsi      # 0x9f81
leaq 0x3927(%rip), %rcx      # 0xa389
movl $0x239, %edx            # imm = 0x239
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckClosingSquareBracket(Parser*, unsigned long*)
void CheckClosingSquareBracket(Parser* parser, size_t* ofs)
{
    assert(parser);
 
    if (TYPE != TYPE_OP || VALUE.op != CLOSING_SQUARE_BRACKET)
    {
        parser->status = MISSED_BRACKET;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6ab2
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6a93
addq %rdx, %rcx
cmpl $0x16, 0x8(%rcx)
je 0x6aa5
movl $0x4, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x29bd(%rip), %rdi      # 0x9476
leaq 0x34c1(%rip), %rsi      # 0x9f81
leaq 0x38f5(%rip), %rcx      # 0xa3bc
movl $0x246, %edx            # imm = 0x246
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetLValue(Parser*, unsigned long*)
Node* GetLValue(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* id = ID(nullptr, nullptr);

    if (TYPE == TYPE_OP && VALUE.op == OPENING_SQUARE_BRACKET)
    {
        CheckOpeningSquareBracket(parser, ofs);
        Node* expression = GetExpression(parser, ofs);
        CheckClosingSquareBracket(parser, ofs);
        return ConstructNode(MEM_ACCESS_TYPE, id, expression);
    }

    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6b6c
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
imulq $0x18, %rcx, %rcx
movq 0x8(%rax,%rcx), %rsi
pushq $0x4
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5ee3
movq %rax, %r15
movq (%r14), %rax
imulq $0x18, (%rbx), %rcx
cmpl $0x2, (%rax,%rcx)
jne 0x6b60
addq %rcx, %rax
cmpl $0x15, 0x8(%rax)
jne 0x6b60
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a07
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a6c
pushq $0x3
popq %rdi
movq %r15, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5f8e
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2903(%rip), %rdi      # 0x9476
leaq 0x3407(%rip), %rsi      # 0x9f81
leaq 0x35ca(%rip), %rcx      # 0xa14b
movl $0x140, %edx            # imm = 0x140
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: CheckAssigment(Parser*, unsigned long*)
void CheckAssigment(Parser* parser, size_t* ofs)
{
    assert(parser);
 
    if (TYPE != TYPE_OP || VALUE.op != ASSIGNMENT)
    {
        parser->status = ASSG_ERROR;
        CompilationError(parser, ofs);
    }

    (*ofs)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6bd1
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6bb2
addq %rdx, %rcx
cmpl $0x6, 0x8(%rcx)
je 0x6bc4
movl $0x9, 0x18(%rdi)
movq %rbx, %rsi
callq 0x511d
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x289e(%rip), %rdi      # 0x9476
leaq 0x33a2(%rip), %rsi      # 0x9f81
leaq 0x3831(%rip), %rcx      # 0xa417
movl $0x260, %edx            # imm = 0x260
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetSimpleExpression(Parser*, unsigned long*)
Node* GetSimpleExpression(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* result = GetTerm(parser, ofs);

    while (TYPE == TYPE_OP && (VALUE.op == PLUS || VALUE.op == MINUS))
    {
        Value op = VALUE;
        (*ofs)++;

        result = ConstructNode(MATH_TYPE, op, result, GetTerm(parser, ofs));
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6c72
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6cdf
movq %rax, %r12
pushq $0xe
popq %r15
movq (%r14), %rcx
movq (%rbx), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6c60
leaq (%rcx,%rdx), %rsi
movl 0x8(%rsi), %esi
andl $-0x2, %esi
cmpl $0xa, %esi
jne 0x6c60
movq 0x8(%rcx,%rdx), %r13
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6cdf
movl %r15d, %edi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x5ee3
movq %rax, %r12
jmp 0x6c15
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27fd(%rip), %rdi      # 0x9476
leaq 0x3301(%rip), %rsi      # 0x9f81
leaq 0x3510(%rip), %rcx      # 0xa197
movl $0x162, %edx            # imm = 0x162
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: IsComparison(Parser*, unsigned long*)
bool IsComparison(Parser* parser, size_t* ofs)
{
    assert(parser);

    return TYPE == TYPE_OP && (VALUE.op == EQUAL || VALUE.op == NOT_EQUAL ||
                               VALUE.op == ABOVE || VALUE.op == EABOVE ||
                               VALUE.op == BELOW || VALUE.op == EBELOW);
}

// Assembly:
testq %rdi, %rdi
je 0x6cbc
movq (%rdi), %rax
imulq $0x18, (%rsi), %rcx
cmpl $0x2, (%rax,%rcx)
jne 0x6cb7
addq %rcx, %rax
movl 0x8(%rax), %ecx
cmpl $0x12, %ecx
ja 0x6cb7
movl $0x7c200, %eax          # imm = 0x7C200
shrl %cl, %eax
jmp 0x6cb9
xorl %eax, %eax
andb $0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x27af(%rip), %rdi      # 0x9476
leaq 0x32b3(%rip), %rsi      # 0x9f81
leaq 0x376a(%rip), %rcx      # 0xa43f
movl $0x26d, %edx            # imm = 0x26D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetTerm(Parser*, unsigned long*)
Node* GetTerm(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* result = GetPrimaryExpression(parser, ofs);

    while (TYPE == TYPE_OP && (VALUE.op == MUL || VALUE.op == DIV))
    {
        Value op = VALUE;
        (*ofs)++;

        result = ConstructNode(MATH_TYPE, op, result, GetPrimaryExpression(parser, ofs));
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6d61
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6d80
movq %rax, %r12
pushq $0xe
popq %r15
movq (%r14), %rcx
movq (%rbx), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6d4f
leaq (%rcx,%rdx), %rsi
movl 0x8(%rsi), %esi
andl $-0x2, %esi
cmpl $0xc, %esi
jne 0x6d4f
movq 0x8(%rcx,%rdx), %r13
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d80
movl %r15d, %edi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x5ee3
movq %rax, %r12
jmp 0x6d04
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x270e(%rip), %rdi      # 0x9476
leaq 0x3212(%rip), %rsi      # 0x9f81
leaq 0x344f(%rip), %rcx      # 0xa1c5
movl $0x173, %edx            # imm = 0x173
callq 0x20b0