LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WritePushNum(Compiler*, int)
void WritePushNum(Compiler* compiler, int value)
{
    assert(compiler);

    if (compiler->memory_optimization_required && abs(value) < max_char)
    {
        SetByte(&compiler->writer, push_num1);
        SetByte(&compiler->writer, value); 
    }
    else
    {
        SetByte(&compiler->writer, push_num4);
        SetInt(&compiler->writer, value);
    }

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "push %d\n\t", value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4f68
jmp 0x4f87
leaq 0x59c6(%rip), %rdi      # 0xa935
leaq 0x5e49(%rip), %rsi      # 0xadbf
movl $0x154, %edx            # imm = 0x154
leaq 0x60bb(%rip), %rcx      # 0xb03d
callq 0x20a0
movq -0x8(%rbp), %rax
testb $0x1, 0x22(%rax)
je 0x4fc9
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0xff, %eax
jge 0x4fc9
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x6a, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0xc(%rbp), %eax
movsbl %al, %esi
callq 0x5eb0
jmp 0x4feb
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x68, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0xc(%rbp), %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x500e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x6059(%rip), %rsi      # 0xb060
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WritePopR64(Compiler*, R64)
void WritePopR64(Compiler* compiler, R64 reg)
{
    assert(compiler);

    if (compiler->speed_optimization_required &&
        CodeR64(mode_push_r64, reg) == LastByte(&compiler->writer))
    {
        if (compiler->asm_listing_required)
        {
            fseek(compiler->file, -push_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_pop_r64, reg));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "pop %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 0x5038
jmp 0x5057
leaq 0x58f6(%rip), %rdi      # 0xa935
leaq 0x5d79(%rip), %rsi      # 0xadbf
movl $0x169, %edx            # imm = 0x169
leaq 0x6018(%rip), %rcx      # 0xb06a
callq 0x20a0
movq -0x8(%rbp), %rax
testb $0x1, 0x21(%rax)
je 0x50eb
movl -0xc(%rbp), %esi
movl $0xa, %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 0x50eb
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x50b4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq $-0xa, %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 0x50e9
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x5158
cmpl $0x7, -0xc(%rbp)
jle 0x5103
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 $0xb, %edi
callq 0x4360
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x5158
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xaffa(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
leaq 0x5f3b(%rip), %rsi      # 0xb08c
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nop
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteSalR64(Compiler*, R64, int)
void WriteSalR64(Compiler* compiler, R64 reg, int offset)
{
    assert(compiler);

    SetByte(&compiler->writer, CodeRexByteR64(reg));
    SetByte(&compiler->writer, sal_r64);
    SetByte(&compiler->writer, CodeR64(mode_sal_r64, reg));
    SetByte(&compiler->writer, (char)offset);

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

// 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 0x517b
jmp 0x519a
leaq 0x57b3(%rip), %rdi      # 0xa935
leaq 0x5c36(%rip), %rsi      # 0xadbf
movl $0x18d, %edx            # imm = 0x18D
leaq 0x5f00(%rip), %rcx      # 0xb095
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 $0xffffffc1, %esi       # imm = 0xFFFFFFC1
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), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %eax
movsbl %al, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x5237
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xaf1e(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %ecx
leaq 0x5e8c(%rip), %rsi      # 0xb0bc
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteCmpR64R64(Compiler*, R64, R64)
void WriteCmpR64R64(Compiler* compiler, R64 reg1, R64 reg2)
{
    assert(compiler);

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

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "cmp %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 0x525b
jmp 0x527a
leaq 0x56d3(%rip), %rdi      # 0xa935
leaq 0x5b56(%rip), %rsi      # 0xadbf
movl $0x19c, %edx            # imm = 0x19C
leaq 0x5e54(%rip), %rcx      # 0xb0c9
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 0x5317
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xae4b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xae3b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rcx
leaq 0x5de3(%rip), %rsi      # 0xb0f3
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteTest(Compiler*, R64, R64)
void WriteTest(Compiler* compiler, R64 reg1, R64 reg2)
{
    assert(compiler);

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

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "test %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 0x533b
jmp 0x535a
leaq 0x55f3(%rip), %rdi      # 0xa935
leaq 0x5a76(%rip), %rsi      # 0xadbf
movl $0x1aa, %edx            # imm = 0x1AA
leaq 0x5dab(%rip), %rcx      # 0xb100
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 $0xffffff85, %esi       # imm = 0xFFFFFF85
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 0x53f7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xad6b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xad5b(%rip), %rax      # 0x10140
movq (%rax,%rcx,8), %rcx
leaq 0x5d35(%rip), %rsi      # 0xb125
movb $0x0, %al
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteJumpOp(Compiler*, int, unsigned long, unsigned long)
size_t WriteJumpOp(Compiler* compiler, int op, size_t label, size_t offset_to_jump)
{
    assert(compiler);

    SetByte(&compiler->writer, jmp_4_bytes);
    SetByte(&compiler->writer, JUMP_OP_CODES[op - EQUAL_OP]);
    SetInt(&compiler->writer, offset_to_jump - compiler->writer.offset - sizeof(int));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "%s L%lu\n\t", JUMPS[op - EQUAL_OP], label);
    }

    return compiler->writer.offset - sizeof(int);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5420
jmp 0x543f
leaq 0x550e(%rip), %rdi      # 0xa935
leaq 0x5991(%rip), %rsi      # 0xadbf
movl $0x1b8, %edx            # imm = 0x1B8
leaq 0x5cf9(%rip), %rcx      # 0xb133
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xf, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0xc(%rbp), %eax
subl $0x4, %eax
movslq %eax, %rcx
leaq 0x5e66(%rip), %rax      # 0xb2cf
movsbl (%rax,%rcx), %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x30(%rcx), %rax
subq $0x4, %rax
movl %eax, %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x54c9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %eax
subl $0x4, %eax
movslq %eax, %rcx
leaq 0xad0d(%rip), %rax      # 0x101c0
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
leaq 0x5ca5(%rip), %rsi      # 0xb167
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
subq $0x4, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteJump(Compiler*, unsigned long, unsigned long)
size_t WriteJump(Compiler* compiler, size_t label, size_t offset_to_jump)
{
    assert(compiler);

    SetByte(&compiler->writer, jmp);
    SetInt(&compiler->writer, offset_to_jump - compiler->writer.offset - sizeof(int));

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "jmp L%lu\n\t", label);
    }
    
    return compiler->writer.offset - sizeof(int);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54fd
jmp 0x551c
leaq 0x5431(%rip), %rdi      # 0xa935
leaq 0x58b4(%rip), %rsi      # 0xadbf
movl $0x1c8, %edx            # imm = 0x1C8
leaq 0x5c5a(%rip), %rcx      # 0xb171
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffffe9, %esi       # imm = 0xFFFFFFE9
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x30(%rcx), %rax
subq $0x4, %rax
movl %eax, %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x5571
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5c34(%rip), %rsi      # 0xb19e
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
subq $0x4, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteLabel(Compiler*, unsigned long)
size_t WriteLabel(Compiler* compiler, size_t label)
{
    assert(compiler);

    if (compiler->asm_listing_required)
    {
        fseek(compiler->file, -1, SEEK_CUR);
        fprintf(compiler->file, "L%lu :\n\t", label);
    }

    return compiler->writer.offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x55a9
jmp 0x55c8
leaq 0x5385(%rip), %rdi      # 0xa935
leaq 0x5808(%rip), %rsi      # 0xadbf
movl $0x1d7, %edx            # imm = 0x1D7
leaq 0x5be6(%rip), %rcx      # 0xb1a9
callq 0x20a0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x5605
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5bd1(%rip), %rsi      # 0xb1cf
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteCall(Compiler*, Function*)
void WriteCall(Compiler* compiler, Function* func)
{
    assert(compiler);
    assert(func);

    SetByte(&compiler->writer, call_func);
    AddCall(&compiler->writer, compiler->writer.offset, func);
    SetInt(&compiler->writer, 0);

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "call %s\n\t", func->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5639
jmp 0x5658
leaq 0x52f5(%rip), %rdi      # 0xa935
leaq 0x5778(%rip), %rsi      # 0xadbf
movl $0x1e4, %edx            # imm = 0x1E4
leaq 0x5b85(%rip), %rcx      # 0xb1d8
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x5661
jmp 0x5680
leaq 0x5b97(%rip), %rdi      # 0xb1ff
leaq 0x5750(%rip), %rsi      # 0xadbf
movl $0x1e5, %edx            # imm = 0x1E5
leaq 0x5b5d(%rip), %rcx      # 0xb1d8
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffffe8, %esi       # imm = 0xFFFFFFE8
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x6010
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x56e1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x5b2a(%rip), %rsi      # 0xb204
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteCall(Compiler*, char const*)
void WriteCall(Compiler* compiler, const char* name)
{
    assert(compiler);
    assert(name);

    SetByte(&compiler->writer, call_func);

    if (strcmp(name, "print") == 0)
    {
        SetInt(&compiler->writer, compiler->print_offset - compiler->writer.offset - sizeof(int));
    }
    else
    {
        SetInt(&compiler->writer, compiler->scan_offset - compiler->writer.offset - sizeof(int));
    }

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "call %s\n\t", name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5709
jmp 0x5728
leaq 0x5225(%rip), %rdi      # 0xa935
leaq 0x56a8(%rip), %rsi      # 0xadbf
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x5aeb(%rip), %rcx      # 0xb20e
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x5731
jmp 0x5750
leaq 0x6e78(%rip), %rdi      # 0xc5b0
leaq 0x5680(%rip), %rsi      # 0xadbf
movl $0x1f4, %edx            # imm = 0x1F4
leaq 0x5ac3(%rip), %rcx      # 0xb20e
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffffe8, %esi       # imm = 0xFFFFFFE8
callq 0x5eb0
movq -0x10(%rbp), %rdi
leaq 0x53c8(%rip), %rsi      # 0xab35
callq 0x2150
cmpl $0x0, %eax
jne 0x579f
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x30(%rcx), %rax
subq $0x4, %rax
movl %eax, %esi
callq 0x5f40
jmp 0x57c5
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x30(%rcx), %rax
subq $0x4, %rax
movl %eax, %esi
callq 0x5f40
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x57e9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5a22(%rip), %rsi      # 0xb204
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nop
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteRet(Compiler*)
void WriteRet(Compiler* compiler)
{
    assert(compiler);

    SetByte(&compiler->writer, ret_func);

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "ret\n\t");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5805
jmp 0x5824
leaq 0x5129(%rip), %rdi      # 0xa935
leaq 0x55ac(%rip), %rsi      # 0xadbf
movl $0x209, %edx            # imm = 0x209
leaq 0x5a18(%rip), %rcx      # 0xb237
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffffc3, %esi       # imm = 0xFFFFFFC3
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x5856
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x5a02(%rip), %rsi      # 0xb251
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteFuncDecl(Compiler*, Function*)
void WriteFuncDecl(Compiler* compiler, Function* func)
{
    assert(compiler);

    SetByte(&compiler->writer, nop);

    func->offset = compiler->writer.offset;

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "\n%s :\n\t", func->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5879
jmp 0x5898
leaq 0x50b5(%rip), %rdi      # 0xa935
leaq 0x5538(%rip), %rsi      # 0xadbf
movl $0x215, %edx            # imm = 0x215
leaq 0x59c4(%rip), %rcx      # 0xb257
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xffffff90, %esi       # imm = 0xFFFFFF90
callq 0x5eb0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x58e1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x59a8(%rip), %rsi      # 0xb282
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteSyscall(Compiler*)
void WriteSyscall(Compiler* compiler)
{
    assert(compiler);

    SetByte(&compiler->writer, syscall_first_byte);
    SetByte(&compiler->writer, syscall_second_byte);

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "syscall\n\t");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5905
jmp 0x5924
leaq 0x5029(%rip), %rdi      # 0xa935
leaq 0x54ac(%rip), %rsi      # 0xadbf
movl $0x223, %edx            # imm = 0x223
leaq 0x596b(%rip), %rcx      # 0xb28a
callq 0x20a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0xf, %esi
callq 0x5eb0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x5, %esi
callq 0x5eb0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x5968
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x5947(%rip), %rsi      # 0xb2a8
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nop
// File: vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: SetAllCalls(Compiler*)
void SetAllCalls(Compiler* compiler)
{
    assert(compiler);

    for (size_t i = 0; i < compiler->writer.calls_size; ++i)
    {
        int* tmp_ptr = (int*)(compiler->writer.buffer + compiler->writer.calls[i].offset);
        *tmp_ptr = compiler->writer.calls[i].function->offset - compiler->writer.calls[i].offset - sizeof(int);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5985
jmp 0x59a4
leaq 0x4fa9(%rip), %rdi      # 0xa935
leaq 0x542c(%rip), %rsi      # 0xadbf
movl $0x230, %edx            # imm = 0x230
leaq 0x5913(%rip), %rcx      # 0xb2b2
callq 0x20a0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x5a27
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addq (%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
subq (%rcx), %rax
subq $0x4, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x59ac
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: InitElf64(ElfFileWriter*)
void InitElf64(ElfFileWriter* writer)
{
    ASSERT_WRITER;

    int* tmp_ptr = (int*)writer->header.e_ident;
    *tmp_ptr = elf_magic;

    writer->header.e_ident[elf_mode_offset] = elf_64bit_mode;
    writer->header.e_ident[elf_encoding_offset] = elf_little_endian;
    writer->header.e_ident[elf_version_offset] = elf_version;

    writer->header.e_type    = elf_executable;
    writer->header.e_machine = elf_machine_amd64;
    writer->header.e_version = elf_ibj_version;

    writer->header.e_entry     = elf_entry; 
    writer->header.e_phoff     = sizeof(Elf64_Ehdr); 
    writer->header.e_flags     = 0;
    writer->header.e_ehsize    = sizeof(Elf64_Ehdr);
    writer->header.e_phentsize = sizeof(Elf64_Phdr);
    writer->header.e_phnum     = num_segments;
    writer->header.e_shnum     = 0;

    writer->text_header.p_type   = PT_LOAD;
    writer->text_header.p_flags  = PF_X | PF_R;
    writer->text_header.p_offset = elf_text_offset;
    writer->text_header.p_vaddr  = elf_entry;

    writer->text_header.p_paddr  = 0;
    writer->text_header.p_align  = 0;

    writer->data_header.p_type   = PT_LOAD;
    writer->data_header.p_flags  = PF_W | PF_R;

    writer->data_header.p_paddr  = 0;
    writer->data_header.p_filesz = elf_data_size;
    writer->data_header.p_memsz  = elf_data_size;
    writer->data_header.p_align  = 0;

    writer->offset = elf_text_offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x464c457f, (%rax)     # imm = 0x464C457F
movq -0x8(%rbp), %rax
movb $0x2, 0x34(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x35(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x36(%rax)
movq -0x8(%rbp), %rax
movw $0x2, 0x40(%rax)
movq -0x8(%rbp), %rax
movw $0x3e, 0x42(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x44(%rax)
movq -0x8(%rbp), %rax
movq $0x401000, 0x48(%rax)   # imm = 0x401000
movq -0x8(%rbp), %rax
movq $0x40, 0x50(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movw $0x40, 0x64(%rax)
movq -0x8(%rbp), %rax
movw $0x38, 0x66(%rax)
movq -0x8(%rbp), %rax
movw $0x2, 0x68(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x6c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x74(%rax)
movq -0x8(%rbp), %rax
movq $0x1000, 0x78(%rax)     # imm = 0x1000
movq -0x8(%rbp), %rax
movq $0x401000, 0x80(%rax) # imm = 0x401000
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xa8(%rax)
movq -0x8(%rbp), %rax
movl $0x6, 0xac(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xc0(%rax)
movq -0x8(%rbp), %rax
movq $0x100, 0xc8(%rax) # imm = 0x100
movq -0x8(%rbp), %rax
movq $0x100, 0xd0(%rax) # imm = 0x100
movq -0x8(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x8(%rbp), %rax
movq $0x1000, 0x8(%rax)      # imm = 0x1000
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: InitDataSegment(ElfFileWriter*)
size_t InitDataSegment(ElfFileWriter* writer)
{
    ASSERT_WRITER;
    
    writer->text_header.p_filesz = writer->offset - elf_text_offset;
    writer->text_header.p_memsz  = writer->offset - elf_text_offset;

    size_t data_segment_offset = writer->offset & ~elf_segment_alignment;
    data_segment_offset       += elf_text_offset;
    writer->offset             = data_segment_offset;

    if (writer->buffer_capacity < writer->offset + elf_data_size)
    {
        writer->buffer_capacity = writer->offset + elf_data_size + 1;
        writer->buffer          = (char*)realloc(writer->buffer,
                                                 writer->buffer_capacity * sizeof(char));
        assert(writer->buffer);
    }

    writer->data_header.p_offset = data_segment_offset;
    writer->data_header.p_vaddr  = virtual_start + data_segment_offset;

    return data_segment_offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x1000, %rcx           # imm = 0x1000
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x1000, %rcx           # imm = 0x1000
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x1000, %rax          # imm = 0xF000
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0x100, %rcx            # imm = 0x100
cmpq %rcx, %rax
jae 0x5ca2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x100, %rcx            # imm = 0x100
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x0, %rsi
callq 0x2190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5c81
jmp 0x5ca0
leaq 0x564d(%rip), %rdi      # 0xb2d5
leaq 0x5655(%rip), %rsi      # 0xb2e4
movl $0xb4, %edx
leaq 0x5665(%rip), %rcx      # 0xb300
callq 0x20a0
jmp 0x5ca2
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x10(%rbp), %rcx
addq $0x400000, %rcx         # imm = 0x400000
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: Construct(ElfFileWriter*)
void Construct(ElfFileWriter* writer)
{
    writer->offset = 0;
    writer->buffer = (char*)calloc(buffer_default_size, sizeof(char));
    writer->buffer_capacity = buffer_default_size;

    writer->calls = (CallInfo*)calloc(calls_default_size, sizeof(CallInfo));
    writer->calls_size = 0;
    writer->calls_capacity = calls_default_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x2000, %edi           # imm = 0x2000
movl $0x1, %esi
callq 0x20b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x2000, 0x10(%rax)     # imm = 0x2000
movl $0x10, %esi
movq %rsi, %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x10, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: CheckElfWriterBuffer(ElfFileWriter*)
void CheckElfWriterBuffer(ElfFileWriter* writer)
{
    ASSERT_WRITER;

    if (writer->offset >= writer->buffer_capacity - sizeof(int64_t))
    {
        writer->buffer_capacity *= 2;
        writer->buffer = (char*)realloc(writer->buffer,
                                        writer->buffer_capacity * sizeof(char));
        assert(writer->buffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
jb 0x5e13
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x0, %rsi
callq 0x2190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5df2
jmp 0x5e11
leaq 0x54dc(%rip), %rdi      # 0xb2d5
leaq 0x54e4(%rip), %rsi      # 0xb2e4
movl $0xd8, %edx
leaq 0x551c(%rip), %rcx      # 0xb328
callq 0x20a0
jmp 0x5e13
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: CheckElfWriterCallsBuffer(ElfFileWriter*)
void CheckElfWriterCallsBuffer(ElfFileWriter* writer)
{
    ASSERT_WRITER;

    if (writer->calls_size >= writer->calls_capacity - 1)
    {
        writer->calls_capacity *= 2;
        writer->calls = (CallInfo*)realloc(writer->calls,
                                           writer->calls_capacity * sizeof(CallInfo));
        assert(writer->calls);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x5ea6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
shlq %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
shlq $0x4, %rsi
callq 0x2190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5e85
jmp 0x5ea4
leaq 0x54c7(%rip), %rdi      # 0xb353
leaq 0x5451(%rip), %rsi      # 0xb2e4
movl $0xe5, %edx
leaq 0x54c2(%rip), %rcx      # 0xb361
callq 0x20a0
jmp 0x5ea6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: SetInt(ElfFileWriter*, int)
void SetInt(ElfFileWriter* writer, int value)
{
    ASSERT_WRITER;

    CheckElfWriterBuffer(writer);

    int* tmp_ptr = (int*)(writer->buffer + writer->offset);
    *tmp_ptr = value;
    writer->offset += sizeof(int);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: SetLong(ElfFileWriter*, long)
void SetLong(ElfFileWriter* writer, int64_t value)
{
    ASSERT_WRITER;

    CheckElfWriterBuffer(writer);

    long long* tmp_ptr = (long long*)(writer->buffer + writer->offset);
    *tmp_ptr = value;
    writer->offset += sizeof(long long);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: Destruct(ElfFileWriter*)
void Destruct(ElfFileWriter* writer)
{
    ASSERT_WRITER;

    assert(writer->buffer);
    free(writer->buffer);
    writer->buffer          = nullptr;
    writer->offset          = 0;
    writer->buffer_capacity = 0;

    assert(writer->calls);
    free(writer->calls);
    writer->calls          = nullptr;
    writer->calls_size     = 0;
    writer->calls_capacity = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x60b8
jmp 0x60d7
leaq 0x5216(%rip), %rdi      # 0xb2d5
leaq 0x521e(%rip), %rsi      # 0xb2e4
movl $0x12a, %edx            # imm = 0x12A
leaq 0x52f1(%rip), %rcx      # 0xb3c3
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2130
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6113
jmp 0x6132
leaq 0x5239(%rip), %rdi      # 0xb353
leaq 0x51c3(%rip), %rsi      # 0xb2e4
movl $0x130, %edx            # imm = 0x130
leaq 0x5296(%rip), %rcx      # 0xb3c3
callq 0x20a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2130
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: LenOfFile(_IO_FILE*)
size_t LenOfFile(FILE* file)
{
    assert(file);

    fseek(file, 0, SEEK_END);
    size_t pos = ftell(file);
    fseek(file, 0, SEEK_SET);

    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6185
jmp 0x61a4
leaq 0x48b7(%rip), %rdi      # 0xaa43
leaq 0x527e(%rip), %rsi      # 0xb411
movl $0x16, %edx
leaq 0x528b(%rip), %rcx      # 0xb42a
callq 0x20a0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2110
movq -0x8(%rbp), %rdi
callq 0x2030
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2110
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: ReadFile(_IO_FILE*)
Buffer* ReadFile(FILE* file)
{
    assert(file);

    Buffer* buffer = (Buffer*)calloc(1, sizeof(Buffer)); 
 
    size_t size = LenOfFile(file);

    buffer->str = (char*)calloc(size + 1, sizeof(char));
    assert(buffer->str);

    buffer->lenght = fread(buffer->str, sizeof(char), size, file);
    buffer->original_str = buffer->str;

    buffer->str[buffer->lenght] = '\0';

    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x61f5
jmp 0x6214
leaq 0x4847(%rip), %rdi      # 0xaa43
leaq 0x520e(%rip), %rsi      # 0xb411
movl $0x21, %edx
leaq 0x5234(%rip), %rcx      # 0xb443
callq 0x20a0
movl $0x1, %edi
movl $0x18, %esi
callq 0x20b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6170
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x20b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x625c
jmp 0x627b
leaq 0x51f9(%rip), %rdi      # 0xb45c
leaq 0x51a7(%rip), %rsi      # 0xb411
movl $0x28, %edx
leaq 0x51cd(%rip), %rcx      # 0xb443
callq 0x20a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetBuffer(char const*)
Buffer* GetBuffer(const char* input)
{
    assert(input);

    FILE* file = fopen(input, "r");
    if (!file) 
    {
        printf("error : no such file \"%s\"\n", input);
        assert(!"no input file\n");
    }

    return ReadFile(file); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x62e5
jmp 0x6304
leaq 0x517c(%rip), %rdi      # 0xb468
leaq 0x511e(%rip), %rsi      # 0xb411
movl $0x34, %edx
leaq 0x516f(%rip), %rcx      # 0xb46e
callq 0x20a0
movq -0x8(%rbp), %rdi
leaq 0x4fd3(%rip), %rsi      # 0xb2e2
callq 0x2120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6350
movq -0x8(%rbp), %rsi
leaq 0x5164(%rip), %rdi      # 0xb48e
movb $0x0, %al
callq 0x2040
leaq 0x5171(%rip), %rdi      # 0xb4a9
leaq 0x50d2(%rip), %rsi      # 0xb411
movl $0x3a, %edx
leaq 0x5123(%rip), %rcx      # 0xb46e
callq 0x20a0
movq -0x10(%rbp), %rdi
callq 0x61e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: PrintError(Error)
void PrintError(Error error)
{
    switch (error)
    {
        case BUFFER_IS_OK :
        {
            printf("error was called, but not detected\n");
            break;
        }
        case TYPE_ERROR :
        {
            printf("unknown type\n");
            break;
        }
        case UNKNOWN_SYMBOL :
        {
            printf("unknown symbol\n");
            break;
        }
        case MISSED_BRACE :
        {
            printf("missed brace\n");
            break;
        }
        case MISSED_SMCLN :
        {
            printf("missed semicolon\n");
            break;   
        }
        case MISSED_BRACKET:
        {
            printf("missed square bracket\n");
            break;
        }
        case ASSG_ERROR :
        {
            printf("assignment error\n");
            break;   
        }
        default :
        {
            printf("unknown error\n");
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x9, %rax
ja 0x6450
movq -0x10(%rbp), %rax
leaq 0x500d(%rip), %rcx      # 0xb3e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x50ee(%rip), %rdi      # 0xb4d5
movb $0x0, %al
callq 0x2040
jmp 0x645e
leaq 0x5102(%rip), %rdi      # 0xb4f9
movb $0x0, %al
callq 0x2040
jmp 0x645e
leaq 0x5100(%rip), %rdi      # 0xb507
movb $0x0, %al
callq 0x2040
jmp 0x645e
leaq 0x5100(%rip), %rdi      # 0xb517
movb $0x0, %al
callq 0x2040
jmp 0x645e
leaq 0x50fe(%rip), %rdi      # 0xb525
movb $0x0, %al
callq 0x2040
jmp 0x645e
leaq 0x5100(%rip), %rdi      # 0xb537
movb $0x0, %al
callq 0x2040
jmp 0x645e
leaq 0x5107(%rip), %rdi      # 0xb54e
movb $0x0, %al
callq 0x2040
jmp 0x645e
leaq 0x5109(%rip), %rdi      # 0xb560
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: CompilationError(Parser*, unsigned long*)
void CompilationError(Parser* parser, size_t* idx)
{
    assert(parser);

    printf("Compilation error : ");

    PrintError(parser->status);

    char* str_start = parser->tokens[*idx].token_str;
    printf("%s\n", str_start);
    
    while (str_start > parser->original_buffer && *str_start != '\n')
    {
        --str_start;
    }

    PrintBeforeSymbol(str_start, '\n');

    printf("\n");

    for (int i = 0; i <= parser->tokens[*idx].token_str - str_start; ++i)
    {
        printf(" ");
    }

    printf("^\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6519
jmp 0x6538
leaq 0x504f(%rip), %rdi      # 0xb56f
leaq 0x4eea(%rip), %rsi      # 0xb411
movl $0x82, %edx
leaq 0x5043(%rip), %rcx      # 0xb576
callq 0x20a0
leaq 0x5061(%rip), %rdi      # 0xb5a0
movb $0x0, %al
callq 0x2040
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x63b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x503e(%rip), %rdi      # 0xb5b5
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x1d(%rbp)
jbe 0x65a1
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x65aa
jmp 0x65b8
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x657e
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x6470
leaq 0x430b(%rip), %rdi      # 0xa8d8
movb $0x0, %al
callq 0x2040
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq $0x18, (%rdx), %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jg 0x661a
leaq 0x4753(%rip), %rdi      # 0xad5b
movb $0x0, %al
callq 0x2040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65db
leaq 0x4f98(%rip), %rdi      # 0xb5b9
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nop
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: IgnoreSpaces(Buffer*)
void IgnoreSpaces(Buffer* buffer)
{
    assert(buffer);

    buffer->str += strspn(buffer->str, SKIP_SYMBOLS);
    if (SYMBOL == '~')
    {
        buffer->str += strcspn(buffer->str, "\n"); 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6645
jmp 0x6664
leaq 0x4c91(%rip), %rdi      # 0xb2dd
leaq 0x4dbe(%rip), %rsi      # 0xb411
movl $0xa3, %edx
leaq 0x4f5d(%rip), %rcx      # 0xb5bc
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x9b7e(%rip), %rsi      # 0x101f0
callq 0x2070
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x66b3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x4237(%rip), %rsi      # 0xa8d8
callq 0x2050
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetToken(Token*, unsigned long*, Buffer*)
void GetToken(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(ofs);
    assert(buffer);

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

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

    int len = 0;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6b5d
jmp 0x6b7c
leaq 0x4bda(%rip), %rdi      # 0xb73e
leaq 0x48a6(%rip), %rsi      # 0xb411
movl $0xf5, %edx
leaq 0x4abb(%rip), %rcx      # 0xb632
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x6b85
jmp 0x6ba4
leaq 0x418d(%rip), %rdi      # 0xad19
leaq 0x487e(%rip), %rsi      # 0xb411
movl $0xf6, %edx
leaq 0x4a93(%rip), %rcx      # 0xb632
callq 0x20a0
cmpq $0x0, -0x18(%rbp)
je 0x6bad
jmp 0x6bcc
leaq 0x4729(%rip), %rdi      # 0xb2dd
leaq 0x4856(%rip), %rsi      # 0xb411
movl $0xf7, %edx
leaq 0x4a6b(%rip), %rcx      # 0xb632
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x66c0
testb $0x1, %al
jne 0x6be3
jmp 0x6be8
jmp 0x6cac
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x68f0
testb $0x1, %al
jne 0x6bff
jmp 0x6c04
jmp 0x6cac
movl $0x0, -0x1c(%rbp)
movl $0x20, %edi
movl $0x1, %esi
callq 0x20b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
imulq $0x18, (%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq 0x4a0c(%rip), %rsi      # 0xb65d
leaq -0x1c(%rbp), %rcx
movb $0x0, %al
callq 0x20f0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
imulq $0x18, (%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetTokens(Token*, unsigned long*, Buffer*)
void GetTokens(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(buffer);

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

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

        IgnoreSpaces(buffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6cdd
jmp 0x6cfc
leaq 0x4a5a(%rip), %rdi      # 0xb73e
leaq 0x4726(%rip), %rsi      # 0xb411
movl $0x113, %edx            # imm = 0x113
leaq 0x4973(%rip), %rcx      # 0xb66a
callq 0x20a0
cmpq $0x0, -0x18(%rbp)
je 0x6d05
jmp 0x6d24
leaq 0x45d1(%rip), %rdi      # 0xb2dd
leaq 0x46fe(%rip), %rsi      # 0xb411
movl $0x114, %edx            # imm = 0x114
leaq 0x494b(%rip), %rcx      # 0xb66a
callq 0x20a0
jmp 0x6d26
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x19(%rbp)
jae 0x6d5a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x6d63
jmp 0x6dbd
movq -0x18(%rbp), %rdi
callq 0x6630
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x20e0
cmpl $0x0, %eax
je 0x6d9e
leaq 0x490f(%rip), %rdi      # 0xb696
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x6daf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6b40
movq -0x18(%rbp), %rdi
callq 0x6630
jmp 0x6d26
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: FillTokens(Token*, Buffer*)
size_t FillTokens(Token* tokens, Buffer* buffer)
{
    assert(tokens);
    assert(buffer);

    size_t ofs = 0;

    GetTokens(tokens, &ofs, buffer);

    return ofs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6de9
jmp 0x6e08
leaq 0x494e(%rip), %rdi      # 0xb73e
leaq 0x461a(%rip), %rsi      # 0xb411
movl $0x12a, %edx            # imm = 0x12A
leaq 0x48a6(%rip), %rcx      # 0xb6a9
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x6e11
jmp 0x6e30
leaq 0x44c5(%rip), %rdi      # 0xb2dd
leaq 0x45f2(%rip), %rsi      # 0xb411
movl $0x12b, %edx            # imm = 0x12B
leaq 0x487e(%rip), %rcx      # 0xb6a9
callq 0x20a0
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rsi
callq 0x6cc0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/front-end/parser.cpp
// Function: Parse(char const*)
Parser* Parse(const char* input)
{
    assert(input);

    Buffer* buffer = GetBuffer(input);

    Token* tokens = NewTokensBuffer();

    size_t ofs = FillTokens(tokens, buffer);

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

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

    Delete(buffer);

    return parser;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6ec5
jmp 0x6ee4
leaq 0x459c(%rip), %rdi      # 0xb468
leaq 0x453e(%rip), %rsi      # 0xb411
movl $0x13d, %edx            # imm = 0x13D
leaq 0x4805(%rip), %rcx      # 0xb6e4
callq 0x20a0
movq -0x8(%rbp), %rdi
callq 0x62d0
movq %rax, -0x10(%rbp)
callq 0x6360
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6dd0
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x20b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x6e60
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)