LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d27
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5d46
movq %rdi, %r14
callq 0x5bfd
xorl %r12d, %r12d
leaq -0x30(%rbp), %r15
movb %r12b, 0x4(%r15)
movl $0x0, (%r15)
leaq 0x3d22(%rip), %rdx      # 0x99ea
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 0x3cc0(%rip), %rdi      # 0x99ee
leaq 0x3cc1(%rip), %rsi      # 0x99f6
leaq 0x3cd3(%rip), %rcx      # 0x9a0f
movl $0x30, %edx
callq 0x20b0
leaq 0x3ce0(%rip), %rdi      # 0x9a2d
leaq 0x3ca2(%rip), %rsi      # 0x99f6
leaq 0x3cb4(%rip), %rcx      # 0x9a0f
movl $0x31, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6119
movq %rdi, %rbx
leaq 0x3ed5(%rip), %rdi      # 0x9f0c
callq 0x20e0
movq 0x81c5(%rip), %rdi      # 0xe208
leaq 0x28b0(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %r14
leaq 0x3ec0(%rip), %rdi      # 0x9f19
movl $0xb, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x21f0
leaq 0x3eb3(%rip), %rdi      # 0x9f25
movl $0x16, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x21f0
movq (%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5d65
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 0x8144(%rip), %rcx      # 0xe208
leaq 0x3e71(%rip), %rdx      # 0x9f3c
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21b0
movaps 0x436f(%rip), %xmm0     # 0xa450
leaq -0x30(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0x434f(%rip), %xmm0     # 0xa440
movaps %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c84
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2b3a(%rip), %rdi      # 0x8c5a
leaq 0x38cf(%rip), %rsi      # 0x99f6
leaq 0x3dc8(%rip), %rcx      # 0x9ef6
movl $0xc6, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x618b
popq %rbp
retq
leaq 0x3dee(%rip), %rdi      # 0x9f80
leaq 0x3dc0(%rip), %rsi      # 0x9f59
leaq 0x3de5(%rip), %rcx      # 0x9f85
movl $0x37, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x621f
movl %r12d, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
cmpl $0xe, %r12d
jne 0x6204
leal -0x9(%r15), %ecx
cmpl $0x9, %ecx
ja 0x6200
movl %ecx, %ecx
leaq 0x37a0(%rip), %rdx      # 0x999c
movl (%rdx,%rcx,4), %r15d
movl %r15d, 0x8(%rax)
testq %r14, %r14
je 0x620d
movq %rax, 0x10(%r14)
testq %rbx, %rbx
je 0x6216
movq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d5a(%rip), %rdi      # 0x9f80
leaq 0x3d2c(%rip), %rsi      # 0x9f59
leaq 0x3d61(%rip), %rcx      # 0x9f95
movl $0x43, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62e8
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x62ba
movq 0x20(%rbx), %rdi
callq 0x62ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6352
movq %rdi, %rbx
callq 0x6138
movq %rax, %r14
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x6371
movq %rax, (%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x311d(%rip), %rdi      # 0x9476
leaq 0x3bf9(%rip), %rsi      # 0x9f59
leaq 0x3c95(%rip), %rcx      # 0x9ffc
movl $0x8e, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x641b
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,8), %r12d
callq 0x643a
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x61aa
movq %rax, %r15
cmpl $0x1, %r12d
sete 0x8(%rax)
movq (%rbx), %rcx
cmpq 0x8(%r14), %rcx
jae 0x6409
movq %r15, %r12
movq (%r14), %rax
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,8), %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x643a
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x61aa
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 0x63c7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3054(%rip), %rdi      # 0x9476
leaq 0x3b30(%rip), %rsi      # 0x9f59
leaq 0x3be4(%rip), %rcx      # 0xa014
movl $0x9b, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64dc
movq %rsi, %rbx
testq %rsi, %rsi
je 0x64fb
movq %rdi, %r14
movq (%rdi), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rdx
cmpl $0x2, (%rax,%rdx,8)
jne 0x6476
leaq (%rax,%rdx,8), %rdx
cmpl $0x2, 0x8(%rdx)
jb 0x648f
movl $0x1, 0x18(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rcx
movq (%r14), %rax
leaq 0x2(%rcx), %rdx
movq %rdx, (%rbx)
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x651a
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65fd
movq %rax, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f93(%rip), %rdi      # 0x9476
leaq 0x3a6f(%rip), %rsi      # 0x9f59
leaq 0x3b45(%rip), %rcx      # 0xa036
movl $0xb2, %edx
callq 0x20b0
leaq 0x27ce(%rip), %rdi      # 0x8cd0
leaq 0x3a50(%rip), %rsi      # 0x9f59
leaq 0x3b26(%rip), %rcx      # 0xa036
movl $0xb3, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x65de
movq %rsi, %rbx
movq %rdi, %r14
callq 0x66a5
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x1, (%rcx,%rdx,8)
jne 0x65c4
leaq (%rcx,%rdx,8), %rcx
incq %rax
movq %rax, (%rbx)
movq 0x8(%rcx), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rdx
leaq (%rdx,%rdx,2), %rax
cmpl $0x2, (%rcx,%rax,8)
jne 0x65c7
leaq (%rcx,%rax,8), %rsi
movq %r15, %r12
cmpl $0x18, 0x8(%rsi)
jne 0x65c7
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 0x61aa
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 0x657f
jmp 0x65c7
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x670b
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e91(%rip), %rdi      # 0x9476
leaq 0x396d(%rip), %rsi      # 0x9f59
leaq 0x3a6b(%rip), %rcx      # 0xa05e
movl $0xc6, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6686
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6771
movl $0x6, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r15
movq %rax, %r12
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6648
leaq (%rax,%rcx,8), %rax
cmpl $0x8, 0x8(%rax)
je 0x666f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67d7
movl $0x7, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, 0x20(%r12)
movq %r12, 0x10(%rax)
jmp 0x662b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68fd
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2de9(%rip), %rdi      # 0x9476
leaq 0x38c5(%rip), %rsi      # 0x9f59
leaq 0x39e5(%rip), %rcx      # 0xa080
movl $0xe2, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66ec
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x66cd
leaq (%rcx,%rdx,8), %rcx
cmpl $0x13, 0x8(%rcx)
je 0x66df
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2d83(%rip), %rdi      # 0x9476
leaq 0x385f(%rip), %rsi      # 0x9f59
leaq 0x3bfc(%rip), %rcx      # 0xa2fd
movl $0x21f, %edx            # imm = 0x21F
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6752
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6733
leaq (%rcx,%rdx,8), %rcx
cmpl $0x14, 0x8(%rcx)
je 0x6745
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2d1d(%rip), %rdi      # 0x9476
leaq 0x37f9(%rip), %rsi      # 0x9f59
leaq 0x3bc8(%rip), %rcx      # 0xa32f
movl $0x22c, %edx            # imm = 0x22C
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67b8
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6799
leaq (%rcx,%rdx,8), %rcx
cmpl $0x7, 0x8(%rcx)
je 0x67ab
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2cb7(%rip), %rdi      # 0x9476
leaq 0x3793(%rip), %rsi      # 0x9f59
leaq 0x3ada(%rip), %rcx      # 0xa2a7
movl $0x205, %edx            # imm = 0x205
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68de
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rdx
leaq (%rax,%rdx,8), %rax
movl (%rax), %edx
cmpl $0x1, %edx
je 0x684a
cmpl $0x2, %edx
jne 0x686a
movl 0x8(%rax), %edx
cmpq $0x4, %rdx
ja 0x686a
leaq 0x316e(%rip), %rsi      # 0x9988
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
incq %rcx
movq %rcx, (%rbx)
cmpl $0x2, 0x30(%rax)
jne 0x68c8
cmpl $0x15, 0x38(%rax)
jne 0x68c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6963
jmp 0x6875
cmpl $0x2, 0x18(%rax)
jne 0x686a
movl 0x20(%rax), %eax
cmpl $0x15, %eax
je 0x685d
cmpl $0x6, %eax
jne 0x686a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a63
jmp 0x6875
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x69fd
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6ad1
jmp 0x6875
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6c0b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6b34
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a63
movq %rax, %r15
movl $0x1, (%rax)
jmp 0x6878
leaq 0x2b91(%rip), %rdi      # 0x9476
leaq 0x366d(%rip), %rsi      # 0x9f59
leaq 0x37b3(%rip), %rcx      # 0xa0a6
movl $0xf7, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6944
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6925
leaq (%rcx,%rdx,8), %rcx
cmpl $0x8, 0x8(%rcx)
je 0x6937
movl $0x2, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2b2b(%rip), %rdi      # 0x9476
leaq 0x3607(%rip), %rsi      # 0x9f59
leaq 0x3979(%rip), %rcx      # 0xa2d2
movl $0x212, %edx            # imm = 0x212
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x69de
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 0x61aa
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d48
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6dae
movl $0x2, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61aa
leaq 0x2a91(%rip), %rdi      # 0x9476
leaq 0x356d(%rip), %rsi      # 0x9f59
leaq 0x36da(%rip), %rcx      # 0xa0cd
movl $0x129, %edx            # imm = 0x129
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6a44
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6a25
leaq (%rcx,%rdx,8), %rcx
cmpl $0x17, 0x8(%rcx)
je 0x6a37
movl $0x3, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2a2b(%rip), %rdi      # 0x9476
leaq 0x3507(%rip), %rsi      # 0x9f59
leaq 0x396e(%rip), %rcx      # 0xa3c7
movl $0x253, %edx            # imm = 0x253
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6ab2
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6e14
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6ed8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movl $0xb, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x61aa
leaq 0x29bd(%rip), %rdi      # 0x9476
leaq 0x3499(%rip), %rsi      # 0x9f59
leaq 0x3634(%rip), %rcx      # 0xa0fb
movl $0x136, %edx            # imm = 0x136
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6b15
movq (%rsi), %rcx
incq %rcx
movq %rcx, (%rsi)
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
je 0x6afa
leaq (%rax,%rcx,8), %rax
cmpl $0x17, 0x8(%rax)
jne 0x6afe
xorl %ecx, %ecx
jmp 0x6b06
callq 0x6c92
movq %rax, %rcx
movl $0xd, %edi
xorl %esi, %esi
xorl %edx, %edx
popq %rbp
jmp 0x61aa
leaq 0x295a(%rip), %rdi      # 0x9476
leaq 0x3436(%rip), %rsi      # 0x9f59
leaq 0x36ee(%rip), %rcx      # 0xa218
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6bec
movq %rsi, %rbx
movq %rdi, %r14
incq (%rsi)
callq 0x66a5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movl $0x8, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x670b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65fd
movl $0x9, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, 0x20(%r15)
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6bde
leaq (%rcx,%rdx,8), %rcx
cmpl $0x5, 0x8(%rcx)
jne 0x6bde
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65fd
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 0x2883(%rip), %rdi      # 0x9476
leaq 0x335f(%rip), %rsi      # 0x9f59
leaq 0x367f(%rip), %rcx      # 0xa280
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6c73
movq %rsi, %rbx
movq %rdi, %r14
incq (%rsi)
callq 0x66a5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movl $0xa, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x670b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65fd
movq %rax, 0x20(%r15)
movq %r15, 0x10(%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27fc(%rip), %rdi      # 0x9476
leaq 0x32d8(%rip), %rsi      # 0x9f59
leaq 0x35d6(%rip), %rcx      # 0xa25e
movl $0x1de, %edx            # imm = 0x1DE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d29
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6f3e
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6d1d
leaq (%rcx,%rdx,8), %rdx
movl 0x8(%rdx), %edx
leal -0xe(%rdx), %esi
cmpl $0x5, %esi
jae 0x6d18
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %r12
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f3e
movl $0xe, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x61aa
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpl $0x2, (%rdx)
je 0x6cc8
jmp 0x6d1d
cmpl $0x9, %edx
je 0x6cd3
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2746(%rip), %rdi      # 0x9476
leaq 0x3222(%rip), %rsi      # 0x9f59
leaq 0x3409(%rip), %rcx      # 0xa147
movl $0x151, %edx            # imm = 0x151
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d8f
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6d70
leaq (%rcx,%rdx,8), %rcx
cmpl $0x15, 0x8(%rcx)
je 0x6d82
movl $0x4, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x26e0(%rip), %rdi      # 0x9476
leaq 0x31bc(%rip), %rsi      # 0x9f59
leaq 0x35bd(%rip), %rcx      # 0xa361
movl $0x239, %edx            # imm = 0x239
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6df5
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6dd6
leaq (%rcx,%rdx,8), %rcx
cmpl $0x16, 0x8(%rcx)
je 0x6de8
movl $0x4, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x267a(%rip), %rdi      # 0x9476
leaq 0x3156(%rip), %rsi      # 0x9f59
leaq 0x358a(%rip), %rcx      # 0xa394
movl $0x246, %edx            # imm = 0x246
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6eb9
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 0x61aa
movq %rax, %r15
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x6ead
leaq (%rax,%rcx,8), %rax
cmpl $0x15, 0x8(%rax)
jne 0x6ead
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d48
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6dae
movl $0x3, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61aa
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25b6(%rip), %rdi      # 0x9476
leaq 0x3092(%rip), %rsi      # 0x9f59
leaq 0x3255(%rip), %rcx      # 0xa123
movl $0x140, %edx            # imm = 0x140
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6f1f
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6f00
leaq (%rcx,%rdx,8), %rcx
cmpl $0x6, 0x8(%rcx)
je 0x6f12
movl $0x9, 0x18(%rdi)
movq %rbx, %rsi
callq 0x52f0
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2550(%rip), %rdi      # 0x9476
leaq 0x302c(%rip), %rsi      # 0x9f59
leaq 0x34bb(%rip), %rcx      # 0xa3ef
movl $0x260, %edx            # imm = 0x260
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6fca
movq %rsi, %rbx
movq %rdi, %r14
callq 0x703b
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x6fbe
leaq (%rcx,%rdx,8), %rdx
movl 0x8(%rdx), %edx
andl $-0x2, %edx
cmpl $0xa, %edx
jne 0x6fbe
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %r12
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x703b
movl $0xe, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x61aa
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpl $0x2, (%rdx)
je 0x6f70
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24a5(%rip), %rdi      # 0x9476
leaq 0x2f81(%rip), %rsi      # 0x9f59
leaq 0x3190(%rip), %rcx      # 0xa16f
movl $0x162, %edx            # imm = 0x162
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7018
movq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x7013
leaq (%rax,%rcx,8), %rax
movl 0x8(%rax), %ecx
cmpl $0x12, %ecx
ja 0x7013
movl $0x7c200, %eax          # imm = 0x7C200
shrl %cl, %eax
jmp 0x7015
xorl %eax, %eax
andb $0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2453(%rip), %rdi      # 0x9476
leaq 0x2f2f(%rip), %rsi      # 0x9f59
leaq 0x33e6(%rip), %rcx      # 0xa417
movl $0x26d, %edx            # imm = 0x26D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70c7
movq %rsi, %rbx
movq %rdi, %r14
callq 0x70e6
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x70bb
leaq (%rcx,%rdx,8), %rdx
movl 0x8(%rdx), %edx
andl $-0x2, %edx
cmpl $0xc, %edx
jne 0x70bb
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %r12
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70e6
movl $0xe, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x61aa
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpl $0x2, (%rdx)
je 0x706d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23a8(%rip), %rdi      # 0x9476
leaq 0x2e84(%rip), %rsi      # 0x9f59
leaq 0x30c1(%rip), %rcx      # 0xa19d
movl $0x173, %edx            # imm = 0x173
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetPrimaryExpression(Parser*, unsigned long*)
Node* GetPrimaryExpression(Parser* parser, size_t* ofs)
{
    assert(parser);

    if (TYPE == TYPE_OP && VALUE.op == OPENING_ROUND_BRACKET)
    {
        CheckOpeningRoundBracket(parser, ofs);
        Node* tmp = GetExpression(parser, ofs);
        CheckClosingRoundBracket(parser, ofs);

        return tmp;
    }

    if (TYPE == TYPE_ID)
    {
        if (NEXT_TYPE == TYPE_OP && NEXT_VALUE.op == OPENING_ROUND_BRACKET) // call
        {
            Node* tmp = ID(nullptr, nullptr);
            return ConstructNode(CALL_TYPE, tmp, GetParams(parser, ofs));             
        }
        else if (NEXT_TYPE == TYPE_OP && NEXT_VALUE.op == OPENING_SQUARE_BRACKET)
        {
            return GetMemoryAccess(parser, ofs);
        }
        else
        {
            return ID(nullptr, nullptr);
        }
    }

    int val = VALUE.number;
    (*ofs)++;

    return ConstructNode(NUMB_TYPE, { .number = val });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x71ed
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rsi
leaq (%rdx,%rsi,8), %rcx
movl (%rcx), %edi
cmpl $0x1, %edi
je 0x7157
cmpl $0x2, %edi
jne 0x71a0
movl 0x8(%rcx), %ecx
cmpl $0x13, %ecx
jne 0x71a3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66a5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x670b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incq %rax
leaq (%rax,%rax,2), %rdi
cmpl $0x2, (%rdx,%rdi,8)
jne 0x71cd
leaq (%rdx,%rdi,8), %rdi
cmpl $0x13, 0x8(%rdi)
jne 0x71b2
movq %rax, (%rbx)
movq 0x8(%rcx), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x720c
movl $0xc, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %rax, %rcx
jmp 0x71de
movl 0x8(%rcx), %ecx
incq %rax
movq %rax, (%rbx)
movl %ecx, %esi
movl $0xf, %edi
jmp 0x71da
cmpl $0x15, 0x20(%rcx)
jne 0x71cd
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7304
movq %rax, (%rbx)
movq 0x8(%rdx,%rsi,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x61aa
leaq 0x2282(%rip), %rdi      # 0x9476
leaq 0x2d5e(%rip), %rsi      # 0x9f59
leaq 0x2fbd(%rip), %rcx      # 0xa1bf
movl $0x184, %edx            # imm = 0x184
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetParams(Parser*, unsigned long*)
Node* GetParams(Parser* parser, size_t* ofs)
{
    assert(parser);

    CheckOpeningRoundBracket(parser, ofs);

    Node* result = nullptr;

    if (TYPE != TYPE_OP || VALUE.op != CLOSING_ROUND_BRACKET)
    {
        result = ConstructNode(ARG_TYPE, GetExpression(parser, ofs), nullptr);

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

            result->parent = ConstructNode(ARG_TYPE, GetExpression(parser, ofs), nullptr);
            result->parent->right = result;
            result = result->parent;
        }
    }

    CheckClosingRoundBracket(parser, ofs);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x72e5
movq %rsi, %rbx
movq %rdi, %r14
callq 0x66a5
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x724d
leaq (%rax,%rcx,8), %rax
cmpl $0x14, 0x8(%rax)
jne 0x724d
xorl %r12d, %r12d
jmp 0x72ce
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movl $0x5, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x72cb
leaq (%rcx,%rdx,8), %rcx
cmpl $0x18, 0x8(%rcx)
jne 0x72cb
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movl $0x5, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x61aa
movq %rax, %r12
movq %rax, 0x10(%r15)
movq %r15, 0x20(%rax)
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rcx
cmpl $0x2, (%rcx)
movq %r12, %r15
je 0x7280
jmp 0x72ce
movq %r15, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x670b
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x218a(%rip), %rdi      # 0x9476
leaq 0x2c66(%rip), %rsi      # 0x9f59
leaq 0x2f40(%rip), %rcx      # 0xa23a
movl $0x1c3, %edx            # imm = 0x1C3
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetMemoryAccess(Parser*, unsigned long*)
Node* GetMemoryAccess(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(MEM_ACCESS_TYPE, id, expression);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x737f
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 0x61aa
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d48
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c92
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6dae
movl $0x3, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61aa
leaq 0x20f0(%rip), %rdi      # 0x9476
leaq 0x2bcc(%rip), %rsi      # 0x9f59
leaq 0x2e5a(%rip), %rcx      # 0xa1ee
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/iotree.cpp
// Function: WriteToFile(Tree*, char const*)
void WriteToFile(Tree* tree, const char* output)
{
    assert(tree);
    assert(output);

    FILE* file = fopen(output, "w");
    assert(file);

    WriteToFileRecursively(tree->root, file);

    fclose(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x73e5
testq %rsi, %rsi
je 0x7404
movq %rdi, %rbx
leaq 0x153f(%rip), %rax      # 0x88fa
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2130
testq %rax, %rax
je 0x7423
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x7442
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
leaq 0x186e(%rip), %rdi      # 0x8c5a
leaq 0x306d(%rip), %rsi      # 0xa460
leaq 0x307f(%rip), %rcx      # 0xa479
movl $0x9, %edx
callq 0x20b0
leaq 0x3095(%rip), %rdi      # 0xa4a0
leaq 0x304e(%rip), %rsi      # 0xa460
leaq 0x3060(%rip), %rcx      # 0xa479
movl $0xa, %edx
callq 0x20b0
leaq 0x14d6(%rip), %rdi      # 0x8900
leaq 0x302f(%rip), %rsi      # 0xa460
leaq 0x3041(%rip), %rcx      # 0xa479
movl $0xd, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/iotree.cpp
// Function: WriteToFileRecursively(Node*, _IO_FILE*)
void WriteToFileRecursively(Node* node, FILE* file)
{
    assert(file);

    if (node == nullptr)
    {
        return;
    }

    fprintf(file, "%d | ", node->type);

    if (node->type == NUMB_TYPE)
    {
        fprintf(file, "%d ", node->value.number);
    }
    else if (node->type == ID_TYPE)
    {
        fprintf(file, "%s ", node->value.name);
    }
    else
    {
        fprintf(file, "%d ", node->value.op);
    }


    fprintf(file, "{ ");
    WriteToFileRecursively(node->left, file);
    fprintf(file, "} ");

    fprintf(file, "{ ");
    WriteToFileRecursively(node->right, file);
    fprintf(file, "} ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x7537
movq %rdi, %r14
testq %rdi, %rdi
je 0x7497
movq %rsi, %rbx
movl (%r14), %edx
leaq 0x3068(%rip), %rsi      # 0xa4d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movl (%r14), %eax
cmpl $0x4, %eax
je 0x74a0
cmpl $0xf, %eax
movl 0x8(%r14), %edx
leaq 0x304e(%rip), %rsi      # 0xa4d9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
jmp 0x74b5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
leaq 0x3032(%rip), %rsi      # 0xa4dd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
leaq 0x3025(%rip), %r15      # 0xa4e1
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x21f0
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x7442
leaq 0x3000(%rip), %r12      # 0xa4e4
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x21f0
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x21f0
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x7442
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
leaq 0x13c2(%rip), %rdi      # 0x8900
leaq 0x2f1b(%rip), %rsi      # 0xa460
leaq 0x2f5b(%rip), %rcx      # 0xa4a7
movl $0x16, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/iotree.cpp
// Function: GetTreeFromFile(char const*)
Tree* GetTreeFromFile(const char* file)
{
    assert(file);

    Buffer* buffer = GetBuffer(file);

    Tree* tree = NewTree();

    tree->root = ConstructNode(D_TYPE, { .op = 0 });
    buffer->str += 5;

    GetTreeFromBuffer(tree->root, buffer);

    DeleteFictiveNodes(tree->root);

    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x759d
callq 0x51d8
movq %rax, %rbx
callq 0x6138
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x626c
movq %rax, (%r14)
addq $0x5, (%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x75bc
movq (%r14), %rdi
callq 0x774e
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x135c(%rip), %rdi      # 0x8900
leaq 0x2eb5(%rip), %rsi      # 0xa460
leaq 0x2f35(%rip), %rcx      # 0xa4e7
movl $0x38, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/iotree.cpp
// Function: DeleteFictiveNodes(Node*)
void DeleteFictiveNodes(Node* node)
{
    assert(node);

    if (node->left == nullptr && node->right == nullptr)
    {
        if (node->parent->left == node)
        {
            node->parent->left = nullptr;
        }
        else
        {
            node->parent->right = nullptr;
        }

        free(node);
    }
    else
    {
        if (node->left != nullptr)
        {
            DeleteFictiveNodes(node->left);
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x77ac
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x7770
callq 0x774e
movq 0x20(%rbx), %rax
jmp 0x7779
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x7788
movq %rax, %rbx
testq %rax, %rax
jne 0x7757
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpq %rbx, 0x18(%rax)
setne %cl
movq $0x0, 0x18(%rax,%rcx,8)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
leaq 0x27cd(%rip), %rdi      # 0x9f80
leaq 0x2ca6(%rip), %rsi      # 0xa460
leaq 0x2d9a(%rip), %rcx      # 0xa55b
movl $0x85, %edx
callq 0x20b0