LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6f75
jmp 0x6f94
leaq 0x45f3(%rip), %rdi      # 0xb56f
leaq 0x448e(%rip), %rsi      # 0xb411
movl $0x152, %edx            # imm = 0x152
leaq 0x4771(%rip), %rcx      # 0xb700
callq 0x20a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6fa1
jmp 0x6fc0
leaq 0x4776(%rip), %rdi      # 0xb71e
leaq 0x4462(%rip), %rsi      # 0xb411
movl $0x153, %edx            # imm = 0x153
leaq 0x4745(%rip), %rcx      # 0xb700
callq 0x20a0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6fcc
jmp 0x6feb
leaq 0x4763(%rip), %rdi      # 0xb736
leaq 0x4437(%rip), %rsi      # 0xb411
movl $0x154, %edx            # imm = 0x154
leaq 0x471a(%rip), %rcx      # 0xb700
callq 0x20a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2130
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2130
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7075
jmp 0x7094
leaq 0x44f3(%rip), %rdi      # 0xb56f
leaq 0x438e(%rip), %rsi      # 0xb411
movl $0x163, %edx            # imm = 0x163
leaq 0x46d2(%rip), %rcx      # 0xb761
callq 0x20a0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x71a3
movq -0x10(%rbp), %rsi
leaq 0x46c2(%rip), %rdi      # 0xb77b
xorl %eax, %eax
callq 0x2040
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x70f2
jmp 0x70db
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x7114
jmp 0x70e5
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x7137
jmp 0x717d
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
leaq 0x4677(%rip), %rdi      # 0xb782
movb $0x0, %al
callq 0x2040
jmp 0x7190
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
leaq 0x466f(%rip), %rdi      # 0xb79d
movb $0x0, %al
callq 0x2040
jmp 0x7190
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rcx
leaq 0x894f(%rip), %rax      # 0xfaa0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
leaq 0x4646(%rip), %rdi      # 0xb7ba
movb $0x0, %al
callq 0x2040
jmp 0x7190
leaq 0x4657(%rip), %rdi      # 0xb7db
movl $0x17b, %esi            # imm = 0x17B
movb $0x0, %al
callq 0x2040
jmp 0x7192
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x709c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/dot_dump.h
// Function: MathToString(int)
const char* MathToString(int op)
{
    switch (op)
    {
        case ADD_OP           : { return "+" ; }
        case SUB_OP           : { return "-" ; }
        case MUL_OP           : { return "*" ; }
        case DIV_OP           : { return "/" ; }
        case EQUAL_OP         : { return "=="; }
        case NOT_EQUAL_OP     : { return "!="; }
        case LESS_OP          : { return "<" ; }
        case GREATER_OP       : { return ">" ; }
        case LESS_EQUAL_OP    : { return "<="; }
        case GREATER_EQUAL_OP : { return ">="; }

        default : return "error_op";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x7261
movq -0x18(%rbp), %rax
leaq 0x47bd(%rip), %rcx      # 0xb990
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x478d(%rip), %rax      # 0xb970
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x477f(%rip), %rax      # 0xb972
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x4774(%rip), %rax      # 0xb974
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x4769(%rip), %rax      # 0xb976
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x4753(%rip), %rax      # 0xb96d
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x475b(%rip), %rax      # 0xb982
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x474a(%rip), %rax      # 0xb97e
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x473f(%rip), %rax      # 0xb980
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x472a(%rip), %rax      # 0xb978
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x4720(%rip), %rax      # 0xb97b
movq %rax, -0x8(%rbp)
jmp 0x726c
leaq 0x47d5(%rip), %rax      # 0xba3d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq 0x8f71(%rip), %rdi      # 0x10200
leaq 0x404c(%rip), %rsi      # 0xb2e2
callq 0x2120
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x72cd
movq -0x8(%rbp), %rdi
leaq 0x478d(%rip), %rsi      # 0xba46
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
callq 0x2100
movq 0x8f2c(%rip), %rdi      # 0x10200
leaq 0x364f(%rip), %rsi      # 0xa92a
callq 0x2120
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
leaq 0x474f(%rip), %rsi      # 0xba46
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rdi
callq 0x2100
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7339
jmp 0x7358
leaq 0x470a(%rip), %rdi      # 0xba4a
leaq 0x470b(%rip), %rsi      # 0xba52
movl $0x30, %edx
leaq 0x4718(%rip), %rcx      # 0xba6b
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x7361
jmp 0x7380
leaq 0x4721(%rip), %rdi      # 0xba89
leaq 0x46e3(%rip), %rsi      # 0xba52
movl $0x31, %edx
leaq 0x46f0(%rip), %rcx      # 0xba6b
callq 0x20a0
callq 0x7280
movq %rax, -0x18(%rbp)
leaq -0x1d(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x2090
leaq -0x1d(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x5, %esi
leaq 0x4699(%rip), %rdx      # 0xba46
movb $0x0, %al
callq 0x2180
movl 0x46d7(%rip), %eax      # 0xba91
movl %eax, -0x22(%rbp)
movb 0x46d2(%rip), %al       # 0xba95
movb %al, -0x1e(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
callq 0x21a0
movq -0x8(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x21a0
movq -0x10(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
callq 0x21a0
movq -0x10(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x21a0
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7795
jmp 0x77b4
leaq 0x3507(%rip), %rdi      # 0xaca3
leaq 0x42af(%rip), %rsi      # 0xba52
movl $0xc6, %edx
leaq 0x47a3(%rip), %rcx      # 0xbf52
callq 0x20a0
leaq 0x47ad(%rip), %rdi      # 0xbf68
callq 0x20d0
movq 0x8a31(%rip), %rdi      # 0x101f8
leaq 0x315c(%rip), %rsi      # 0xa92a
callq 0x2120
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4793(%rip), %rsi      # 0xbf75
movb $0x0, %al
callq 0x2160
movq -0x10(%rbp), %rdi
leaq 0x478d(%rip), %rsi      # 0xbf81
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x7400
movq -0x10(%rbp), %rdi
leaq 0x477e(%rip), %rsi      # 0xbf98
movb $0x0, %al
callq 0x2160
movq -0x10(%rbp), %rdi
callq 0x2100
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2090
leaq -0x50(%rbp), %rdi
movq 0x89b3(%rip), %rcx      # 0x101f8
movl $0x40, %esi
leaq 0x4749(%rip), %rdx      # 0xbf9a
movb $0x0, %al
callq 0x2180
movq 0x4c41(%rip), %rax      # 0xc4a0
movq %rax, -0x70(%rbp)
movq 0x4c3e(%rip), %rax      # 0xc4a8
movq %rax, -0x68(%rbp)
movq 0x4c3b(%rip), %rax      # 0xc4b0
movq %rax, -0x60(%rbp)
movq 0x4c38(%rip), %rax      # 0xc4b8
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7320
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x70(%rbp), %rdi
callq 0x20d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movl $0x1, %edi
movl $0x28, %esi
callq 0x20b0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7924
jmp 0x7943
leaq 0x46b3(%rip), %rdi      # 0xbfde
leaq 0x4685(%rip), %rsi      # 0xbfb7
movl $0x37, %edx
leaq 0x46a5(%rip), %rcx      # 0xbfe3
callq 0x20a0
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x20b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x79b3
jmp 0x79d2
leaq 0x4624(%rip), %rdi      # 0xbfde
leaq 0x45f6(%rip), %rsi      # 0xbfb7
movl $0x43, %edx
leaq 0x4626(%rip), %rcx      # 0xbff3
callq 0x20a0
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0xe, -0xc(%rbp)
jne 0x7a16
movl -0x8(%rbp), %edi
callq 0x7a50
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x7a29
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x7a3c
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/front-end/tree.cpp
// Function: MathTokenToNode(int)
int MathTokenToNode(int op)
{
    switch (op)
    {
        case PLUS      : { return ADD_OP          ; }
        case MINUS     : { return SUB_OP          ; }
        case MUL       : { return MUL_OP          ; }
        case DIV       : { return DIV_OP          ; }
        case NOT_EQUAL : { return NOT_EQUAL_OP    ; }
        case EQUAL     : { return EQUAL_OP        ; }
        case BELOW     : { return LESS_OP         ; }
        case ABOVE     : { return GREATER_OP      ; }
        case EBELOW    : { return LESS_EQUAL_OP   ; }
        case EABOVE    : { return GREATER_EQUAL_OP; }

        default     : { return op              ; }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x9, %eax
ja 0x7ad6
movq -0x10(%rbp), %rax
leaq 0x3f85(%rip), %rcx      # 0xb9f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x7adc
movl $0x1, -0x4(%rbp)
jmp 0x7adc
movl $0x2, -0x4(%rbp)
jmp 0x7adc
movl $0x3, -0x4(%rbp)
jmp 0x7adc
movl $0x5, -0x4(%rbp)
jmp 0x7adc
movl $0x4, -0x4(%rbp)
jmp 0x7adc
movl $0x6, -0x4(%rbp)
jmp 0x7adc
movl $0x7, -0x4(%rbp)
jmp 0x7adc
movl $0x8, -0x4(%rbp)
jmp 0x7adc
movl $0x9, -0x4(%rbp)
jmp 0x7adc
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7bf5
jmp 0x7c18
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7be0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7be0
movq -0x8(%rbp), %rdi
callq 0x2130
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7c85
jmp 0x7ca4
leaq 0x38e3(%rip), %rdi      # 0xb56f
leaq 0x4324(%rip), %rsi      # 0xbfb7
movl $0x8e, %edx
leaq 0x43bb(%rip), %rcx      # 0xc05a
callq 0x20a0
callq 0x78b0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7ce0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7cf9
jmp 0x7d18
leaq 0x386f(%rip), %rdi      # 0xb56f
leaq 0x42b0(%rip), %rsi      # 0xbfb7
movl $0x9b, %edx
leaq 0x435f(%rip), %rcx      # 0xc072
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
sete %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e00
movq %rax, %rdx
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x7af0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x11(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x7dea
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
sete %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e00
movq %rax, %rdx
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x7af0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movb -0x11(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
jmp 0x7d6a
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7e19
jmp 0x7e38
leaq 0x374f(%rip), %rdi      # 0xb56f
leaq 0x4190(%rip), %rsi      # 0xbfb7
movl $0xb2, %edx
leaq 0x4261(%rip), %rcx      # 0xc094
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x7e41
jmp 0x7e60
leaq 0x2ed1(%rip), %rdi      # 0xad19
leaq 0x4168(%rip), %rsi      # 0xbfb7
movl $0xb3, %edx
leaq 0x4239(%rip), %rcx      # 0xc094
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x7ea7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x7ebf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
je 0x7ebf
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x7980
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7f50
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7f69
jmp 0x7f88
leaq 0x35ff(%rip), %rdi      # 0xb56f
leaq 0x4040(%rip), %rsi      # 0xbfb7
movl $0xc6, %edx
leaq 0x4139(%rip), %rcx      # 0xc0bc
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81d0
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x80b9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x7980
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0x31(%rbp)
jne 0x8038
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x18, 0x8(%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x8041
jmp 0x80b7
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x7980
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8000
jmp 0x80b9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8270
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x80e9
jmp 0x8108
leaq 0x347f(%rip), %rdi      # 0xb56f
leaq 0x3ec0(%rip), %rsi      # 0xbfb7
movl $0xe2, %edx
leaq 0x3fdb(%rip), %rcx      # 0xc0de
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8310
movl $0x6, %edi
callq 0x7b60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x2, (%rcx)
movb %al, -0x21(%rbp)
jne 0x8163
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x8, 0x8(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x816c
jmp 0x81b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x83b0
movq %rax, %rsi
movl $0x7, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7af0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x812b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8680
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x81e9
jmp 0x8208
leaq 0x337f(%rip), %rdi      # 0xb56f
leaq 0x3dc0(%rip), %rsi      # 0xbfb7
movl $0x21f, %edx            # imm = 0x21F
leaq 0x4158(%rip), %rcx      # 0xc35b
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8237
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x13, 0x8(%rax)
je 0x824f
movq -0x8(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8289
jmp 0x82a8
leaq 0x32df(%rip), %rdi      # 0xb56f
leaq 0x3d20(%rip), %rsi      # 0xbfb7
movl $0x22c, %edx            # imm = 0x22C
leaq 0x40ea(%rip), %rcx      # 0xc38d
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x82d7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x14, 0x8(%rax)
je 0x82ef
movq -0x8(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8329
jmp 0x8348
leaq 0x323f(%rip), %rdi      # 0xb56f
leaq 0x3c80(%rip), %rsi      # 0xbfb7
movl $0x205, %edx            # imm = 0x205
leaq 0x3fc2(%rip), %rcx      # 0xc305
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8377
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x7, 0x8(%rax)
je 0x838f
movq -0x8(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8699
jmp 0x86b8
leaq 0x2ecf(%rip), %rdi      # 0xb56f
leaq 0x3910(%rip), %rsi      # 0xbfb7
movl $0x212, %edx            # imm = 0x212
leaq 0x3c7d(%rip), %rcx      # 0xc330
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x86e7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x8, 0x8(%rax)
je 0x86ff
movq -0x8(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8739
jmp 0x8758
leaq 0x2e2f(%rip), %rdi      # 0xb56f
leaq 0x3870(%rip), %rsi      # 0xbfb7
movl $0x129, %edx            # imm = 0x129
leaq 0x39d8(%rip), %rcx      # 0xc12b
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x7980
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8c80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d20
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x2, %edi
callq 0x7af0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x87f9
jmp 0x8818
leaq 0x2d6f(%rip), %rdi      # 0xb56f
leaq 0x37b0(%rip), %rsi      # 0xbfb7
movl $0x253, %edx            # imm = 0x253
leaq 0x3c12(%rip), %rcx      # 0xc425
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8847
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x17, 0x8(%rax)
je 0x885f
movq -0x8(%rbp), %rax
movl $0x3, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8899
jmp 0x88b8
leaq 0x2ccf(%rip), %rdi      # 0xb56f
leaq 0x3710(%rip), %rsi      # 0xbfb7
movl $0x136, %edx            # imm = 0x136
leaq 0x38a6(%rip), %rcx      # 0xc159
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8dc0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8ec0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movl $0xb, %edi
callq 0x7af0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8929
jmp 0x8948
leaq 0x2c3f(%rip), %rdi      # 0xb56f
leaq 0x3680(%rip), %rsi      # 0xbfb7
movl $0x1b4, %edx            # imm = 0x1B4
leaq 0x3933(%rip), %rcx      # 0xc276
callq 0x20a0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
je 0x899e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x17, 0x8(%rax)
je 0x899e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movl $0xd, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x7af0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x89d9
jmp 0x89f8
leaq 0x2b8f(%rip), %rdi      # 0xb56f
leaq 0x35d0(%rip), %rsi      # 0xbfb7
movl $0x1ee, %edx            # imm = 0x1EE
leaq 0x38eb(%rip), %rcx      # 0xc2de
callq 0x20a0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq %rax, %rsi
movl $0x8, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7af0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8270
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80d0
movq %rax, %rsi
movl $0x9, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7af0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8adc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x5, 0x8(%rax)
jne 0x8adc
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8b09
jmp 0x8b28
leaq 0x2a5f(%rip), %rdi      # 0xb56f
leaq 0x34a0(%rip), %rsi      # 0xbfb7
movl $0x1de, %edx            # imm = 0x1DE
leaq 0x3799(%rip), %rcx      # 0xc2bc
callq 0x20a0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq %rax, %rsi
movl $0xa, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7af0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8270
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8bc9
jmp 0x8be8
leaq 0x299f(%rip), %rdi      # 0xb56f
leaq 0x33e0(%rip), %rsi      # 0xbfb7
movl $0x151, %edx            # imm = 0x151
leaq 0x35c2(%rip), %rcx      # 0xc1a5
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8f60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9080
testb $0x1, %al
jne 0x8c0c
jmp 0x8c6c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8f60
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rsi
movl $0xe, %edi
callq 0x7980
movq %rax, -0x18(%rbp)
jmp 0x8bf9
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8c99
jmp 0x8cb8
leaq 0x28cf(%rip), %rdi      # 0xb56f
leaq 0x3310(%rip), %rsi      # 0xbfb7
movl $0x239, %edx            # imm = 0x239
leaq 0x370c(%rip), %rcx      # 0xc3bf
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8ce7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x15, 0x8(%rax)
je 0x8cff
movq -0x8(%rbp), %rax
movl $0x4, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8d39
jmp 0x8d58
leaq 0x282f(%rip), %rdi      # 0xb56f
leaq 0x3270(%rip), %rsi      # 0xbfb7
movl $0x246, %edx            # imm = 0x246
leaq 0x369f(%rip), %rcx      # 0xc3f2
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8d87
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x16, 0x8(%rax)
je 0x8d9f
movq -0x8(%rbp), %rax
movl $0x4, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8dd9
jmp 0x8df8
leaq 0x278f(%rip), %rdi      # 0xb56f
leaq 0x31d0(%rip), %rsi      # 0xbfb7
movl $0x140, %edx            # imm = 0x140
leaq 0x338e(%rip), %rcx      # 0xc181
callq 0x20a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x7980
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8eaa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x15, 0x8(%rax)
jne 0x8eaa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8c80
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8bb0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8d20
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x3, %edi
callq 0x7af0
movq %rax, -0x8(%rbp)
jmp 0x8eb2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8ed9
jmp 0x8ef8
leaq 0x268f(%rip), %rdi      # 0xb56f
leaq 0x30d0(%rip), %rsi      # 0xbfb7
movl $0x260, %edx            # imm = 0x260
leaq 0x355a(%rip), %rcx      # 0xc44d
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8f27
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x6, 0x8(%rax)
je 0x8f3f
movq -0x8(%rbp), %rax
movl $0x9, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6500
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8f79
jmp 0x8f98
leaq 0x25ef(%rip), %rdi      # 0xb56f
leaq 0x3030(%rip), %rsi      # 0xbfb7
movl $0x162, %edx            # imm = 0x162
leaq 0x323a(%rip), %rcx      # 0xc1cd
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x91a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0x29(%rbp)
jne 0x9004
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0xa, 0x8(%rcx)
movb %al, -0x2a(%rbp)
je 0x8ffe
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0xb, 0x8(%rax)
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x900d
jmp 0x9070
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x91a0
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rsi
movl $0xe, %edi
callq 0x7980
movq %rax, -0x18(%rbp)
jmp 0x8fa9
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9099
jmp 0x90b8
leaq 0x24cf(%rip), %rdi      # 0xb56f
leaq 0x2f10(%rip), %rsi      # 0xbfb7
movl $0x26d, %edx            # imm = 0x26D
leaq 0x33c2(%rip), %rcx      # 0xc475
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0x11(%rbp)
jne 0x918f
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x9, 0x8(%rcx)
movb %al, -0x12(%rbp)
je 0x9189
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x12, 0x8(%rcx)
movb %al, -0x12(%rbp)
je 0x9189
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x11, 0x8(%rcx)
movb %al, -0x12(%rbp)
je 0x9189
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0xf, 0x8(%rcx)
movb %al, -0x12(%rbp)
je 0x9189
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x10, 0x8(%rcx)
movb %al, -0x12(%rbp)
je 0x9189
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0xe, 0x8(%rax)
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)