LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmCall(Node*, Compiler*)
void WriteAsmCall(Node* node, Compiler* compiler)
{
    if (WriteAsmStdCall(node, compiler))
    {
        return;
    }

    ASSERT_COMPILER;

    Function* call_func = FindFunc(node->left->value.name, compiler->table);

    if (call_func != nullptr)
    {       
        for (size_t i = 0; i < call_func->num_args; ++i)
        {
            node = node->right;
            if (node == nullptr)
            {
                printf("error : too few arguments for '%s'\n", call_func->name);
                return;
            }

            WriteAsmExpression(node->left, compiler);
        }

        if (node->right != nullptr)
        {
            printf("error : too more arguments for '%s'\n", call_func->name);
        }

        WriteCall     (compiler, call_func);
        WriteAddR64Num(compiler, RSP, call_func->num_args * 8);

        if (!call_func->is_void)
        {
            WritePushR64(compiler, RAX);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ce0
testb $0x1, %al
jne 0x36f3
jmp 0x36f8
jmp 0x37de
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2fd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x37de
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x377e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x375f
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x7391(%rip), %rdi      # 0xaae7
movb $0x0, %al
callq 0x2040
jmp 0x37de
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x33a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3727
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x379e
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x7374(%rip), %rdi      # 0xab0b
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5620
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x3, %rax
movl %eax, %edx
movl $0x4, %esi
callq 0x48d0
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x37dc
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4e10
jmp 0x37de
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: GetVarOfs(Function*, char*)
int GetVarOfs(Function* function, char* name)
{
    assert(function);
    assert(name);

    for (size_t i = 0; i < function->num_args; ++i)
    {
        if (strcmp(function->vars[i], name) == 0)
        {
            return (i + 2) * sizeof(int64_t);
        }
    }

    for (size_t i = function->num_args; i < function->num_vars + function->num_args; ++i)
    {
        if (strcmp(function->vars[i], name) == 0)
        {
            return - (i - function->num_args + 1) * sizeof(int64_t);
        }
    }
    
    printf("error : '%s' wasn't declarated here\n", name);
    return -0xFFFFFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3809
jmp 0x3828
leaq 0x737a(%rip), %rdi      # 0xab8a
leaq 0x70d4(%rip), %rsi      # 0xa8eb
movl $0x2b5, %edx            # imm = 0x2B5
leaq 0x7370(%rip), %rcx      # 0xab93
callq 0x20a0
cmpq $0x0, -0x18(%rbp)
je 0x3831
jmp 0x3850
leaq 0x8d78(%rip), %rdi      # 0xc5b0
leaq 0x70ac(%rip), %rsi      # 0xa8eb
movl $0x2b6, %edx            # imm = 0x2B6
leaq 0x7348(%rip), %rcx      # 0xab93
callq 0x20a0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x38a8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x2150
cmpl $0x0, %eax
jne 0x3898
movq -0x20(%rbp), %rax
addq $0x2, %rax
shlq $0x3, %rax
movl %eax, -0x4(%rbp)
jmp 0x3932
jmp 0x389a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3858
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x10(%rbp), %rdx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
jae 0x3919
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x2150
cmpl $0x0, %eax
jne 0x3909
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq 0x18(%rax), %rcx
addq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x3, %rax
movl %eax, -0x4(%rbp)
jmp 0x3932
jmp 0x390b
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x38b4
movq -0x18(%rbp), %rsi
leaq 0x7291(%rip), %rdi      # 0xabb5
movb $0x0, %al
callq 0x2040
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmCompare(Node*, Compiler*)
void WriteAsmCompare(Node* node, Compiler* compiler)
{
    ASSERT_COMPILER;

    WritePopR64   (compiler, RAX);
    WritePopR64   (compiler, RBX);
    WriteCmpR64R64(compiler, RBX, RAX);

    size_t true_label     = compiler->label++;
    size_t continue_label = compiler->label++;

    size_t true_jump_offset = WriteJumpOp(compiler, node->value.op, true_label);

    WritePushNum(compiler, 0);
    size_t continue_jump_offset  = WriteJump (compiler, continue_label);
    size_t true_label_offset     = WriteLabel(compiler, true_label);

    WritePushNum(compiler, 1);
    size_t continue_label_offset = WriteLabel(compiler, continue_label);

    SetInt(&compiler->writer, true_label_offset     - true_jump_offset     - sizeof(int), true_jump_offset);
    SetInt(&compiler->writer, continue_label_offset - continue_jump_offset - sizeof(int), continue_jump_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5020
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x5020
movq -0x10(%rbp), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5240
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rcx)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rcx)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x5400
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4f50
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x54e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5590
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4f50
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5590
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x38(%rbp), %rax
subq -0x28(%rbp), %rax
subq $0x4, %rax
movl %eax, %esi
movq -0x28(%rbp), %rdx
callq 0x5f90
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x40(%rbp), %rax
subq -0x30(%rbp), %rax
subq $0x4, %rax
movl %eax, %esi
movq -0x30(%rbp), %rdx
callq 0x5f90
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmSimpleExpression(Node*, Compiler*)
void WriteAsmSimpleExpression(Node* node, Compiler* compiler)
{
    ASSERT_COMPILER;

    if (node->type == MATH_TYPE)
    {
        WriteAsmSimpleExpression(node->left,  compiler);
        WriteAsmSimpleExpression(node->right, compiler);
        
        WritePopR64(compiler, RBX);
        WritePopR64(compiler, RAX);

        switch (node->value.op)
        {
            case ADD_OP :
            {   
                WriteAddR64R64(compiler, RAX, RBX);
                break;
            }
            case SUB_OP :
            {
                WriteSubR64R64(compiler, RAX, RBX);
                break;
            }
            case MUL_OP :
            {
                WriteMulR64(compiler, RBX);
                break;
            }
            case DIV_OP :
            {   
                WriteDivR64(compiler, RBX);
                break;
            }
            default:
            {
                printf("I am here, but I shouldn't, line = %d\n", __LINE__);
            }
        }

        WritePushR64(compiler, RAX);
    }
    else
    {
        WriteAsmPrimaryExpression(node, compiler);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x3b41
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3a60
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3a60
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x5020
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5020
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x3b21
movq -0x18(%rbp), %rax
leaq 0x6580(%rip), %rcx      # 0xa054
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x47f0
jmp 0x3b34
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x4a20
jmp 0x3b34
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x4c50
jmp 0x3b34
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x4d20
jmp 0x3b34
leaq 0x6f98(%rip), %rdi      # 0xaac0
movl $0x20f, %esi            # imm = 0x20F
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4e10
jmp 0x3b4e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmPrimaryExpression(Node*, Compiler*)
void WriteAsmPrimaryExpression(Node* node, Compiler* compiler)
{
    ASSERT_COMPILER;

    switch (node->type)
    {
        case ID_TYPE :
        {
            WriteMovR64Mem(compiler, RAX, RBP, GetVarOfs(FUNC, node->value.name));
            WritePushR64  (compiler, RAX);
            break;
        }
        case NUMB_TYPE :
        {
            WritePushNum(compiler, node->value.number);
            break;
        }
        case MEM_ACCESS_TYPE :
        {
            WriteAsmMemoryAccess(node, compiler);
            break;
        }
        case CALL_TYPE :
        {
            WriteAsmCall(node, compiler);
            break;
        }
        default :
        {
            printf("I am here, but I shouldn't, line = %d\n", __LINE__);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xc, %eax
ja 0x3c08
movq -0x18(%rbp), %rax
leaq 0x64d1(%rip), %rcx      # 0xa064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x37f0
movq -0x20(%rbp), %rdi
movl %eax, %ecx
xorl %esi, %esi
movl $0x5, %edx
callq 0x4470
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4e10
jmp 0x3c1b
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x4f50
jmp 0x3c1b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c30
jmp 0x3c1b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36d0
jmp 0x3c1b
leaq 0x6eb1(%rip), %rdi      # 0xaac0
movl $0x238, %esi            # imm = 0x238
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmMemoryAccess(Node*, Compiler*)
void WriteAsmMemoryAccess(Node* node, Compiler* compiler)
{
    ASSERT_COMPILER;

    WriteAsmExpression(node->right, compiler);

    WriteMovR64Mem(compiler, RAX, RBP, GetVarOfs(FUNC, node->left->value.name));
    WritePopR64   (compiler, RBX);
    WriteSalR64   (compiler, RBX, 3);
    WriteSubR64R64(compiler, RAX, RBX);
    WriteMovR64Mem(compiler, RAX, RAX);
    WritePushR64  (compiler, RAX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x33a0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x37f0
movq -0x18(%rbp), %rdi
movl %eax, %ecx
xorl %esi, %esi
movl $0x5, %edx
callq 0x4470
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x5020
movq -0x10(%rbp), %rdi
movl $0x3, %edx
movl %edx, %esi
callq 0x5160
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x4a20
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4470
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4e10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmStdCall(Node*, Compiler*)
bool WriteAsmStdCall(Node* node, Compiler* compiler)
{
    ASSERT_COMPILER;

    if (strcmp(node->left->value.name, SCAN) == 0)
    {
        WriteCall   (compiler, "scan");
        WritePushR64(compiler, RAX);
        return true;
    }

    if (strcmp(node->left->value.name, PRINT) == 0)
    {
        WriteAsmExpression(node->right->left, compiler);

        WriteCall  (compiler, "print");
        WritePopR64(compiler, RBX); //cleaning stack
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xc42d(%rip), %rsi      # 0x10130
callq 0x2150
cmpl $0x0, %eax
jne 0x3d2e
movq -0x18(%rbp), %rdi
leaq 0x6e18(%rip), %rsi      # 0xab30
callq 0x56f0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4e10
movb $0x1, -0x1(%rbp)
jmp 0x3d88
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xc3f7(%rip), %rsi      # 0x10138
callq 0x2150
cmpl $0x0, %eax
jne 0x3d84
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x33a0
movq -0x18(%rbp), %rdi
leaq 0x6dca(%rip), %rsi      # 0xab35
callq 0x56f0
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x5020
movb $0x1, -0x1(%rbp)
jmp 0x3d88
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: GetNumFunc(Tree*)
size_t GetNumFunc(Tree* tree)
{
    assert(tree);

    size_t result = 0;
    Node* node = tree->root;

    while (node != nullptr)
    {
        node = node->left;
        result++;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3db5
jmp 0x3dd4
leaq 0x6ee7(%rip), %rdi      # 0xaca3
leaq 0x6b28(%rip), %rsi      # 0xa8eb
movl $0x2f0, %edx            # imm = 0x2F0
leaq 0x6e75(%rip), %rcx      # 0xac44
callq 0x20a0
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3e08
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3de7
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: NewNameTable()
NameTable* NewNameTable()
{
    NameTable* table = (NameTable*)calloc(1, sizeof(NameTable));
    assert(table);

    table->num_func  = 0;
    table->functions = nullptr;

    return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10, %esi
callq 0x20b0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e44
jmp 0x3e63
leaq 0x6b35(%rip), %rdi      # 0xa980
leaq 0x6a99(%rip), %rsi      # 0xa8eb
movl $0x301, %edx            # imm = 0x301
leaq 0x6e00(%rip), %rcx      # 0xac5e
callq 0x20a0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: FillNameTable(NameTable*, Tree*)
void FillNameTable(NameTable* table, Tree* tree)
{
    assert(table);
    assert(tree);

    Node* node = tree->root;

    for (size_t i = 0; i < table->num_func; ++i)
    {
        GetFunction(node->right, table->functions + i);
        node = node->left;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ea9
jmp 0x3ec8
leaq 0x6ad0(%rip), %rdi      # 0xa980
leaq 0x6a34(%rip), %rsi      # 0xa8eb
movl $0x30b, %edx            # imm = 0x30B
leaq 0x6db5(%rip), %rcx      # 0xac78
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x3ed1
jmp 0x3ef0
leaq 0x6dcb(%rip), %rdi      # 0xaca3
leaq 0x6a0c(%rip), %rsi      # 0xa8eb
movl $0x30c, %edx            # imm = 0x30C
leaq 0x6d8d(%rip), %rcx      # 0xac78
callq 0x20a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3f47
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
imulq $0x30, -0x20(%rbp), %rax
addq %rax, %rsi
callq 0x3f50
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f03
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: GetFunction(Node*, Function*)
void GetFunction(Node* subtree, Function* function)
{
    assert(subtree);
    assert(function);

    function->name     = subtree->value.name;
    function->is_void  = subtree->parent->value.is_void;

    function->num_args = GetNumArgs(subtree->right);
    function->num_vars = GetNumVars(subtree->left->right);

    function->vars = (char**)calloc(function->num_args + function->num_vars, sizeof(char*));

    GetNames(function->vars, subtree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3f69
jmp 0x3f88
leaq 0x6d30(%rip), %rdi      # 0xaca0
leaq 0x6974(%rip), %rsi      # 0xa8eb
movl $0x319, %edx            # imm = 0x319
leaq 0x6d25(%rip), %rcx      # 0xaca8
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x3f91
jmp 0x3fb0
leaq 0x6bf2(%rip), %rdi      # 0xab8a
leaq 0x694c(%rip), %rsi      # 0xa8eb
movl $0x31a, %edx            # imm = 0x31A
leaq 0x6cfd(%rip), %rcx      # 0xaca8
callq 0x20a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4050
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x4090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rdi
movl $0x8, %esi
callq 0x20b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: GetNumArgs(Node*)
size_t GetNumArgs(Node* node)
{
    size_t result = 0;

    while (node != nullptr)
    {
        node = node->right;
        result++;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4081
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4060
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: GetNumVars(Node*)
size_t GetNumVars(Node* node)
{
    if (node == nullptr)
    {
        return 0;
    }

    int num = 0;

    if (node->type == DECL_TYPE || node->type == ADECL_TYPE)
    {
        num = 1;
    }

    return num + GetNumVars(node->left) + GetNumVars(node->right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x40ad
movq $0x0, -0x8(%rbp)
jmp 0x410b
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x40c6
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x40cd
movl $0x1, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4090
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4090
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: GetNames(char**, Node*)
void GetNames(char** vars, Node* subtree)
{
    assert(vars);
    assert(subtree);

    Node* arg = subtree->right;

    size_t ofs = 0;

    for (; arg != nullptr; ++ofs)
    {
        vars[ofs] = arg->value.name;

        arg = arg->right;
    }

    GetVars(subtree->left->right, vars, &ofs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4139
jmp 0x4158
leaq 0x6b8d(%rip), %rdi      # 0xaccd
leaq 0x67a4(%rip), %rsi      # 0xa8eb
movl $0x347, %edx            # imm = 0x347
leaq 0x6b7f(%rip), %rcx      # 0xacd2
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x4161
jmp 0x4180
leaq 0x6b38(%rip), %rdi      # 0xaca0
leaq 0x677c(%rip), %rsi      # 0xa8eb
movl $0x348, %edx            # imm = 0x348
leaq 0x6b57(%rip), %rcx      # 0xacd2
callq 0x20a0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x41c9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4194
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x41f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/compiling.cpp
// Function: GetVars(Node*, char**, unsigned long*)
void GetVars(Node* node, char** vars, size_t* ofs)
{
    assert(vars);
    assert(ofs);

    if (node == nullptr)
    {
        return;
    }

    if (node->type == DECL_TYPE || node->type == ADECL_TYPE)
    {
        vars[(*ofs)++] = node->left->value.name;
    }

    GetVars(node->right, vars, ofs);
    GetVars(node->left,  vars, ofs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x420d
jmp 0x422c
leaq 0x6ab9(%rip), %rdi      # 0xaccd
leaq 0x66d0(%rip), %rsi      # 0xa8eb
movl $0x35a, %edx            # imm = 0x35A
leaq 0x6aca(%rip), %rcx      # 0xacf1
callq 0x20a0
cmpq $0x0, -0x18(%rbp)
je 0x4235
jmp 0x4254
leaq 0x6add(%rip), %rdi      # 0xad19
leaq 0x66a8(%rip), %rsi      # 0xa8eb
movl $0x35b, %edx            # imm = 0x35B
leaq 0x6aa2(%rip), %rcx      # 0xacf1
callq 0x20a0
cmpq $0x0, -0x8(%rbp)
jne 0x425d
jmp 0x42be
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x426f
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x4294
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x41f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x41f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: CodeRexByteR64R64(R64, R64)
byte CodeRexByteR64R64(R64 reg1, R64 reg2)
{
    byte first_byte = default_r64_rex;

    if (reg1 > RDI)
    {
        first_byte |= reg1_additional_bit;
    }

    if (reg2 > RDI)
    {
        first_byte |= reg2_additional_bit;
    }

    return first_byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb $0x48, -0x9(%rbp)
cmpl $0x7, -0x4(%rbp)
jle 0x42ee
movzbl -0x9(%rbp), %eax
orl $0x1, %eax
movb %al, -0x9(%rbp)
cmpl $0x7, -0x8(%rbp)
jle 0x42fe
movzbl -0x9(%rbp), %eax
orl $0x4, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: CodeRexByteR64(R64)
byte CodeRexByteR64(R64 reg)
{
    byte first_byte = default_r64_rex;

    if (reg > RDI)
    {
        first_byte |= reg1_additional_bit;
    }

    return first_byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x48, -0x5(%rbp)
cmpl $0x7, -0x4(%rbp)
jle 0x432b
movzbl -0x5(%rbp), %eax
orl $0x1, %eax
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
popq %rbp
retq
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteMovR64R64(Compiler*, R64, R64)
void WriteMovR64R64(Compiler* compiler, R64 reg1, R64 reg2)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64R64(reg1, reg2));
    SetByte(&compiler->writer, mov_r64_r64);
    SetByte(&compiler->writer, CodeR64R64(mode_r64_r64, reg2, reg1));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "mov %s, %s\n\t", REGS[reg1], REGS[reg2]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x43ab
jmp 0x43ca
leaq 0x6583(%rip), %rdi      # 0xa935
leaq 0x6a06(%rip), %rsi      # 0xadbf
movl $0x6e, %edx
leaq 0x6a15(%rip), %rcx      # 0xadda
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x42d0
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff89, %esi       # imm = 0xFFFFFF89
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movl $0x3, %edi
callq 0x4330
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4467
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xbcfb(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xbceb(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rcx
leaq 0x69a4(%rip), %rsi      # 0xae04
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteMovR64Mem(Compiler*, R64, R64, int)
void WriteMovR64Mem(Compiler* compiler, R64 reg1, R64 reg2, int offset)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64R64(reg1, reg2));
    SetByte(&compiler->writer, mov_r64_mem);
    SetByte(&compiler->writer, CodeR64R64(mode_r64_mem_4_bytes, reg1, reg2));

    if (reg2 == RSP || reg2 == R12)
    {
        SetByte(&compiler->writer, additional_rsp_r12_byte);
    }

    SetInt(&compiler->writer, offset);

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "mov %s, [%s + %d]\n\t", REGS[reg1], REGS[reg2], offset);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x448e
jmp 0x44ad
leaq 0x64a0(%rip), %rdi      # 0xa935
leaq 0x6923(%rip), %rsi      # 0xadbf
movl $0x7c, %edx
leaq 0x6969(%rip), %rcx      # 0xae11
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x42d0
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff8b, %esi       # imm = 0xFFFFFF8B
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl $0x2, %edi
callq 0x4330
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
cmpl $0x4, -0x10(%rbp)
je 0x4516
cmpl $0xc, -0x10(%rbp)
jne 0x4528
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x24, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x457c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xbbea(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xbbda(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rcx
movl -0x14(%rbp), %r8d
leaq 0x68cb(%rip), %rsi      # 0xae40
movb $0x0, %al
callq 0x2160
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteMovMemR64(Compiler*, R64, R64, int)
void WriteMovMemR64(Compiler* compiler, R64 reg1, R64 reg2, int offset)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64R64(reg2, reg1));
    SetByte(&compiler->writer, mov_mem_r64);
    SetByte(&compiler->writer, CodeR64R64(mode_r64_mem_4_bytes, reg2, reg1));

    if (reg1 == RSP || reg1 == R12)
    {
        SetByte(&compiler->writer, additional_rsp_r12_byte);
    }

    SetInt(&compiler->writer, offset);

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "mov [%s + %d], %s\n\t", REGS[reg1], offset, REGS[reg2]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x45ae
jmp 0x45cd
leaq 0x6380(%rip), %rdi      # 0xa935
leaq 0x6803(%rip), %rsi      # 0xadbf
movl $0x91, %edx
leaq 0x688c(%rip), %rcx      # 0xae54
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x42d0
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff89, %esi       # imm = 0xFFFFFF89
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movl $0x2, %edi
callq 0x4330
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
cmpl $0x4, -0xc(%rbp)
je 0x4636
cmpl $0xc, -0xc(%rbp)
jne 0x4648
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x24, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x469b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xbaca(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x14(%rbp), %ecx
movl -0x10(%rbp), %eax
movl %eax, %esi
leaq 0xbab7(%rip), %rax      # 0x10140
movq (%rax,%rsi,8), %r8
leaq 0x67ef(%rip), %rsi      # 0xae83
movb $0x0, %al
callq 0x2160
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteMovR64Num(Compiler*, R64, long)
void WriteMovR64Num(Compiler* compiler, R64 reg, int64_t value)
{
    assert(compiler);

    if (compiler->memory_optimization_required && abs(value) < max_int)
    {
        if (reg > RDI)
        {
            SetByte(&compiler->writer, additional_push_pop_byte);
        }

        SetByte(&compiler->writer, CodeR64(mode_mov_r64_num, reg));
        SetInt(&compiler->writer, value);
    }
    else
    {
        SetByte(&compiler->writer, CodeRexByteR64(reg));
        SetByte(&compiler->writer, CodeR64(mode_mov_r64_num, reg));
        SetLong(&compiler->writer, value);
    }

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "mov %s, %ld\n\t", REGS[reg], value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x46cc
jmp 0x46eb
leaq 0x6262(%rip), %rdi      # 0xa935
leaq 0x66e5(%rip), %rsi      # 0xadbf
movl $0xa6, %edx
leaq 0x67b1(%rip), %rcx      # 0xae97
callq 0x20a0
movq -0x8(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x4756
movq -0x18(%rbp), %rdi
callq 0x5a30
cmpq $-0x1, %rax
jge 0x4756
cmpl $0x7, -0xc(%rbp)
jle 0x471c
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x41, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl $0x17, %edi
callq 0x4360
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x5f40
jmp 0x47ac
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0x4310
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %esi
movl $0x17, %edi
callq 0x4360
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x5fc0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x47e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb976(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
leaq 0x66ec(%rip), %rsi      # 0xaec5
movb $0x0, %al
callq 0x2160
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteAddR64R64(Compiler*, R64, R64)
void WriteAddR64R64(Compiler* compiler, R64 reg1, R64 reg2)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64R64(reg1, reg2));
    SetByte(&compiler->writer, add_r64_r64);
    SetByte(&compiler->writer, CodeR64R64(mode_r64_r64, reg2, reg1));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "add %s, %s\n\t", REGS[reg1], REGS[reg2]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x480b
jmp 0x482a
leaq 0x6123(%rip), %rdi      # 0xa935
leaq 0x65a6(%rip), %rsi      # 0xadbf
movl $0xc1, %edx
leaq 0x66ae(%rip), %rcx      # 0xaed3
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x42d0
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movl $0x3, %edi
callq 0x4330
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x48c7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb89b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xb88b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rcx
leaq 0x663d(%rip), %rsi      # 0xaefd
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteAddR64Num(Compiler*, R64, int)
void WriteAddR64Num(Compiler* compiler, R64 reg, int value)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64(reg));

    if (compiler->memory_optimization_required && abs(value) < max_char)
    {
        SetByte(&compiler->writer, add_r64_num1);
        SetByte(&compiler->writer, CodeR64(mode_add_r64_num, reg));
        SetByte(&compiler->writer, value);
    }
    else
    {
        SetByte(&compiler->writer, add_r64_num4);
        SetByte(&compiler->writer, CodeR64(mode_add_r64_num, reg));
        SetInt (&compiler->writer, value);
    }

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "add %s, %d\n\t", REGS[reg], value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x48eb
jmp 0x490a
leaq 0x6043(%rip), %rdi      # 0xa935
leaq 0x64c6(%rip), %rsi      # 0xadbf
movl $0xcf, %edx
leaq 0x6605(%rip), %rcx      # 0xaf0a
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x4310
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x4991
movl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0xff, %eax
jge 0x4991
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff83, %esi       # imm = 0xFFFFFF83
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl $0x18, %edi
callq 0x4360
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %eax
movsbl %al, %esi
callq 0x5eb0
jmp 0x49d8
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff81, %esi       # imm = 0xFFFFFF81
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %esi
movl $0x18, %edi
callq 0x4360
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4a0b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb74a(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %ecx
leaq 0x6530(%rip), %rsi      # 0xaf34
movb $0x0, %al
callq 0x2160
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteSubR64R64(Compiler*, R64, R64)
void WriteSubR64R64(Compiler* compiler, R64 reg1, R64 reg2)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64R64(reg1, reg2));
    SetByte(&compiler->writer, sub_r64_r64);
    SetByte(&compiler->writer, CodeR64R64(mode_r64_r64, reg2, reg1));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "sub %s, %s\n\t", REGS[reg1], REGS[reg2]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4a3b
jmp 0x4a5a
leaq 0x5ef3(%rip), %rdi      # 0xa935
leaq 0x6376(%rip), %rsi      # 0xadbf
movl $0xe8, %edx
leaq 0x64ec(%rip), %rcx      # 0xaf41
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x42d0
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x29, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movl $0x3, %edi
callq 0x4330
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4af7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb66b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xb65b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rcx
leaq 0x647b(%rip), %rsi      # 0xaf6b
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteSubR64Num(Compiler*, R64, int)
void WriteSubR64Num(Compiler* compiler, R64 reg, int value)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64(reg));
    
    if (compiler->memory_optimization_required && abs(value) < max_char)
    {
        SetByte(&compiler->writer, sub_r64_num1);
        SetByte(&compiler->writer, CodeR64(mode_sub_r64_num, reg));

        SetByte(&compiler->writer, value);
    }
    else
    {
        SetByte(&compiler->writer, sub_r64_num4);
        SetByte(&compiler->writer, CodeR64(mode_sub_r64_num, reg));

        SetInt(&compiler->writer, value);
    }

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "sub %s, %d\n\t", REGS[reg], value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4b1b
jmp 0x4b3a
leaq 0x5e13(%rip), %rdi      # 0xa935
leaq 0x6296(%rip), %rsi      # 0xadbf
movl $0xf6, %edx
leaq 0x6443(%rip), %rcx      # 0xaf78
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x4310
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x4bc1
movl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0xff, %eax
jge 0x4bc1
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff83, %esi       # imm = 0xFFFFFF83
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl $0x1d, %edi
callq 0x4360
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %eax
movsbl %al, %esi
callq 0x5eb0
jmp 0x4c08
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff81, %esi       # imm = 0xFFFFFF81
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %esi
movl $0x1d, %edi
callq 0x4360
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4c3b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb51a(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %ecx
leaq 0x636e(%rip), %rsi      # 0xafa2
movb $0x0, %al
callq 0x2160
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteMulR64(Compiler*, R64)
void WriteMulR64(Compiler* compiler, R64 reg)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64(reg));
    SetByte(&compiler->writer, mul_div_r64);
    SetByte(&compiler->writer, CodeR64(mode_mul_r64_num, reg));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "imul %s\n\t", REGS[reg]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4c68
jmp 0x4c87
leaq 0x5cc6(%rip), %rdi      # 0xa935
leaq 0x6149(%rip), %rsi      # 0xadbf
movl $0x111, %edx            # imm = 0x111
leaq 0x632d(%rip), %rcx      # 0xafaf
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x4310
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
movl $0x1c, %edi
callq 0x4360
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4d0e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb444(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
leaq 0x62ca(%rip), %rsi      # 0xafd1
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteDivR64(Compiler*, R64)
void WriteDivR64(Compiler* compiler, R64 reg)
{
    assert(compiler);

    SetByte(&compiler->writer, cqo_first_byte);
    SetByte(&compiler->writer, cqo_second_byte);

    SetByte(&compiler->writer, CodeRexByteR64(reg));
    SetByte(&compiler->writer, mul_div_r64);
    SetByte(&compiler->writer, CodeR64(mode_div_r64_num, reg));

    if (compiler->asm_listing_required)
    {    
        fprintf(compiler->file, "cqo    \n\t"
                                "idiv %s\n\t", REGS[reg]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4d38
jmp 0x4d57
leaq 0x5bf6(%rip), %rdi      # 0xa935
leaq 0x6079(%rip), %rsi      # 0xadbf
movl $0x11f, %edx            # imm = 0x11F
leaq 0x6289(%rip), %rcx      # 0xafdb
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x48, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff99, %esi       # imm = 0xFFFFFF99
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x4310
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
movl $0x1e, %edi
callq 0x4360
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4e02
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb350(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
leaq 0x6202(%rip), %rsi      # 0xaffd
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WritePushR64(Compiler*, R64)
void WritePushR64(Compiler* compiler, R64 reg)
{
    assert(compiler);

    if (compiler->speed_optimization_required &&
        CodeR64(mode_pop_r64, reg) == LastByte(&compiler->writer))
    {
        if (compiler->asm_listing_required)
        {
            fseek(compiler->file, -pop_reg_str_size, SEEK_CUR);
        }

        compiler->writer.offset--;
        
        if (LastByte(&compiler->writer) == additional_push_pop_byte)
        {
            compiler->writer.offset--;
        }

        return;
    }

    if (reg > RDI)
    {
        SetByte(&compiler->writer, additional_push_pop_byte);
    }

    SetByte(&compiler->writer, CodeR64(mode_push_r64, reg));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "push %s\n\t", REGS[reg]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4e28
jmp 0x4e47
leaq 0x5b06(%rip), %rdi      # 0xa935
leaq 0x5f89(%rip), %rsi      # 0xadbf
movl $0x131, %edx            # imm = 0x131
leaq 0x61ce(%rip), %rcx      # 0xb010
callq 0x20a0
movq -0x8(%rbp), %rax
testb $0x1, 0x21(%rax)
je 0x4edb
movl -0xc(%rbp), %esi
movl $0xb, %edi
callq 0x4360
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x5f00
movb %al, %cl
movl -0x10(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4edb
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4ea4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq $-0x9, %rsi
movl $0x1, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x5f00
movsbl %al, %eax
cmpl $0x41, %eax
jne 0x4ed9
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x4f48
cmpl $0x7, -0xc(%rbp)
jle 0x4ef3
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x41, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
movl $0xa, %edi
callq 0x4360
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x4f48
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb20a(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
leaq 0x60f2(%rip), %rsi      # 0xb033
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nop