LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4407
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x1, 0x21(%rdi)
jne 0x43a9
movl %r14d, %r12d
andl $0x7, %r12d
orl $0x58, %r12d
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x4f68
movsbl %al, %eax
cmpl %eax, %r12d
jne 0x43a9
cmpb $0x1, 0x20(%rbx)
jne 0x4393
movq 0x10(%rbx), %rdi
movq $-0x9, %rsi
movl $0x1, %edx
callq 0x2110
decq 0x30(%rbx)
movq %r15, %rdi
callq 0x4f68
cmpb $0x41, %al
jne 0x43fe
decq 0x30(%rbx)
jmp 0x43fe
cmpl $0x8, %r14d
jl 0x43bd
leaq 0x28(%rbx), %rdi
movl $0x41, %esi
callq 0x4f40
leaq 0x28(%rbx), %rdi
movl %r14d, %eax
andb $0x7, %al
orb $0x50, %al
movzbl %al, %esi
callq 0x4f40
cmpb $0x1, 0x20(%rbx)
jne 0x43fe
movq 0x10(%rbx), %rdi
movl %r14d, %eax
leaq 0x9d6c(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4bfb(%rip), %rsi      # 0x8fea
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x44f7(%rip), %rdi      # 0x8905
leaq 0x4961(%rip), %rsi      # 0x8d76
leaq 0x4bab(%rip), %rcx      # 0x8fc7
movl $0x131, %edx            # imm = 0x131
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x44b3
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
leaq 0x28(%rdi), %r15
cmpb $0x1, 0x22(%rdi)
jne 0x446c
cmpl $0xfe, %eax
ja 0x446c
movq %r15, %rdi
movl $0x6a, %esi
callq 0x4f40
movsbl %bl, %esi
movq %r15, %rdi
callq 0x4f40
jmp 0x4483
movq %r15, %rdi
movl $0x68, %esi
callq 0x4f40
movq %r15, %rdi
movl %ebx, %esi
callq 0x4f81
cmpb $0x1, 0x20(%r14)
jne 0x44a8
movq 0x10(%r14), %rdi
leaq 0x4b82(%rip), %rsi      # 0x9017
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x444b(%rip), %rdi      # 0x8905
leaq 0x48b5(%rip), %rsi      # 0x8d76
leaq 0x4b2c(%rip), %rcx      # 0x8ff4
movl $0x154, %edx            # imm = 0x154
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x45a0
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x1, 0x21(%rdi)
jne 0x4542
movl %r14d, %r12d
andl $0x7, %r12d
orl $0x50, %r12d
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x4f68
movsbl %al, %eax
cmpl %eax, %r12d
jne 0x4542
cmpb $0x1, 0x20(%rbx)
jne 0x452c
movq 0x10(%rbx), %rdi
movq $-0xa, %rsi
movl $0x1, %edx
callq 0x2110
decq 0x30(%rbx)
movq %r15, %rdi
callq 0x4f68
cmpb $0x41, %al
jne 0x4597
decq 0x30(%rbx)
jmp 0x4597
cmpl $0x8, %r14d
jl 0x4556
leaq 0x28(%rbx), %rdi
movl $0x41, %esi
callq 0x4f40
leaq 0x28(%rbx), %rdi
movl %r14d, %eax
andb $0x7, %al
orb $0x58, %al
movzbl %al, %esi
callq 0x4f40
cmpb $0x1, 0x20(%rbx)
jne 0x4597
movq 0x10(%rbx), %rdi
movl %r14d, %eax
leaq 0x9bd3(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4abb(%rip), %rsi      # 0x9043
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x435e(%rip), %rdi      # 0x8905
leaq 0x47c8(%rip), %rsi      # 0x8d76
leaq 0x4a6c(%rip), %rcx      # 0x9021
movl $0x169, %edx            # imm = 0x169
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4658
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x28(%rdi), %r12
xorl %esi, %esi
cmpl $0x8, %r14d
setge %sil
orl $0x48, %esi
movq %r12, %rdi
callq 0x4f40
movq %r12, %rdi
movl $0xffffffc1, %esi       # imm = 0xFFFFFFC1
callq 0x4f40
movl %r14d, %eax
andb $0x7, %al
orb $-0x20, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4f40
movsbl %bl, %esi
movq %r12, %rdi
callq 0x4f40
cmpb $0x1, 0x20(%r15)
jne 0x464f
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0x9b1d(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4a35(%rip), %rsi      # 0x9073
movl %ebx, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42a6(%rip), %rdi      # 0x8905
leaq 0x4710(%rip), %rsi      # 0x8d76
leaq 0x49df(%rip), %rcx      # 0x904c
movl $0x18d, %edx            # imm = 0x18D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4717
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x28(%rdi), %r12
cmpl $0x8, %esi
setge %al
cmpl $0x8, %edx
setge %cl
shlb $0x2, %cl
orb %al, %cl
orb $0x48, %cl
movzbl %cl, %esi
movq %r12, %rdi
callq 0x4f40
movq %r12, %rdi
movl $0x29, %esi
callq 0x4f40
movl %r14d, %eax
andl $0x7, %eax
leal (%rax,%rbx,8), %eax
orb $-0x40, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4f40
cmpb $0x1, 0x20(%r15)
jne 0x470e
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0x9a62(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
movl %ebx, %eax
movq (%rcx,%rax,8), %rcx
leaq 0x49ab(%rip), %rsi      # 0x90aa
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x41e7(%rip), %rdi      # 0x8905
leaq 0x4651(%rip), %rsi      # 0x8d76
leaq 0x4954(%rip), %rcx      # 0x9080
movl $0x19c, %edx            # imm = 0x19C
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x47d6
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x28(%rdi), %r12
cmpl $0x8, %esi
setge %al
cmpl $0x8, %edx
setge %cl
shlb $0x2, %cl
orb %al, %cl
orb $0x48, %cl
movzbl %cl, %esi
movq %r12, %rdi
callq 0x4f40
movq %r12, %rdi
movl $0xffffff85, %esi       # imm = 0xFFFFFF85
callq 0x4f40
movl %r14d, %eax
andl $0x7, %eax
leal (%rax,%rbx,8), %eax
orb $-0x40, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4f40
cmpb $0x1, 0x20(%r15)
jne 0x47cd
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0x99a3(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
movl %ebx, %eax
movq (%rcx,%rax,8), %rcx
leaq 0x491e(%rip), %rsi      # 0x90dc
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4128(%rip), %rdi      # 0x8905
leaq 0x4592(%rip), %rsi      # 0x8d76
leaq 0x48cc(%rip), %rcx      # 0x90b7
movl $0x1aa, %edx            # imm = 0x1AA
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4892
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x28(%rdi), %r13
movq %r13, %rdi
movl $0xf, %esi
callq 0x4f40
movslq %r12d, %r12
leaq 0x4a53(%rip), %rax      # 0x9286
movsbl -0x4(%r12,%rax), %esi
movq %r13, %rdi
callq 0x4f40
subl 0x30(%rbx), %r15d
addl $-0x4, %r15d
movq %r13, %rdi
movl %r15d, %esi
callq 0x4f81
cmpb $0x1, 0x20(%rbx)
jne 0x487b
movq 0x10(%rbx), %rdi
leaq 0x996b(%rip), %rax      # 0xe1d0
movq -0x20(%rax,%r12,8), %rdx
leaq 0x48ad(%rip), %rsi      # 0x911e
movq %r14, %rcx
xorl %eax, %eax
callq 0x2180
movq 0x30(%rbx), %rax
addq $-0x4, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x406c(%rip), %rdi      # 0x8905
leaq 0x44d6(%rip), %rsi      # 0x8d76
leaq 0x4843(%rip), %rcx      # 0x90ea
movl $0x1b8, %edx            # imm = 0x1B8
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x491a
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
movq %r12, %rdi
movl $0xffffffe9, %esi       # imm = 0xFFFFFFE9
callq 0x4f40
subl 0x30(%rbx), %r15d
addl $-0x4, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x4f81
cmpb $0x1, 0x20(%rbx)
jne 0x4909
movq 0x10(%rbx), %rdi
leaq 0x4856(%rip), %rsi      # 0x9155
movq %r14, %rdx
xorl %eax, %eax
callq 0x2180
movq 0x30(%rbx), %rax
addq $-0x4, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3fe4(%rip), %rdi      # 0x8905
leaq 0x444e(%rip), %rsi      # 0x8d76
leaq 0x47f9(%rip), %rcx      # 0x9128
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4984
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x497b
movq %rsi, %r14
movq 0x10(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x2110
movq 0x10(%rbx), %rdi
leaq 0x4815(%rip), %rsi      # 0x9186
movq %r14, %rdx
xorl %eax, %eax
callq 0x2180
movq 0x30(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3f7a(%rip), %rdi      # 0x8905
leaq 0x43e4(%rip), %rsi      # 0x8d76
leaq 0x47c7(%rip), %rcx      # 0x9160
movl $0x1d7, %edx            # imm = 0x1D7
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4a18
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4a37
movq %rdi, %r14
leaq 0x28(%rdi), %r15
movq %r15, %rdi
movl $0xffffffe8, %esi       # imm = 0xFFFFFFE8
callq 0x4f40
movq 0x30(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x4fdf
movq %r15, %rdi
xorl %esi, %esi
callq 0x4f81
cmpb $0x1, 0x20(%r14)
jne 0x4a0d
movq 0x10(%r14), %rdi
movq (%rbx), %rdx
leaq 0x47bf(%rip), %rsi      # 0x91bb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ee6(%rip), %rdi      # 0x8905
leaq 0x4350(%rip), %rsi      # 0x8d76
leaq 0x4762(%rip), %rcx      # 0x918f
movl $0x1e4, %edx            # imm = 0x1E4
callq 0x20b0
leaq 0x4778(%rip), %rdi      # 0x91b6
leaq 0x4331(%rip), %rsi      # 0x8d76
leaq 0x4743(%rip), %rcx      # 0x918f
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4ae3
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4b02
movq %rdi, %r14
leaq 0x28(%rdi), %r15
movq %r15, %rdi
movl $0xffffffe8, %esi       # imm = 0xFFFFFFE8
callq 0x4f40
leaq 0x4060(%rip), %rsi      # 0x8aec
movq %rbx, %rdi
callq 0x2170
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl 0x108(%r14,%rcx,8), %esi
subl 0x30(%r14), %esi
addl $-0x4, %esi
movq %r15, %rdi
callq 0x4f81
cmpb $0x1, 0x20(%r14)
jne 0x4ad8
movq 0x10(%r14), %rdi
leaq 0x46f7(%rip), %rsi      # 0x91bb
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e1b(%rip), %rdi      # 0x8905
leaq 0x4285(%rip), %rsi      # 0x8d76
leaq 0x46cd(%rip), %rcx      # 0x91c5
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x20b0
leaq 0x5a47(%rip), %rdi      # 0xa550
leaq 0x4266(%rip), %rsi      # 0x8d76
leaq 0x46ae(%rip), %rcx      # 0x91c5
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4b6a
movq %rdi, %rbx
addq $0x28, %rdi
movl $0xffffffc3, %esi       # imm = 0xFFFFFFC3
callq 0x4f40
cmpb $0x1, 0x20(%rbx)
jne 0x4b63
movq 0x10(%rbx), %rcx
leaq 0x46ba(%rip), %rdi      # 0x9208
movl $0x5, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3d94(%rip), %rdi      # 0x8905
leaq 0x41fe(%rip), %rsi      # 0x8d76
leaq 0x466f(%rip), %rcx      # 0x91ee
movl $0x209, %edx            # imm = 0x209
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4bd6
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
movl $0xffffff90, %esi       # imm = 0xFFFFFF90
callq 0x4f40
movq 0x30(%r14), %rax
movq %rax, 0x28(%rbx)
cmpb $0x1, 0x20(%r14)
jne 0x4bd1
movq 0x10(%r14), %rdi
movq (%rbx), %rdx
leaq 0x4673(%rip), %rsi      # 0x9239
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2180
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3d28(%rip), %rdi      # 0x8905
leaq 0x4192(%rip), %rsi      # 0x8d76
leaq 0x4623(%rip), %rcx      # 0x920e
movl $0x215, %edx            # imm = 0x215
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4c4b
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %rdi
movl $0xf, %esi
callq 0x4f40
movq %r14, %rdi
movl $0x5, %esi
callq 0x4f40
cmpb $0x1, 0x20(%rbx)
jne 0x4c46
movq 0x10(%rbx), %rcx
leaq 0x462c(%rip), %rdi      # 0x925f
movl $0x9, %esi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x21f0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3cb3(%rip), %rdi      # 0x8905
leaq 0x411d(%rip), %rsi      # 0x8d76
leaq 0x45e1(%rip), %rcx      # 0x9241
movl $0x223, %edx            # imm = 0x223
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rdi, %rdi
je 0x4ca5
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x4ca3
movq 0x28(%rdi), %rcx
movq 0x40(%rdi), %rdx
addq $0x8, %rdx
movq -0x8(%rdx), %rsi
movq (%rdx), %rdi
movl 0x28(%rdi), %edi
subl %esi, %edi
addl $-0x4, %edi
movl %edi, (%rcx,%rsi)
addq $0x10, %rdx
decq %rax
jne 0x4c88
popq %rbp
retq
leaq 0x3c59(%rip), %rdi      # 0x8905
leaq 0x40c3(%rip), %rsi      # 0x8d76
leaq 0x45af(%rip), %rcx      # 0x9269
movl $0x230, %edx            # imm = 0x230
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
movq $-0x1000, %rcx          # imm = 0xF000
leaq (%r15,%rcx), %rdx
movq %rdx, 0x90(%rdi)
movq %rdx, 0x98(%rdi)
andq %rcx, %r15
leaq 0x1000(%r15), %r14
movq %r14, 0x8(%rdi)
leaq 0x1100(%r15), %rcx
cmpq %rcx, %rax
jae 0x4de7
leaq 0x1101(%r15), %rsi
movq %rsi, 0x10(%rbx)
movq (%rbx), %rdi
callq 0x21c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x4e0a
movq %r14, 0xb0(%rbx)
addq $0x401000, %r15         # imm = 0x401000
movq %r15, 0xb8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x448f(%rip), %rdi      # 0x92a0
leaq 0x4497(%rip), %rsi      # 0x92af
leaq 0x44ac(%rip), %rcx      # 0x92cb
movl $0xb4, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rsi
leaq -0x8(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jb 0x4ebf
movq %rdi, %rbx
addq %rsi, %rsi
movq %rsi, 0x10(%rdi)
movq (%rdi), %rdi
callq 0x21c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x4ec6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x43d3(%rip), %rdi      # 0x92a0
leaq 0x43db(%rip), %rsi      # 0x92af
leaq 0x4418(%rip), %rcx      # 0x92f3
movl $0xd8, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rsi
leaq -0x1(%rsi), %rax
cmpq %rax, 0x20(%rdi)
jb 0x4f1a
movq %rdi, %rbx
leaq (%rsi,%rsi), %rax
movq %rax, 0x28(%rdi)
movq 0x18(%rdi), %rdi
shlq $0x5, %rsi
callq 0x21c0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x4f21
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x43f6(%rip), %rdi      # 0x931e
leaq 0x4380(%rip), %rsi      # 0x92af
leaq 0x43f6(%rip), %rcx      # 0x932c
movl $0xe5, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/back-end/elf_writer.cpp
// Function: AddCall(ElfFileWriter*, unsigned long, Function*)
void AddCall(ElfFileWriter* writer, size_t offset, Function* function)
{
    ASSERT_WRITER;
    assert(function);

    CheckElfWriterCallsBuffer(writer);

    writer->calls[writer->calls_size++] = {offset, function};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x5024
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4ee5
movq 0x18(%r15), %rax
movq 0x20(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%r15)
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b16(%rip), %rdi      # 0x8b41
leaq 0x427d(%rip), %rsi      # 0x92af
leaq 0x4323(%rip), %rcx      # 0x935c
movl $0x11f, %edx            # imm = 0x11F
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x508e
callq 0x2140
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x50ad
addq $0x18, %rbx
callq 0x2140
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x420b(%rip), %rdi      # 0x92a0
leaq 0x4213(%rip), %rsi      # 0x92af
leaq 0x42eb(%rip), %rcx      # 0x938e
movl $0x12a, %edx            # imm = 0x12A
callq 0x20b0
leaq 0x426a(%rip), %rdi      # 0x931e
leaq 0x41f4(%rip), %rsi      # 0x92af
leaq 0x42cc(%rip), %rcx      # 0x938e
movl $0x130, %edx            # imm = 0x130
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5106
movq %rdi, %rbx
xorl %esi, %esi
movl $0x2, %edx
callq 0x2110
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2110
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x37f3(%rip), %rdi      # 0x8900
leaq 0x429e(%rip), %rsi      # 0x93b2
leaq 0x42b0(%rip), %rcx      # 0x93cb
movl $0x16, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x519a
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x20c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x50cc
movq %rax, %r15
leaq 0x1(%rax), %rdi
movl $0x1, %esi
callq 0x20c0
movq %rax, (%r14)
testq %rax, %rax
je 0x51b9
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2190
movq %rax, 0x10(%r14)
movq %r12, 0x8(%r14)
movb $0x0, (%r12,%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x375f(%rip), %rdi      # 0x8900
leaq 0x420a(%rip), %rsi      # 0x93b2
leaq 0x4235(%rip), %rcx      # 0x93e4
movl $0x21, %edx
callq 0x20b0
leaq 0x423d(%rip), %rdi      # 0x93fd
leaq 0x41eb(%rip), %rsi      # 0x93b2
leaq 0x4216(%rip), %rcx      # 0x93e4
movl $0x28, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5205
movq %rdi, %rbx
leaq 0x40c0(%rip), %rsi      # 0x92ad
callq 0x2130
testq %rax, %rax
je 0x5224
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5125
leaq 0x41fd(%rip), %rdi      # 0x9409
leaq 0x419f(%rip), %rsi      # 0x93b2
leaq 0x41f5(%rip), %rcx      # 0x940f
movl $0x34, %edx
callq 0x20b0
leaq 0x4204(%rip), %rdi      # 0x942f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
leaq 0x420e(%rip), %rdi      # 0x944a
leaq 0x416f(%rip), %rsi      # 0x93b2
leaq 0x41c5(%rip), %rcx      # 0x940f
movl $0x3a, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x53b9
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4196(%rip), %rdi      # 0x94a7
xorl %eax, %eax
callq 0x2040
movl 0x18(%r14), %edi
callq 0x528d
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rax,%rcx,8), %r15
movq %r15, %rdi
callq 0x21a0
movq 0x10(%r14), %rax
cmpq %rax, %r15
jbe 0x5352
cmpb $0xa, (%r15)
je 0x5352
decq %r15
cmpq %rax, %r15
ja 0x5341
movq %rax, %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x52b5
movl $0xa, %edi
callq 0x2160
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpq %r15, 0x10(%rax,%rcx,8)
js 0x53a5
movq $-0x1, %r12
movl $0x20, %edi
callq 0x2160
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rax,%rcx,8), %rax
subq %r15, %rax
incq %r12
cmpq %r12, %rax
jg 0x5381
leaq 0x4560(%rip), %rdi      # 0x990c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
leaq 0x40b6(%rip), %rdi      # 0x9476
leaq 0x3feb(%rip), %rsi      # 0x93b2
leaq 0x40af(%rip), %rcx      # 0x947d
movl $0x82, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x542a
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8e0c(%rip), %rsi      # 0xe200
movq %r15, %rdi
callq 0x2070
leaq (%r15,%rax), %r14
movq %r14, (%rbx)
cmpb $0x7e, (%r15,%rax)
jne 0x541f
leaq 0x3497(%rip), %rsi      # 0x88a8
movq %r14, %rdi
callq 0x2050
addq %r14, %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e77(%rip), %rdi      # 0x92a8
leaq 0x3f7a(%rip), %rsi      # 0x93b2
leaq 0x407d(%rip), %rcx      # 0x94bc
movl $0xa3, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetNumber(Token*, unsigned long*, Buffer*)
bool GetNumber(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(ofs);
    assert(buffer);

    for (int i = 0; i < NUM_DIGITS; ++i)
    {
        if (strncmp(buffer->str, DIGITS[i].rus_digit, DIGITS[i].rus_len) == 0)
        {
            VALUE.number = i;
            TYPE         = TYPE_NUMB;
            STR          = buffer->str;

            buffer->str += DIGITS[i].rus_len;
            (*ofs)++;
            return true;
        }

        if (strncmp(buffer->str, DIGITS[i].eng_digit, DIGITS[i].eng_len) == 0)
        {
            VALUE.number = i;
            TYPE         = TYPE_NUMB;
            STR          = buffer->str;

            buffer->str += DIGITS[i].eng_len;
            (*ofs)++;
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x554d
movq %rsi, %r14
testq %rsi, %rsi
je 0x556c
testq %rdx, %rdx
je 0x558b
movq %rdi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq (%rdx), %rbx
leaq 0x4257(%rip), %rsi      # 0x96e1
movl $0x4, %r13d
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x54f6
movq %r14, -0x30(%rbp)
movb $0x1, %r12b
leaq 0x8469(%rip), %r14      # 0xd918
xorl %r15d, %r15d
movq -0x18(%r14), %rsi
movq -0x10(%r14), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2090
testl %eax, %eax
je 0x54f0
cmpq $0xa, %r15
je 0x5534
setb %r12b
movq -0x8(%r14), %rsi
movq (%r14), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2090
addq $0x20, %r14
incq %r15
testl %eax, %eax
jne 0x54b2
movq -0x30(%rbp), %r14
jmp 0x54fc
movb $0x1, %r12b
xorl %r15d, %r15d
movq (%r14), %rax
leaq (%rax,%rax,2), %rax
movq -0x38(%rbp), %rdi
movl %r15d, 0x8(%rdi,%rax,8)
movq (%r14), %rax
leaq (%rax,%rax,2), %rcx
movl $0x0, (%rdi,%rcx,8)
movq -0x40(%rbp), %rsi
movq (%rsi), %rdx
movq %rdx, 0x10(%rdi,%rcx,8)
addq %rdx, %r13
movq %r13, (%rsi)
incq %rax
movq %rax, (%r14)
jmp 0x5537
xorl %r12d, %r12d
andb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40d7(%rip), %rdi      # 0x962b
leaq 0x3e57(%rip), %rsi      # 0x93b2
leaq 0x3f76(%rip), %rcx      # 0x94d8
movl $0xae, %edx
callq 0x20b0
leaq 0x375d(%rip), %rdi      # 0x8cd0
leaq 0x3e38(%rip), %rsi      # 0x93b2
leaq 0x3f57(%rip), %rcx      # 0x94d8
movl $0xaf, %edx
callq 0x20b0
leaq 0x3d16(%rip), %rdi      # 0x92a8
leaq 0x3e19(%rip), %rsi      # 0x93b2
leaq 0x3f38(%rip), %rcx      # 0x94d8
movl $0xb0, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetOperator(Token*, unsigned long*, Buffer*)
bool GetOperator(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(ofs);
    assert(buffer);

    for (int i = 0; i < NUM_OPERATORS; ++i)
    {
        if (strncmp(buffer->str, OPERATORS[i].rus_name, OPERATORS[i].rus_len) == 0)
        {
            VALUE.op = i;
            TYPE     = TYPE_OP;
            STR      = buffer->str;

            buffer->str += OPERATORS[i].rus_len;
            (*ofs)++;
            return true;
        }

        if (OPERATORS[i].eng_name != nullptr)
        {
            if (strncmp(buffer->str, OPERATORS[i].eng_name, OPERATORS[i].eng_len) == 0)
            {
                VALUE.op = i;
                TYPE     = TYPE_OP;
                STR      = buffer->str;

                buffer->str += OPERATORS[i].eng_len;
                (*ofs)++;
                return true;
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x56b3
movq %rsi, %r14
testq %rsi, %rsi
je 0x56d2
testq %rdx, %rdx
je 0x56f1
movq %rdi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq (%rdx), %rbx
leaq 0x41d0(%rip), %rsi      # 0x97bb
movl $0x7, %r13d
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2090
testl %eax, %eax
je 0x565c
movq %r14, -0x30(%rbp)
movb $0x1, %r12b
leaq 0x8468(%rip), %r14      # 0xda78
xorl %r15d, %r15d
movq -0x18(%r14), %rsi
testq %rsi, %rsi
je 0x562f
movq -0x10(%r14), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2090
testl %eax, %eax
je 0x5656
cmpq $0x18, %r15
je 0x569a
setb %r12b
movq -0x8(%r14), %rsi
movq (%r14), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2090
addq $0x20, %r14
incq %r15
testl %eax, %eax
jne 0x5613
movq -0x30(%rbp), %r14
jmp 0x5662
movb $0x1, %r12b
xorl %r15d, %r15d
movq (%r14), %rax
leaq (%rax,%rax,2), %rax
movq -0x38(%rbp), %rdi
movl %r15d, 0x8(%rdi,%rax,8)
movq (%r14), %rax
leaq (%rax,%rax,2), %rcx
movl $0x2, (%rdi,%rcx,8)
movq -0x40(%rbp), %rsi
movq (%rsi), %rdx
movq %rdx, 0x10(%rdi,%rcx,8)
addq %rdx, %r13
movq %r13, (%rsi)
incq %rax
movq %rax, (%r14)
jmp 0x569d
xorl %r12d, %r12d
andb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f71(%rip), %rdi      # 0x962b
leaq 0x3cf1(%rip), %rsi      # 0x93b2
leaq 0x3e3c(%rip), %rcx      # 0x9504
movl $0xd0, %edx
callq 0x20b0
leaq 0x35f7(%rip), %rdi      # 0x8cd0
leaq 0x3cd2(%rip), %rsi      # 0x93b2
leaq 0x3e1d(%rip), %rcx      # 0x9504
movl $0xd1, %edx
callq 0x20b0
leaq 0x3bb0(%rip), %rdi      # 0x92a8
leaq 0x3cb3(%rip), %rsi      # 0x93b2
leaq 0x3dfe(%rip), %rcx      # 0x9504
movl $0xd2, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetToken(Token*, unsigned long*, Buffer*)
void GetToken(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(ofs);
    assert(buffer);

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

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

    int len = 0;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x57e3
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5802
movq %rdx, %r14
testq %rdx, %rdx
je 0x5821
movq %rdi, %r15
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5449
testb %al, %al
jne 0x57d6
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x55aa
testb %al, %al
jne 0x57d6
leaq -0x24(%rbp), %r12
movl $0x0, (%r12)
movl $0x20, %edi
movl $0x1, %esi
callq 0x20c0
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rax, 0x8(%r15,%rcx,8)
movq (%r14), %rdi
movq (%rbx), %rax
leaq (%rax,%rax,2), %rax
movq 0x8(%r15,%rax,8), %rdx
leaq 0x3db8(%rip), %rsi      # 0x955d
movq %r12, %rcx
xorl %eax, %eax
callq 0x20f0
movq (%rbx), %rax
leaq (%rax,%rax,2), %rcx
movl $0x1, (%r15,%rcx,8)
movq (%r14), %rdx
movq %rdx, 0x10(%r15,%rcx,8)
movslq (%r12), %rcx
addq %rdx, %rcx
movq %rcx, (%r14)
incq %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e41(%rip), %rdi      # 0x962b
leaq 0x3bc1(%rip), %rsi      # 0x93b2
leaq 0x3d3a(%rip), %rcx      # 0x9532
movl $0xf5, %edx
callq 0x20b0
leaq 0x34c7(%rip), %rdi      # 0x8cd0
leaq 0x3ba2(%rip), %rsi      # 0x93b2
leaq 0x3d1b(%rip), %rcx      # 0x9532
movl $0xf6, %edx
callq 0x20b0
leaq 0x3a80(%rip), %rdi      # 0x92a8
leaq 0x3b83(%rip), %rsi      # 0x93b2
leaq 0x3cfc(%rip), %rcx      # 0x9532
movl $0xf7, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: GetTokens(Token*, unsigned long*, Buffer*)
void GetTokens(Token* tokens, size_t* ofs, Buffer* buffer)
{
    assert(tokens);
    assert(buffer);

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

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

        IgnoreSpaces(buffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x58d4
movq %rdx, %rbx
testq %rdx, %rdx
je 0x58f3
movq (%rbx), %rax
movq %rax, %rcx
subq 0x8(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jae 0x58cb
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4091(%rip), %r12      # 0x990e
cmpb $-0x1, (%rax)
je 0x58cb
movq %rbx, %rdi
callq 0x53d8
movq (%rbx), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x58a5
movq %r12, %rdi
callq 0x21a0
incq (%rbx)
jmp 0x58b3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5710
movq %rbx, %rdi
callq 0x53d8
movq (%rbx), %rax
movq %rax, %rcx
subq 0x8(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jb 0x587d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d50(%rip), %rdi      # 0x962b
leaq 0x3ad0(%rip), %rsi      # 0x93b2
leaq 0x3c81(%rip), %rcx      # 0x956a
movl $0x113, %edx            # imm = 0x113
callq 0x20b0
leaq 0x39ae(%rip), %rdi      # 0x92a8
leaq 0x3ab1(%rip), %rsi      # 0x93b2
leaq 0x3c62(%rip), %rcx      # 0x956a
movl $0x114, %edx            # imm = 0x114
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: FillTokens(Token*, Buffer*)
size_t FillTokens(Token* tokens, Buffer* buffer)
{
    assert(tokens);
    assert(buffer);

    size_t ofs = 0;

    GetTokens(tokens, &ofs, buffer);

    return ofs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5942
movq %rsi, %rdx
testq %rsi, %rsi
je 0x5961
leaq -0x10(%rbp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rsi
callq 0x5840
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3ce2(%rip), %rdi      # 0x962b
leaq 0x3a62(%rip), %rsi      # 0x93b2
leaq 0x3c3f(%rip), %rcx      # 0x9596
movl $0x12a, %edx            # imm = 0x12A
callq 0x20b0
leaq 0x3940(%rip), %rdi      # 0x92a8
leaq 0x3a43(%rip), %rsi      # 0x93b2
leaq 0x3c20(%rip), %rcx      # 0x9596
movl $0x12b, %edx            # imm = 0x12B
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: Parse(char const*)
Parser* Parse(const char* input)
{
    assert(input);

    Buffer* buffer = GetBuffer(input);

    Token* tokens = NewTokensBuffer();

    size_t ofs = FillTokens(tokens, buffer);

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

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

    Delete(buffer);

    return parser;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5a10
callq 0x51d8
movq %rax, %rbx
callq 0x5254
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5912
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x20c0
movq %rax, %r12
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x5980
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x39f2(%rip), %rdi      # 0x9409
leaq 0x3994(%rip), %rsi      # 0x93b2
leaq 0x3bac(%rip), %rcx      # 0x95d1
movl $0x13d, %edx            # imm = 0x13D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: DestructParser(Parser*)
void DestructParser(Parser* parser)
{
    assert(parser);
    assert(parser->original_buffer);
    assert(parser->tokens);

    free(parser->original_buffer);
    free(parser->tokens);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5a5f
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x5a7e
cmpq $0x0, (%rbx)
je 0x5a9d
callq 0x2140
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
leaq 0x3a10(%rip), %rdi      # 0x9476
leaq 0x3945(%rip), %rsi      # 0x93b2
leaq 0x3b79(%rip), %rcx      # 0x95ed
movl $0x152, %edx            # imm = 0x152
callq 0x20b0
leaq 0x3b86(%rip), %rdi      # 0x960b
leaq 0x3926(%rip), %rsi      # 0x93b2
leaq 0x3b5a(%rip), %rcx      # 0x95ed
movl $0x153, %edx            # imm = 0x153
callq 0x20b0
leaq 0x3b7f(%rip), %rdi      # 0x9623
leaq 0x3907(%rip), %rsi      # 0x93b2
leaq 0x3b3b(%rip), %rcx      # 0x95ed
movl $0x154, %edx            # imm = 0x154
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/parser.cpp
// Function: ParserDump(Parser*)
void ParserDump(Parser* parser)
{
    assert(parser);

    for (size_t i = 0; i < parser->size; ++i)
    {
        printf("[%lu] ", i);
        switch (parser->tokens[i].type)
        {
            case TYPE_NUMB :
            {
                printf("type number,   value = %d\n", parser->tokens[i].value.number);
                break;
            }
            case TYPE_ID :
            {
                printf("type ID,       value = '%s'\n", parser->tokens[i].value.name);
                break;
            }
            case TYPE_OP :
            {
                printf("type operator, value = '%s'[%d]\n", OPERATORS[parser->tokens[i].value.op].rus_name, parser->tokens[i].value.op);
                break;
            }
            default :
            {
                printf("Unknown type, line = %d\n", __LINE__);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5bbd
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x5bae
movl $0x8, %r13d
leaq 0x3b4e(%rip), %r14      # 0x9668
leaq 0x3ba7(%rip), %r15      # 0x96c8
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movl -0x8(%rax,%r13), %ecx
cmpl $0x2, %ecx
je 0x5b68
cmpl $0x1, %ecx
je 0x5b54
testl %ecx, %ecx
jne 0x5b8e
movl (%rax,%r13), %esi
leaq 0x3b1d(%rip), %rdi      # 0x966f
jmp 0x5b96
movq (%rax,%r13), %rsi
leaq 0x3b2b(%rip), %rdi      # 0x968a
xorl %eax, %eax
callq 0x2040
jmp 0x5b9d
movslq (%rax,%r13), %rdx
movq %rdx, %rax
shlq $0x5, %rax
leaq 0x7ed6(%rip), %rcx      # 0xda50
movq (%rax,%rcx), %rsi
leaq 0x3b22(%rip), %rdi      # 0x96a7
xorl %eax, %eax
callq 0x2040
jmp 0x5b9d
movq %r15, %rdi
movl $0x17b, %esi            # imm = 0x17B
xorl %eax, %eax
callq 0x2040
incq %r12
addq $0x18, %r13
cmpq 0x8(%rbx), %r12
jb 0x5b24
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38b2(%rip), %rdi      # 0x9476
leaq 0x37e7(%rip), %rsi      # 0x93b2
leaq 0x3a7c(%rip), %rcx      # 0x964e
movl $0x163, %edx            # imm = 0x163
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/front-end/dot_dump.h
// Function: GetJPGNumber()
size_t GetJPGNumber()
{
    FILE* numjpgs = fopen(DUMP_FILE_NAME, "r");

    size_t num = 0;
    
    if (numjpgs != nullptr)
    {
        fscanf(numjpgs, "%lu", &num);
        fclose(numjpgs);
    }

    numjpgs = fopen(DUMP_FILE_NAME, "w");
    fprintf(numjpgs, "%lu", num + 1);
    fclose(numjpgs);
    
    return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8606(%rip), %rdi      # 0xe210
leaq 0x369c(%rip), %rsi      # 0x92ad
callq 0x2130
movq $0x0, -0x10(%rbp)
testq %rax, %rax
je 0x5c43
movq %rax, %rbx
leaq 0x3dbd(%rip), %rsi      # 0x99ea
leaq -0x10(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
callq 0x2100
movq 0x85c6(%rip), %rdi      # 0xe210
leaq 0x2ca9(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %rbx
movq -0x10(%rbp), %rdx
incq %rdx
leaq 0x3d83(%rip), %rsi      # 0x99ea
movq %rax, %rdi
xorl %eax, %eax
callq 0x2180
movq %rbx, %rdi
callq 0x2100
movq -0x10(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq