LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteAddR64R64(Compiler*, R64, R64)
void WriteAddR64R64(Compiler* compiler, R64 reg1, R64 reg2)
{
    assert(compiler);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3d8d
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 0x4d94
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x4d94
movl %r14d, %eax
andl $0x7, %eax
leal (%rax,%rbx,8), %eax
orb $-0x40, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%r15)
jne 0x3d84
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0xa3ec(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
movl %ebx, %eax
movq (%rcx,%rax,8), %rcx
leaq 0x513f(%rip), %rsi      # 0x8eb4
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 0x4b71(%rip), %rdi      # 0x8905
leaq 0x4fdb(%rip), %rsi      # 0x8d76
leaq 0x50e8(%rip), %rcx      # 0x8e8a
movl $0xc1, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteAddR64Num(Compiler*, R64, int)
void WriteAddR64Num(Compiler* compiler, R64 reg, int value)
{
    assert(compiler);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e8f
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 0x4d94
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
movl %r14d, %r13d
andb $0x7, %r13b
orb $-0x40, %r13b
cmpb $0x1, 0x22(%r15)
jne 0x3e28
cmpl $0xfe, %eax
ja 0x3e28
pushq $-0x7d
popq %rsi
movq %r12, %rdi
callq 0x4d94
movsbl %r13b, %esi
movq %r12, %rdi
callq 0x4d94
movsbl %bl, %esi
movq %r12, %rdi
callq 0x4d94
jmp 0x3e49
pushq $-0x7f
popq %rsi
movq %r12, %rdi
callq 0x4d94
movsbl %r13b, %esi
movq %r12, %rdi
callq 0x4d94
movq %r12, %rdi
movl %ebx, %esi
callq 0x4dd5
cmpb $0x1, 0x20(%r15)
jne 0x3e80
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0xa2f2(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x5082(%rip), %rsi      # 0x8eeb
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a6f(%rip), %rdi      # 0x8905
leaq 0x4ed9(%rip), %rsi      # 0x8d76
leaq 0x501d(%rip), %rcx      # 0x8ec1
movl $0xcf, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteSubR64R64(Compiler*, R64, R64)
void WriteSubR64R64(Compiler* compiler, R64 reg1, R64 reg2)
{
    assert(compiler);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3f4c
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 0x4d94
pushq $0x29
popq %rsi
movq %r12, %rdi
callq 0x4d94
movl %r14d, %eax
andl $0x7, %eax
leal (%rax,%rbx,8), %eax
orb $-0x40, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%r15)
jne 0x3f43
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0xa22d(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
movl %ebx, %eax
movq (%rcx,%rax,8), %rcx
leaq 0x4fee(%rip), %rsi      # 0x8f22
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 0x49b2(%rip), %rdi      # 0x8905
leaq 0x4e1c(%rip), %rsi      # 0x8d76
leaq 0x4f97(%rip), %rcx      # 0x8ef8
movl $0xe8, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteSubR64Num(Compiler*, R64, int)
void WriteSubR64Num(Compiler* compiler, R64 reg, int value)
{
    assert(compiler);

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x404e
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 0x4d94
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
movl %r14d, %r13d
andb $0x7, %r13b
orb $-0x18, %r13b
cmpb $0x1, 0x22(%r15)
jne 0x3fe7
cmpl $0xfe, %eax
ja 0x3fe7
pushq $-0x7d
popq %rsi
movq %r12, %rdi
callq 0x4d94
movsbl %r13b, %esi
movq %r12, %rdi
callq 0x4d94
movsbl %bl, %esi
movq %r12, %rdi
callq 0x4d94
jmp 0x4008
pushq $-0x7f
popq %rsi
movq %r12, %rdi
callq 0x4d94
movsbl %r13b, %esi
movq %r12, %rdi
callq 0x4d94
movq %r12, %rdi
movl %ebx, %esi
callq 0x4dd5
cmpb $0x1, 0x20(%r15)
jne 0x403f
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0xa133(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4f31(%rip), %rsi      # 0x8f59
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48b0(%rip), %rdi      # 0x8905
leaq 0x4d1a(%rip), %rsi      # 0x8d76
leaq 0x4ecc(%rip), %rcx      # 0x8f2f
movl $0xf6, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteMulR64(Compiler*, R64)
void WriteMulR64(Compiler* compiler, R64 reg)
{
    assert(compiler);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x40f0
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
xorl %esi, %esi
cmpl $0x8, %ebx
setge %sil
orl $0x48, %esi
movq %r15, %rdi
callq 0x4d94
pushq $-0x9
popq %rsi
movq %r15, %rdi
callq 0x4d94
movl %ebx, %eax
andb $0x7, %al
orb $-0x20, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%r14)
jne 0x40e5
movq 0x10(%r14), %rdi
movl %ebx, %eax
leaq 0xa087(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4eb4(%rip), %rsi      # 0x8f88
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 0x480e(%rip), %rdi      # 0x8905
leaq 0x4c78(%rip), %rsi      # 0x8d76
leaq 0x4e61(%rip), %rcx      # 0x8f66
movl $0x111, %edx            # imm = 0x111
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/byte_code.cpp
// Function: WriteDivR64(Compiler*, R64)
void WriteDivR64(Compiler* compiler, R64 reg)
{
    assert(compiler);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x41ac
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x4d94
pushq $-0x67
popq %rsi
movq %r15, %rdi
callq 0x4d94
xorl %esi, %esi
cmpl $0x8, %ebx
setge %sil
orl $0x48, %esi
movq %r15, %rdi
callq 0x4d94
pushq $-0x9
popq %rsi
movq %r15, %rdi
callq 0x4d94
movl %ebx, %eax
andb $0x7, %al
orb $-0x10, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%r14)
jne 0x41a1
movq 0x10(%r14), %rdi
movl %ebx, %eax
leaq 0x9fcb(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4e24(%rip), %rsi      # 0x8fb4
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 0x4752(%rip), %rdi      # 0x8905
leaq 0x4bbc(%rip), %rsi      # 0x8d76
leaq 0x4dd1(%rip), %rcx      # 0x8f92
movl $0x11f, %edx            # imm = 0x11F
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4291
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x1, 0x21(%rdi)
jne 0x4235
movl %r14d, %r12d
andl $0x7, %r12d
orl $0x58, %r12d
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x4dbc
movsbl %al, %eax
cmpl %eax, %r12d
jne 0x4235
cmpb $0x1, 0x20(%rbx)
jne 0x421f
movq 0x10(%rbx), %rdi
pushq $-0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x2110
decq 0x30(%rbx)
movq %r15, %rdi
callq 0x4dbc
cmpb $0x41, %al
jne 0x4288
decq 0x30(%rbx)
jmp 0x4288
cmpl $0x8, %r14d
jl 0x4247
leaq 0x28(%rbx), %rdi
pushq $0x41
popq %rsi
callq 0x4d94
leaq 0x28(%rbx), %rdi
movl %r14d, %eax
andb $0x7, %al
orb $0x50, %al
movzbl %al, %esi
callq 0x4d94
cmpb $0x1, 0x20(%rbx)
jne 0x4288
movq 0x10(%rbx), %rdi
movl %r14d, %eax
leaq 0x9ee2(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4d71(%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 0x466d(%rip), %rdi      # 0x8905
leaq 0x4ad7(%rip), %rsi      # 0x8d76
leaq 0x4d21(%rip), %rcx      # 0x8fc7
movl $0x131, %edx            # imm = 0x131
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4339
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
leaq 0x28(%rdi), %r15
cmpb $0x1, 0x22(%rdi)
jne 0x42f4
cmpl $0xfe, %eax
ja 0x42f4
pushq $0x6a
popq %rsi
movq %r15, %rdi
callq 0x4d94
movsbl %bl, %esi
movq %r15, %rdi
callq 0x4d94
jmp 0x4309
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x4d94
movq %r15, %rdi
movl %ebx, %esi
callq 0x4dd5
cmpb $0x1, 0x20(%r14)
jne 0x432e
movq 0x10(%r14), %rdi
leaq 0x4cfc(%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 0x45c5(%rip), %rdi      # 0x8905
leaq 0x4a2f(%rip), %rsi      # 0x8d76
leaq 0x4ca6(%rip), %rcx      # 0x8ff4
movl $0x154, %edx            # imm = 0x154
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x441e
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x1, 0x21(%rdi)
jne 0x43c2
movl %r14d, %r12d
andl $0x7, %r12d
orl $0x50, %r12d
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x4dbc
movsbl %al, %eax
cmpl %eax, %r12d
jne 0x43c2
cmpb $0x1, 0x20(%rbx)
jne 0x43ac
movq 0x10(%rbx), %rdi
pushq $-0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x2110
decq 0x30(%rbx)
movq %r15, %rdi
callq 0x4dbc
cmpb $0x41, %al
jne 0x4415
decq 0x30(%rbx)
jmp 0x4415
cmpl $0x8, %r14d
jl 0x43d4
leaq 0x28(%rbx), %rdi
pushq $0x41
popq %rsi
callq 0x4d94
leaq 0x28(%rbx), %rdi
movl %r14d, %eax
andb $0x7, %al
orb $0x58, %al
movzbl %al, %esi
callq 0x4d94
cmpb $0x1, 0x20(%rbx)
jne 0x4415
movq 0x10(%rbx), %rdi
movl %r14d, %eax
leaq 0x9d55(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4c3d(%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 0x44e0(%rip), %rdi      # 0x8905
leaq 0x494a(%rip), %rsi      # 0x8d76
leaq 0x4bee(%rip), %rcx      # 0x9021
movl $0x169, %edx            # imm = 0x169
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x44d4
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 0x4d94
pushq $-0x3f
popq %rsi
movq %r12, %rdi
callq 0x4d94
movl %r14d, %eax
andb $0x7, %al
orb $-0x20, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4d94
movsbl %bl, %esi
movq %r12, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%r15)
jne 0x44cb
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0x9ca1(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
leaq 0x4bb9(%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 0x442a(%rip), %rdi      # 0x8905
leaq 0x4894(%rip), %rsi      # 0x8d76
leaq 0x4b63(%rip), %rcx      # 0x904c
movl $0x18d, %edx            # imm = 0x18D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4591
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 0x4d94
pushq $0x29
popq %rsi
movq %r12, %rdi
callq 0x4d94
movl %r14d, %eax
andl $0x7, %eax
leal (%rax,%rbx,8), %eax
orb $-0x40, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%r15)
jne 0x4588
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0x9be8(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
movl %ebx, %eax
movq (%rcx,%rax,8), %rcx
leaq 0x4b31(%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 0x436d(%rip), %rdi      # 0x8905
leaq 0x47d7(%rip), %rsi      # 0x8d76
leaq 0x4ada(%rip), %rcx      # 0x9080
movl $0x19c, %edx            # imm = 0x19C
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x464e
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 0x4d94
pushq $-0x7b
popq %rsi
movq %r12, %rdi
callq 0x4d94
movl %r14d, %eax
andl $0x7, %eax
leal (%rax,%rbx,8), %eax
orb $-0x40, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%r15)
jne 0x4645
movq 0x10(%r15), %rdi
movl %r14d, %eax
leaq 0x9b2b(%rip), %rcx      # 0xe150
movq (%rcx,%rax,8), %rdx
movl %ebx, %eax
movq (%rcx,%rax,8), %rcx
leaq 0x4aa6(%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 0x42b0(%rip), %rdi      # 0x8905
leaq 0x471a(%rip), %rsi      # 0x8d76
leaq 0x4a54(%rip), %rcx      # 0x90b7
movl $0x1aa, %edx            # imm = 0x1AA
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4708
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x28(%rdi), %r13
pushq $0xf
popq %rsi
movq %r13, %rdi
callq 0x4d94
movslq %r12d, %r12
leaq 0x4bdd(%rip), %rax      # 0x9286
movsbl -0x4(%r12,%rax), %esi
movq %r13, %rdi
callq 0x4d94
subl 0x30(%rbx), %r15d
addl $-0x4, %r15d
movq %r13, %rdi
movl %r15d, %esi
callq 0x4dd5
cmpb $0x1, 0x20(%rbx)
jne 0x46f1
movq 0x10(%rbx), %rdi
leaq 0x9af5(%rip), %rax      # 0xe1d0
movq -0x20(%rax,%r12,8), %rdx
leaq 0x4a37(%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 0x41f6(%rip), %rdi      # 0x8905
leaq 0x4660(%rip), %rsi      # 0x8d76
leaq 0x49cd(%rip), %rcx      # 0x90ea
movl $0x1b8, %edx            # imm = 0x1B8
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x478e
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
pushq $-0x17
popq %rsi
movq %r12, %rdi
callq 0x4d94
subl 0x30(%rbx), %r15d
addl $-0x4, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x4dd5
cmpb $0x1, 0x20(%rbx)
jne 0x477d
movq 0x10(%rbx), %rdi
leaq 0x49e2(%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 0x4170(%rip), %rdi      # 0x8905
leaq 0x45da(%rip), %rsi      # 0x8d76
leaq 0x4985(%rip), %rcx      # 0x9128
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x47f2
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x47e9
movq %rsi, %r14
movq 0x10(%rbx), %rdi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
callq 0x2110
movq 0x10(%rbx), %rdi
leaq 0x49a7(%rip), %rsi      # 0x9186
movq %r14, %rdx
xorl %eax, %eax
callq 0x2180
movq 0x30(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x410c(%rip), %rdi      # 0x8905
leaq 0x4576(%rip), %rsi      # 0x8d76
leaq 0x4959(%rip), %rcx      # 0x9160
movl $0x1d7, %edx            # imm = 0x1D7
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4884
movq %rsi, %rbx
testq %rsi, %rsi
je 0x48a3
movq %rdi, %r14
leaq 0x28(%rdi), %r15
pushq $-0x18
popq %rsi
movq %r15, %rdi
callq 0x4d94
movq 0x30(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x4e33
movq %r15, %rdi
xorl %esi, %esi
callq 0x4dd5
cmpb $0x1, 0x20(%r14)
jne 0x4879
movq 0x10(%r14), %rdi
movq (%rbx), %rdx
leaq 0x4953(%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 0x407a(%rip), %rdi      # 0x8905
leaq 0x44e4(%rip), %rsi      # 0x8d76
leaq 0x48f6(%rip), %rcx      # 0x918f
movl $0x1e4, %edx            # imm = 0x1E4
callq 0x20b0
leaq 0x490c(%rip), %rdi      # 0x91b6
leaq 0x44c5(%rip), %rsi      # 0x8d76
leaq 0x48d7(%rip), %rcx      # 0x918f
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x494d
movq %rsi, %rbx
testq %rsi, %rsi
je 0x496c
movq %rdi, %r14
leaq 0x28(%rdi), %r15
pushq $-0x18
popq %rsi
movq %r15, %rdi
callq 0x4d94
leaq 0x41f6(%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 0x4dd5
cmpb $0x1, 0x20(%r14)
jne 0x4942
movq 0x10(%r14), %rdi
leaq 0x488d(%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 0x3fb1(%rip), %rdi      # 0x8905
leaq 0x441b(%rip), %rsi      # 0x8d76
leaq 0x4863(%rip), %rcx      # 0x91c5
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x20b0
leaq 0x5c0d(%rip), %rdi      # 0xa580
leaq 0x43fc(%rip), %rsi      # 0x8d76
leaq 0x4844(%rip), %rcx      # 0x91c5
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x49ce
movq %rdi, %rbx
addq $0x28, %rdi
pushq $-0x3d
popq %rsi
callq 0x4d94
cmpb $0x1, 0x20(%rbx)
jne 0x49c7
movq 0x10(%rbx), %rcx
leaq 0x4852(%rip), %rdi      # 0x9208
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3f30(%rip), %rdi      # 0x8905
leaq 0x439a(%rip), %rsi      # 0x8d76
leaq 0x480b(%rip), %rcx      # 0x91ee
movl $0x209, %edx            # imm = 0x209
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4a38
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
pushq $-0x70
popq %rsi
callq 0x4d94
movq 0x30(%r14), %rax
movq %rax, 0x28(%rbx)
cmpb $0x1, 0x20(%r14)
jne 0x4a33
movq 0x10(%r14), %rdi
movq (%rbx), %rdx
leaq 0x4811(%rip), %rsi      # 0x9239
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2180
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3ec6(%rip), %rdi      # 0x8905
leaq 0x4330(%rip), %rsi      # 0x8d76
leaq 0x47c1(%rip), %rcx      # 0x920e
movl $0x215, %edx            # imm = 0x215
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4aa5
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0x4d94
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x4d94
cmpb $0x1, 0x20(%rbx)
jne 0x4aa0
movq 0x10(%rbx), %rcx
leaq 0x47ce(%rip), %rdi      # 0x925f
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x21f0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3e59(%rip), %rdi      # 0x8905
leaq 0x42c3(%rip), %rsi      # 0x8d76
leaq 0x4787(%rip), %rcx      # 0x9241
movl $0x223, %edx            # imm = 0x223
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b00
movq 0x48(%rdi), %rax
pushq $0x8
popq %rcx
subq $0x1, %rax
jb 0x4afe
movq 0x28(%rdi), %rdx
movq 0x40(%rdi), %rsi
movq -0x8(%rsi,%rcx), %r8
movq (%rsi,%rcx), %rsi
movl 0x28(%rsi), %esi
subl %r8d, %esi
addl $-0x4, %esi
movl %esi, (%rdx,%r8)
addq $0x10, %rcx
jmp 0x4ad4
popq %rbp
retq
leaq 0x3dfe(%rip), %rdi      # 0x8905
leaq 0x4268(%rip), %rsi      # 0x8d76
leaq 0x4754(%rip), %rcx      # 0x9269
movl $0x230, %edx            # imm = 0x230
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4c41
leaq 0x1101(%r15), %rsi
movq %rsi, 0x10(%rbx)
movq (%rbx), %rdi
callq 0x21c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x4c64
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 0x4635(%rip), %rdi      # 0x92a0
leaq 0x463d(%rip), %rsi      # 0x92af
leaq 0x4652(%rip), %rcx      # 0x92cb
movl $0xb4, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %rsi
movl $0x2000, %edi           # imm = 0x2000
callq 0x20c0
movq %rax, (%rbx)
movq $0x2000, 0x10(%rbx)     # imm = 0x2000
pushq $0x10
popq %rdi
movq %rdi, %rsi
callq 0x20c0
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq $0x10, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4d13
movq %rdi, %rbx
addq %rsi, %rsi
movq %rsi, 0x10(%rdi)
movq (%rdi), %rdi
callq 0x21c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x4d1a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x457f(%rip), %rdi      # 0x92a0
leaq 0x4587(%rip), %rsi      # 0x92af
leaq 0x45c4(%rip), %rcx      # 0x92f3
movl $0xd8, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4d6e
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 0x4d75
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x45a2(%rip), %rdi      # 0x931e
leaq 0x452c(%rip), %rsi      # 0x92af
leaq 0x45a2(%rip), %rcx      # 0x932c
movl $0xe5, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x4ce5
movq (%r14), %rax
movq 0x8(%r14), %rcx
movl %ebx, (%rax,%rcx)
addq $0x4, %rcx
movq %rcx, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4e78
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4d39
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 0x3cc2(%rip), %rdi      # 0x8b41
leaq 0x4429(%rip), %rsi      # 0x92af
leaq 0x44cf(%rip), %rcx      # 0x935c
movl $0x11f, %edx            # imm = 0x11F
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4edc
callq 0x2140
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4efb
addq $0x18, %rbx
callq 0x2140
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x43bd(%rip), %rdi      # 0x92a0
leaq 0x43c5(%rip), %rsi      # 0x92af
leaq 0x449d(%rip), %rcx      # 0x938e
movl $0x12a, %edx            # imm = 0x12A
callq 0x20b0
leaq 0x441c(%rip), %rdi      # 0x931e
leaq 0x43a6(%rip), %rsi      # 0x92af
leaq 0x447e(%rip), %rcx      # 0x938e
movl $0x130, %edx            # imm = 0x130
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f54
movq %rdi, %rbx
pushq $0x2
popq %rdx
xorl %esi, %esi
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 0x39a5(%rip), %rdi      # 0x8900
leaq 0x4450(%rip), %rsi      # 0x93b2
leaq 0x4462(%rip), %rcx      # 0x93cb
pushq $0x16
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4fe2
movq %rdi, %rbx
pushq $0x1
popq %r12
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x20c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4f1c
movq %rax, %r15
leaq 0x1(%rax), %rdi
movq %r12, %rsi
callq 0x20c0
movq %rax, (%r14)
testq %rax, %rax
je 0x4ffb
movq %rax, %r12
pushq $0x1
popq %rsi
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 0x3917(%rip), %rdi      # 0x8900
leaq 0x43c2(%rip), %rsi      # 0x93b2
leaq 0x43ed(%rip), %rcx      # 0x93e4
pushq $0x21
jmp 0x5012
leaq 0x43fb(%rip), %rdi      # 0x93fd
leaq 0x43a9(%rip), %rsi      # 0x93b2
leaq 0x43d4(%rip), %rcx      # 0x93e4
pushq $0x28
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5045
movq %rdi, %rbx
leaq 0x4280(%rip), %rsi      # 0x92ad
callq 0x2130
testq %rax, %rax
je 0x505e
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4f71
leaq 0x43bd(%rip), %rdi      # 0x9409
leaq 0x435f(%rip), %rsi      # 0x93b2
leaq 0x43b5(%rip), %rcx      # 0x940f
pushq $0x34
jmp 0x5086
leaq 0x43ca(%rip), %rdi      # 0x942f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
leaq 0x43d4(%rip), %rdi      # 0x944a
leaq 0x4335(%rip), %rsi      # 0x93b2
leaq 0x438b(%rip), %rcx      # 0x940f
pushq $0x3a
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x51d7
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4366(%rip), %rdi      # 0x94a7
xorl %eax, %eax
callq 0x2040
movl 0x18(%r14), %edi
callq 0x50c1
movq (%r14), %rax
imulq $0x18, (%rbx), %rcx
movq 0x10(%rax,%rcx), %r15
movq %r15, %rdi
callq 0x21a0
movq 0x10(%r14), %rax
movq %r15, %rdi
cmpq %rax, %rdi
jbe 0x517e
cmpb $0xa, (%rdi)
je 0x517e
decq %rdi
decq %r15
jmp 0x516c
pushq $0xa
popq %r12
movl %r12d, %esi
callq 0x50e9
movl %r12d, %edi
callq 0x2160
negq %r15
xorl %r13d, %r13d
pushq $0x20
popq %r12
imulq $0x18, (%rbx), %rax
movq (%r14), %rcx
movq 0x10(%rcx,%rax), %rax
addq %r15, %rax
cmpq %r13, %rax
jl 0x51bd
movl %r12d, %edi
callq 0x2160
incq %r13
jmp 0x519c
leaq 0x4748(%rip), %rdi      # 0x990c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
leaq 0x4298(%rip), %rdi      # 0x9476
leaq 0x41cd(%rip), %rsi      # 0x93b2
leaq 0x4291(%rip), %rcx      # 0x947d
movl $0x82, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5248
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8fee(%rip), %rsi      # 0xe200
movq %r15, %rdi
callq 0x2070
leaq (%r15,%rax), %r14
movq %r14, (%rbx)
cmpb $0x7e, (%r15,%rax)
jne 0x523d
leaq 0x3679(%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 0x4059(%rip), %rdi      # 0x92a8
leaq 0x415c(%rip), %rsi      # 0x93b2
leaq 0x425f(%rip), %rcx      # 0x94bc
movl $0xa3, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x532b
testq %rsi, %rsi
je 0x534a
movq %rdx, %r14
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
testq %rdx, %rdx
je 0x5369
movq (%r14), %r12
leaq 0x86b0(%rip), %r15      # 0xd958
xorl %ebx, %ebx
cmpq $0xb, %rbx
je 0x5315
movq -0x18(%r15), %rsi
movq -0x10(%r15), %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x2090
testl %eax, %eax
je 0x52e6
movq -0x8(%r15), %rsi
movq (%r15), %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x2090
testl %eax, %eax
je 0x52e6
incq %rbx
addq $0x20, %r15
jmp 0x52aa
movq -0x38(%rbp), %rsi
imulq $0x18, (%rsi), %rax
movq -0x30(%rbp), %rdi
movl %ebx, 0x8(%rdi,%rax)
movq (%rsi), %rax
imulq $0x18, %rax, %rcx
andl $0x0, (%rdi,%rcx)
movq (%r14), %rdx
movq %rdx, 0x10(%rdi,%rcx)
addq %rdx, %r13
movq %r13, (%r14)
incq %rax
movq %rax, (%rsi)
cmpq $0xb, %rbx
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42f9(%rip), %rdi      # 0x962b
leaq 0x4079(%rip), %rsi      # 0x93b2
leaq 0x4198(%rip), %rcx      # 0x94d8
movl $0xae, %edx
callq 0x20b0
leaq 0x397f(%rip), %rdi      # 0x8cd0
leaq 0x405a(%rip), %rsi      # 0x93b2
leaq 0x4179(%rip), %rcx      # 0x94d8
movl $0xaf, %edx
callq 0x20b0
leaq 0x3f38(%rip), %rdi      # 0x92a8
leaq 0x403b(%rip), %rsi      # 0x93b2
leaq 0x415a(%rip), %rcx      # 0x94d8
movl $0xb0, %edx
callq 0x20b0