LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5871
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5890
movq %rdx, %r14
testq %rdx, %rdx
je 0x58af
movq %rdi, %r15
movq %rbx, %rsi
movq %r14, %rdx
callq 0x551d
testb %al, %al
jne 0x5864
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x565b
testb %al, %al
jne 0x5864
leaq -0x24(%rbp), %r12
movl $0x0, (%r12)
movl $0x20, %edi
movl $0x1, %esi
callq 0x20c0
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rax, 0x8(%r15,%rcx,8)
movq (%r14), %rdi
movq (%rbx), %rax
leaq (%rax,%rax,2), %rax
movq 0x8(%r15,%rax,8), %rdx
leaq 0x3d2a(%rip), %rsi      # 0x955d
movq %r12, %rcx
xorl %eax, %eax
callq 0x20f0
movq (%rbx), %rax
leaq (%rax,%rax,2), %rcx
movl $0x1, (%r15,%rcx,8)
movq (%r14), %rdx
movq %rdx, 0x10(%r15,%rcx,8)
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 0x3db3(%rip), %rdi      # 0x962b
leaq 0x3b33(%rip), %rsi      # 0x93b2
leaq 0x3cac(%rip), %rcx      # 0x9532
movl $0xf5, %edx
callq 0x20b0
leaq 0x3439(%rip), %rdi      # 0x8cd0
leaq 0x3b14(%rip), %rsi      # 0x93b2
leaq 0x3c8d(%rip), %rcx      # 0x9532
movl $0xf6, %edx
callq 0x20b0
leaq 0x39f2(%rip), %rdi      # 0x92a8
leaq 0x3af5(%rip), %rsi      # 0x93b2
leaq 0x3c6e(%rip), %rcx      # 0x9532
movl $0xf7, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5962
movq %rdx, %rbx
testq %rdx, %rdx
je 0x5981
movq (%rbx), %rax
movq %rax, %rcx
subq 0x8(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jae 0x5959
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4003(%rip), %r12      # 0x990e
cmpb $-0x1, (%rax)
je 0x5959
movq %rbx, %rdi
callq 0x54ac
movq (%rbx), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x5933
movq %r12, %rdi
callq 0x21a0
incq (%rbx)
jmp 0x5941
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x579e
movq %rbx, %rdi
callq 0x54ac
movq (%rbx), %rax
movq %rax, %rcx
subq 0x8(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jb 0x590b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cc2(%rip), %rdi      # 0x962b
leaq 0x3a42(%rip), %rsi      # 0x93b2
leaq 0x3bf3(%rip), %rcx      # 0x956a
movl $0x113, %edx            # imm = 0x113
callq 0x20b0
leaq 0x3920(%rip), %rdi      # 0x92a8
leaq 0x3a23(%rip), %rsi      # 0x93b2
leaq 0x3bd4(%rip), %rcx      # 0x956a
movl $0x114, %edx            # imm = 0x114
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59d0
movq %rsi, %rdx
testq %rsi, %rsi
je 0x59ef
leaq -0x10(%rbp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rsi
callq 0x58ce
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3c54(%rip), %rdi      # 0x962b
leaq 0x39d4(%rip), %rsi      # 0x93b2
leaq 0x3bb1(%rip), %rcx      # 0x9596
movl $0x12a, %edx            # imm = 0x12A
callq 0x20b0
leaq 0x38b2(%rip), %rdi      # 0x92a8
leaq 0x39b5(%rip), %rsi      # 0x93b2
leaq 0x3b92(%rip), %rcx      # 0x9596
movl $0x12b, %edx            # imm = 0x12B
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a9e
callq 0x52ac
movq %rax, %rbx
callq 0x5328
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x59a0
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x20c0
movq %rax, %r12
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x5a0e
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3964(%rip), %rdi      # 0x9409
leaq 0x3906(%rip), %rsi      # 0x93b2
leaq 0x3b1e(%rip), %rcx      # 0x95d1
movl $0x13d, %edx            # imm = 0x13D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5aed
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x5b0c
cmpq $0x0, (%rbx)
je 0x5b2b
callq 0x2140
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
leaq 0x3982(%rip), %rdi      # 0x9476
leaq 0x38b7(%rip), %rsi      # 0x93b2
leaq 0x3aeb(%rip), %rcx      # 0x95ed
movl $0x152, %edx            # imm = 0x152
callq 0x20b0
leaq 0x3af8(%rip), %rdi      # 0x960b
leaq 0x3898(%rip), %rsi      # 0x93b2
leaq 0x3acc(%rip), %rcx      # 0x95ed
movl $0x153, %edx            # imm = 0x153
callq 0x20b0
leaq 0x3af1(%rip), %rdi      # 0x9623
leaq 0x3879(%rip), %rsi      # 0x93b2
leaq 0x3aad(%rip), %rcx      # 0x95ed
movl $0x154, %edx            # imm = 0x154
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c4b
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x5c3c
movl $0x8, %r13d
leaq 0x3ac0(%rip), %r14      # 0x9668
leaq 0x3b19(%rip), %r15      # 0x96c8
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movl -0x8(%rax,%r13), %ecx
cmpl $0x2, %ecx
je 0x5bf6
cmpl $0x1, %ecx
je 0x5be2
testl %ecx, %ecx
jne 0x5c1c
movl (%rax,%r13), %esi
leaq 0x3a8f(%rip), %rdi      # 0x966f
jmp 0x5c24
movq (%rax,%r13), %rsi
leaq 0x3a9d(%rip), %rdi      # 0x968a
xorl %eax, %eax
callq 0x2040
jmp 0x5c2b
movslq (%rax,%r13), %rdx
movq %rdx, %rax
shlq $0x5, %rax
leaq 0x7e48(%rip), %rcx      # 0xda50
movq (%rax,%rcx), %rsi
leaq 0x3a94(%rip), %rdi      # 0x96a7
xorl %eax, %eax
callq 0x2040
jmp 0x5c2b
movq %r15, %rdi
movl $0x17b, %esi            # imm = 0x17B
xorl %eax, %eax
callq 0x2040
incq %r12
addq $0x18, %r13
cmpq 0x8(%rbx), %r12
jb 0x5bb2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3824(%rip), %rdi      # 0x9476
leaq 0x3759(%rip), %rsi      # 0x93b2
leaq 0x39ee(%rip), %rcx      # 0x964e
movl $0x163, %edx            # imm = 0x163
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8576(%rip), %rdi      # 0xe210
leaq 0x360c(%rip), %rsi      # 0x92ad
callq 0x2130
movq $0x0, -0x10(%rbp)
testq %rax, %rax
je 0x5cd3
movq %rax, %rbx
leaq 0x3d19(%rip), %rsi      # 0x99d6
leaq -0x10(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
callq 0x2100
movq 0x8536(%rip), %rdi      # 0xe210
leaq 0x2c19(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %rbx
movq -0x10(%rbp), %rdx
incq %rdx
leaq 0x3cdf(%rip), %rsi      # 0x99d6
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_O1/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 0x5db7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5dd6
movq %rdi, %r14
callq 0x5c8d
xorl %r12d, %r12d
leaq -0x30(%rbp), %r15
movb %r12b, 0x4(%r15)
movl $0x0, (%r15)
leaq 0x3c7e(%rip), %rdx      # 0x99d6
movl $0x5, %esi
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 0x3c1c(%rip), %rdi      # 0x99da
leaq 0x3c1d(%rip), %rsi      # 0x99e2
leaq 0x3c2f(%rip), %rcx      # 0x99fb
movl $0x30, %edx
callq 0x20b0
leaq 0x3c3c(%rip), %rdi      # 0x9a19
leaq 0x3bfe(%rip), %rsi      # 0x99e2
leaq 0x3c10(%rip), %rcx      # 0x99fb
movl $0x31, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x61a9
movq %rdi, %rbx
leaq 0x3e31(%rip), %rdi      # 0x9ef8
callq 0x20e0
movq 0x8135(%rip), %rdi      # 0xe208
leaq 0x2820(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %r14
leaq 0x3e1c(%rip), %rdi      # 0x9f05
movl $0xb, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x21f0
leaq 0x3e0f(%rip), %rdi      # 0x9f11
movl $0x16, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x21f0
movq (%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5df5
movl $0x7d, %edi
movq %r14, %rsi
callq 0x2150
movq %r14, %rdi
callq 0x2100
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rbx
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq 0x80b4(%rip), %rcx      # 0xe208
leaq 0x3dcd(%rip), %rdx      # 0x9f28
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21b0
movaps 0x42cf(%rip), %xmm0     # 0xa440
leaq -0x30(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0x42af(%rip), %xmm0     # 0xa430
movaps %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2aaa(%rip), %rdi      # 0x8c5a
leaq 0x382b(%rip), %rsi      # 0x99e2
leaq 0x3d24(%rip), %rcx      # 0x9ee2
movl $0xc6, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edi
movl $0x28, %esi
callq 0x20c0
testq %rax, %rax
je 0x622a
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
popq %rbp
retq
leaq 0x3d3b(%rip), %rdi      # 0x9f6c
leaq 0x3d0d(%rip), %rsi      # 0x9f45
leaq 0x3d32(%rip), %rcx      # 0x9f71
movl $0x37, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
movl $0x1, %edi
movl $0x28, %esi
callq 0x20c0
testq %rax, %rax
je 0x62be
movl %r12d, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
cmpl $0xe, %r12d
jne 0x62a3
leal -0x9(%r15), %ecx
cmpl $0x9, %ecx
ja 0x629f
movl %ecx, %ecx
leaq 0x36ed(%rip), %rdx      # 0x9988
movl (%rdx,%rcx,4), %r15d
movl %r15d, 0x8(%rax)
testq %r14, %r14
je 0x62ac
movq %rax, 0x10(%r14)
testq %rbx, %rbx
je 0x62b5
movq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ca7(%rip), %rdi      # 0x9f6c
leaq 0x3c79(%rip), %rsi      # 0x9f45
leaq 0x3cae(%rip), %rcx      # 0x9f81
movl $0x43, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6387
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x6359
movq 0x20(%rbx), %rdi
callq 0x6359
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x63f1
movq %rdi, %rbx
callq 0x61c8
movq %rax, %r14
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x6410
movq %rax, (%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x307e(%rip), %rdi      # 0x9476
leaq 0x3b46(%rip), %rsi      # 0x9f45
leaq 0x3be2(%rip), %rcx      # 0x9fe8
movl $0x8e, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64ba
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,8), %r12d
callq 0x64d9
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x6249
movq %rax, %r15
cmpl $0x1, %r12d
sete 0x8(%rax)
movq (%rbx), %rcx
cmpq 0x8(%r14), %rcx
jae 0x64a8
movq %r15, %r12
movq (%r14), %rax
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,8), %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64d9
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x6249
cmpl $0x1, %r13d
movq %rax, 0x18(%r12)
movq %r12, 0x10(%rax)
sete 0x8(%rax)
movq (%rbx), %rcx
movq %rax, %r12
cmpq 0x8(%r14), %rcx
jb 0x6466
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2fb5(%rip), %rdi      # 0x9476
leaq 0x3a7d(%rip), %rsi      # 0x9f45
leaq 0x3b31(%rip), %rcx      # 0xa000
movl $0x9b, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6582
movq %rsi, %rbx
testq %rsi, %rsi
je 0x65a1
movq %rdi, %r14
movq (%rdi), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6515
leaq (%rax,%rcx,8), %rax
cmpl $0x2, 0x8(%rax)
jb 0x6528
movl $0x1, 0x18(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x53c4
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movq (%r14), %rcx
leaq 0x2(%rax), %rdx
movq %rdx, (%rbx)
leaq (%rax,%rax,2), %rax
movq 0x20(%rcx,%rax,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65c0
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66a3
movq %rax, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2eed(%rip), %rdi      # 0x9476
leaq 0x39b5(%rip), %rsi      # 0x9f45
leaq 0x3a8b(%rip), %rcx      # 0xa022
movl $0xb2, %edx
callq 0x20b0
leaq 0x2728(%rip), %rdi      # 0x8cd0
leaq 0x3996(%rip), %rsi      # 0x9f45
leaq 0x3a6c(%rip), %rcx      # 0xa022
movl $0xb3, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x6684
movq %rsi, %rbx
movq %rdi, %r14
callq 0x674b
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x1, (%rcx,%rdx,8)
jne 0x666a
leaq (%rcx,%rdx,8), %rcx
incq %rax
movq %rax, (%rbx)
movq 0x8(%rcx), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rdx
leaq (%rdx,%rdx,2), %rax
cmpl $0x2, (%rcx,%rax,8)
jne 0x666d
leaq (%rcx,%rax,8), %rsi
movq %r15, %r12
cmpl $0x18, 0x8(%rsi)
jne 0x666d
leaq 0x2(%rdx), %rax
movq %rax, (%rbx)
leaq (%rdx,%rdx,2), %rax
movq 0x20(%rcx,%rax,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, 0x20(%r12)
movq %r12, 0x10(%rax)
movq (%r14), %rcx
movq (%rbx), %rdx
leaq (%rdx,%rdx,2), %rsi
leaq (%rcx,%rsi,8), %rsi
cmpl $0x2, (%rsi)
movq %rax, %r12
je 0x6625
jmp 0x666d
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67ab
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2deb(%rip), %rdi      # 0x9476
leaq 0x38b3(%rip), %rsi      # 0x9f45
leaq 0x39b1(%rip), %rcx      # 0xa04a
movl $0xc6, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x672c
movq %rsi, %rbx
movq %rdi, %r14
callq 0x680b
movl $0x6, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq %rax, %r12
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x66ee
leaq (%rax,%rcx,8), %rax
cmpl $0x8, 0x8(%rax)
je 0x6715
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686b
movl $0x7, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x6249
movq %rax, 0x20(%r12)
movq %r12, 0x10(%rax)
jmp 0x66d1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x69a1
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d43(%rip), %rdi      # 0x9476
leaq 0x380b(%rip), %rsi      # 0x9f45
leaq 0x392b(%rip), %rcx      # 0xa06c
movl $0xe2, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x678c
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6773
leaq (%rax,%rcx,8), %rax
cmpl $0x13, 0x8(%rax)
je 0x6782
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2ce3(%rip), %rdi      # 0x9476
leaq 0x37ab(%rip), %rsi      # 0x9f45
leaq 0x3b48(%rip), %rcx      # 0xa2e9
movl $0x21f, %edx            # imm = 0x21F
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67ec
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x67d3
leaq (%rax,%rcx,8), %rax
cmpl $0x14, 0x8(%rax)
je 0x67e2
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2c83(%rip), %rdi      # 0x9476
leaq 0x374b(%rip), %rsi      # 0x9f45
leaq 0x3b1a(%rip), %rcx      # 0xa31b
movl $0x22c, %edx            # imm = 0x22C
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x684c
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6833
leaq (%rax,%rcx,8), %rax
cmpl $0x7, 0x8(%rax)
je 0x6842
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2c23(%rip), %rdi      # 0x9476
leaq 0x36eb(%rip), %rsi      # 0x9f45
leaq 0x3a32(%rip), %rcx      # 0xa293
movl $0x205, %edx            # imm = 0x205
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6982
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rdx
leaq (%rdx,%rdx,2), %rcx
leaq (%rax,%rcx,8), %rax
movl (%rax), %ecx
cmpl $0x2, %ecx
jne 0x689f
cmpl $0x0, 0x8(%rax)
je 0x68e6
cmpl $0x1, %ecx
jne 0x68c7
cmpl $0x2, 0x18(%rax)
jne 0x68c7
movl 0x20(%rax), %edx
cmpl $0x15, %edx
je 0x68b7
cmpl $0x6, %edx
jne 0x68c7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6afb
jmp 0x6966
cmpl $0x2, %ecx
jne 0x695b
cmpl $0x3, 0x8(%rax)
jne 0x6905
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6b69
jmp 0x6966
incq %rdx
movq %rdx, (%rbx)
cmpl $0x2, 0x30(%rax)
jne 0x6925
cmpl $0x15, 0x38(%rax)
jne 0x6925
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a01
jmp 0x6966
cmpl $0x2, %ecx
jne 0x695b
cmpl $0x4, 0x8(%rax)
jne 0x693b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6bcc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6afb
movq %rax, %r15
movl $0x1, (%rax)
jmp 0x6969
cmpl $0x2, %ecx
jne 0x695b
cmpl $0x2, 0x8(%rax)
jne 0x695b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6ca3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a9b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2aed(%rip), %rdi      # 0x9476
leaq 0x35b5(%rip), %rsi      # 0x9f45
leaq 0x36fb(%rip), %rcx      # 0xa092
movl $0xf7, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x69e2
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x69c9
leaq (%rax,%rcx,8), %rax
cmpl $0x8, 0x8(%rax)
je 0x69d8
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2a8d(%rip), %rdi      # 0x9476
leaq 0x3555(%rip), %rsi      # 0x9f45
leaq 0x38c7(%rip), %rcx      # 0xa2be
movl $0x212, %edx            # imm = 0x212
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6a7c
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6de0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6e40
movl $0x2, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6249
leaq 0x29f3(%rip), %rdi      # 0x9476
leaq 0x34bb(%rip), %rsi      # 0x9f45
leaq 0x3628(%rip), %rcx      # 0xa0b9
movl $0x129, %edx            # imm = 0x129
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6adc
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6ac3
leaq (%rax,%rcx,8), %rax
cmpl $0x17, 0x8(%rax)
je 0x6ad2
movl $0x3, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2993(%rip), %rdi      # 0x9476
leaq 0x345b(%rip), %rsi      # 0x9f45
leaq 0x38c2(%rip), %rcx      # 0xa3b3
movl $0x253, %edx            # imm = 0x253
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6b4a
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6ea0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f64
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movl $0xb, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6249
leaq 0x2925(%rip), %rdi      # 0x9476
leaq 0x33ed(%rip), %rsi      # 0x9f45
leaq 0x3588(%rip), %rcx      # 0xa0e7
movl $0x136, %edx            # imm = 0x136
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6bad
movq (%rsi), %rcx
incq %rcx
movq %rcx, (%rsi)
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
je 0x6b92
leaq (%rax,%rcx,8), %rax
cmpl $0x17, 0x8(%rax)
jne 0x6b96
xorl %ecx, %ecx
jmp 0x6b9e
callq 0x6d2a
movq %rax, %rcx
movl $0xd, %edi
xorl %esi, %esi
xorl %edx, %edx
popq %rbp
jmp 0x6249
leaq 0x28c2(%rip), %rdi      # 0x9476
leaq 0x338a(%rip), %rsi      # 0x9f45
leaq 0x3642(%rip), %rcx      # 0xa204
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c84
movq %rsi, %rbx
movq %rdi, %r14
incq (%rsi)
callq 0x674b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movl $0x8, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67ab
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66a3
movl $0x9, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x6249
movq %rax, 0x20(%r15)
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6c76
leaq (%rcx,%rdx,8), %rcx
cmpl $0x5, 0x8(%rcx)
jne 0x6c76
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66a3
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 0x27eb(%rip), %rdi      # 0x9476
leaq 0x32b3(%rip), %rsi      # 0x9f45
leaq 0x35d3(%rip), %rcx      # 0xa26c
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d0b
movq %rsi, %rbx
movq %rdi, %r14
incq (%rsi)
callq 0x674b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movl $0xa, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67ab
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66a3
movq %rax, 0x20(%r15)
movq %r15, 0x10(%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2764(%rip), %rdi      # 0x9476
leaq 0x322c(%rip), %rsi      # 0x9f45
leaq 0x352a(%rip), %rcx      # 0xa24a
movl $0x1de, %edx            # imm = 0x1DE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x6dc1
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6fc4
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6db5
leaq (%rcx,%rdx,8), %rdx
movl 0x8(%rdx), %edx
leal -0xe(%rdx), %esi
cmpl $0x5, %esi
jae 0x6db0
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %r12
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6fc4
movl $0xe, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x6249
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpl $0x2, (%rdx)
je 0x6d60
jmp 0x6db5
cmpl $0x9, %edx
je 0x6d6b
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26ae(%rip), %rdi      # 0x9476
leaq 0x3176(%rip), %rsi      # 0x9f45
leaq 0x335d(%rip), %rcx      # 0xa133
movl $0x151, %edx            # imm = 0x151
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e21
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6e08
leaq (%rax,%rcx,8), %rax
cmpl $0x15, 0x8(%rax)
je 0x6e17
movl $0x4, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x264e(%rip), %rdi      # 0x9476
leaq 0x3116(%rip), %rsi      # 0x9f45
leaq 0x3517(%rip), %rcx      # 0xa34d
movl $0x239, %edx            # imm = 0x239
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e81
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6e68
leaq (%rax,%rcx,8), %rax
cmpl $0x16, 0x8(%rax)
je 0x6e77
movl $0x4, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x25ee(%rip), %rdi      # 0x9476
leaq 0x30b6(%rip), %rsi      # 0x9f45
leaq 0x34ea(%rip), %rcx      # 0xa380
movl $0x246, %edx            # imm = 0x246
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6f45
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6f39
leaq (%rax,%rcx,8), %rax
cmpl $0x15, 0x8(%rax)
jne 0x6f39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6de0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6e40
movl $0x3, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6249
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x252a(%rip), %rdi      # 0x9476
leaq 0x2ff2(%rip), %rsi      # 0x9f45
leaq 0x31b5(%rip), %rcx      # 0xa10f
movl $0x140, %edx            # imm = 0x140
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6fa5
movq %rsi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6f8c
leaq (%rax,%rcx,8), %rax
cmpl $0x6, 0x8(%rax)
je 0x6f9b
movl $0x9, 0x18(%rdi)
movq %rbx, %rsi
callq 0x53c4
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x24ca(%rip), %rdi      # 0x9476
leaq 0x2f92(%rip), %rsi      # 0x9f45
leaq 0x3421(%rip), %rcx      # 0xa3db
movl $0x260, %edx            # imm = 0x260
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x7050
movq %rsi, %rbx
movq %rdi, %r14
callq 0x70c1
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x7044
leaq (%rcx,%rdx,8), %rdx
movl 0x8(%rdx), %edx
andl $-0x2, %edx
cmpl $0xa, %edx
jne 0x7044
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %r12
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70c1
movl $0xe, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x6249
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpl $0x2, (%rdx)
je 0x6ff6
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x241f(%rip), %rdi      # 0x9476
leaq 0x2ee7(%rip), %rsi      # 0x9f45
leaq 0x30f6(%rip), %rcx      # 0xa15b
movl $0x162, %edx            # imm = 0x162
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x709e
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x7099
leaq (%rax,%rcx,8), %rax
movl 0x8(%rax), %ecx
cmpl $0x12, %ecx
ja 0x7099
movl $0x7c200, %eax          # imm = 0x7C200
shrl %cl, %eax
jmp 0x709b
xorl %eax, %eax
andb $0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x23cd(%rip), %rdi      # 0x9476
leaq 0x2e95(%rip), %rsi      # 0x9f45
leaq 0x334c(%rip), %rcx      # 0xa403
movl $0x26d, %edx            # imm = 0x26D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x714d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x716c
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x7141
leaq (%rcx,%rdx,8), %rdx
movl 0x8(%rdx), %edx
andl $-0x2, %edx
cmpl $0xc, %edx
jne 0x7141
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %r12
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x716c
movl $0xe, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x6249
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpl $0x2, (%rdx)
je 0x70f3
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2322(%rip), %rdi      # 0x9476
leaq 0x2dea(%rip), %rsi      # 0x9f45
leaq 0x3027(%rip), %rcx      # 0xa189
movl $0x173, %edx            # imm = 0x173
callq 0x20b0