LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: main
int main()
{
    Tree code = {};
    TreeConstructor (&code);

    if (LoadTree (&code))
        GoElf (&code);

    TreeDestructor (&code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq -0x58(%rbp), %rbx
andq $0x0, (%rbx)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movl $0xc, 0x30(%rbx)
movups %xmm0, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x3502
testb %al, %al
je 0x12f2
leaq -0x58(%rbp), %rdi
callq 0x1304
leaq -0x58(%rbp), %rdi
callq 0x2f34
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: GoElf(Tree*)
void GoElf (Tree* code)
{
    assert (code);

    Elf elf = {};
    if (ElfConstructor (&elf))
        return;
    
    ElfAddBytes (&elf, "\xE8\x00\x00\x00\x00"           // call ♂sex♂
                       "\x48\xC7\xC0\x3C\x00\x00\x00"   // mov rax, 0x3C
                       "\x48\x31\xFF"                   // xor rdi, rdi
                       "\x0F\x05",                      // syscall
                       17);

    ElfAddPlace (&elf, "♂sex♂", 1);

    if (PrintDec (&elf, code->head))
        printf ("Something went wrong...\n");

    ElfCreateJumps (&elf);
    ElfWrite (&elf);
    system ("chmod u+x CompileResult/RightProgram.elf");
    ElfDestructor (&elf);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
testq %rdi, %rdi
je 0x13c6
movq %rdi, %rbx
leaq -0x78(%rbp), %rdi
andq $0x0, (%rdi)
orq $-0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
orq $-0x1, 0x28(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movb $0x0, 0x60(%rdi)
callq 0x13e5
testb %al, %al
jne 0x13bd
leaq 0x2d00(%rip), %rsi      # 0x4059
leaq -0x78(%rbp), %r14
pushq $0x11
popq %rdx
movq %r14, %rdi
callq 0x1504
leaq 0x3063(%rip), %rsi      # 0x43d2
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x1654
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1c17
testb %al, %al
je 0x1395
leaq 0x3427(%rip), %rdi      # 0x47b7
callq 0x1170
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
callq 0x1966
movq %rbx, %rdi
callq 0x1af5
leaq 0x302c(%rip), %rdi      # 0x43dc
callq 0x10c0
movq %rbx, %rdi
callq 0x1450
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2fed(%rip), %rdi      # 0x43ba
leaq 0x2ccc(%rip), %rsi      # 0x40a0
leaq 0x2fe4(%rip), %rcx      # 0x43bf
movl $0x12b, %edx            # imm = 0x12B
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfConstructor(Elf*)
bool ElfConstructor (Elf* elf)
{
    assert (elf);

    elf->text = (char*) calloc (ALIGN, sizeof (*(elf->text)));
    if (!(elf->text))
        return 1;
    
    elf->printf_.func_name  = PRINT_STR;
    elf-> scanf_.func_name  = SCAN_STR;
    elf->aligned_text_size  = ALIGN;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1433
movq %rdi, %rbx
pushq $0x1
popq %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x1090
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x1426
leaq 0x2c0c(%rip), %rcx      # 0x401c
movq %rcx, (%rbx)
leaq 0x2c10(%rip), %rcx      # 0x402a
movq %rcx, 0x20(%rbx)
movq $0x1000, 0x58(%rbx)     # imm = 0x1000
testq %rax, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2eac(%rip), %rdi      # 0x42e6
leaq 0x2c5f(%rip), %rsi      # 0x40a0
leaq 0x2c6c(%rip), %rcx      # 0x40b4
pushq $0x11
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfDestructor(Elf*)
bool ElfDestructor  (Elf* elf)
{
    assert (elf);

    free (elf->text);
    elf->aligned_text_size = 0;
    elf->text_size = 0;
    bool ret = FuncPointerDestructor (elf->functions);
    elf->functions = 0;

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1485
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x1110
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x48(%rbx), %rdi
callq 0x14a2
andq $0x0, 0x48(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2e5a(%rip), %rdi      # 0x42e6
leaq 0x2c0d(%rip), %rsi      # 0x40a0
leaq 0x2c35(%rip), %rcx      # 0x40cf
pushq $0x1f
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerDestructor(FuncPointer*)
bool FuncPointerDestructor  (FuncPointer* func_p)
{
    assert (func_p);

    while (func_p)
    {
        PointerPlace* i_place = func_p->last_pl;
        while (i_place)
        {
            PointerPlace* next_place = i_place->next_place;
            *i_place = {};
            free (i_place);
            i_place  = next_place;
        }

        FuncPointer* next_func = func_p->p_next;
        *func_p = {};
        free (func_p);
        func_p = next_func;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x14e5
movq %rdi, %rbx
testq %rbx, %rbx
je 0x14de
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x14cd
movq 0x8(%rdi), %r14
callq 0x1110
movq %r14, %rdi
jmp 0x14ba
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x1110
movq %r14, %rbx
jmp 0x14b1
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2e33(%rip), %rdi      # 0x431f
leaq 0x2bad(%rip), %rsi      # 0x40a0
leaq 0x2e2c(%rip), %rcx      # 0x4326
movl $0xf5, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddBytes(Elf*, char const*, unsigned long)
bool ElfAddBytes    (Elf* elf, const char* bytes, size_t amount_bytes)
{
    assert (elf);
    assert (bytes);
    if (elf->aligned_text_size < elf->text_size + amount_bytes)
        if (ElfResizeText (elf))
            return 1;

    memcpy (elf->text + elf->text_size, bytes, amount_bytes);
    elf->text_size += amount_bytes;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1563
movq %rsi, %r15
testq %rsi, %rsi
je 0x157c
movq %rdx, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq %rax, 0x58(%r14)
jae 0x1543
movq %r14, %rdi
callq 0x1599
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1558
movq 0x50(%r14), %rdi
addq 0x40(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10b0
addq %rbx, 0x50(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d7c(%rip), %rdi      # 0x42e6
leaq 0x2b2f(%rip), %rsi      # 0x40a0
leaq 0x2b71(%rip), %rcx      # 0x40e9
pushq $0x2c
jmp 0x1593
leaq 0x2b94(%rip), %rdi      # 0x4117
leaq 0x2b16(%rip), %rsi      # 0x40a0
leaq 0x2b58(%rip), %rcx      # 0x40e9
pushq $0x2d
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfResizeText(Elf*)
bool ElfResizeText  (Elf* elf)
{
    assert (elf);

    elf->text = (char*) realloc (elf->text, elf->aligned_text_size + ALIGN); // sizeof (byte = 1)
    if (!(elf->text)) return 1;
    elf->aligned_text_size += ALIGN;
    return ElfFillZero (elf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15e1
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movl $0x1000, %esi           # imm = 0x1000
addq 0x58(%rbx), %rsi
callq 0x1180
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x15d8
addq $0x1000, 0x58(%rbx)     # imm = 0x1000
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x15fe
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2cfe(%rip), %rdi      # 0x42e6
leaq 0x2ab1(%rip), %rsi      # 0x40a0
leaq 0x2b27(%rip), %rcx      # 0x411d
pushq $0x39
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfFillZero(Elf*)
bool ElfFillZero    (Elf* elf)
{
    assert (elf);

    if (elf->aligned_text_size < ALIGN)
        return 1;
    
    for (size_t i_byte = 0; i_byte < ALIGN / 4; i_byte++)
        ((size_t*) elf->text)[i_byte] = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1637
movq 0x58(%rdi), %rax
cmpq $0x1000, %rax           # imm = 0x1000
jae 0x161e
cmpq $0x1000, %rax           # imm = 0x1000
setb %al
popq %rbp
retq
movq 0x40(%rdi), %rcx
xorl %edx, %edx
cmpq $0x400, %rdx            # imm = 0x400
je 0x1613
andq $0x0, (%rcx,%rdx,8)
incq %rdx
jmp 0x1624
leaq 0x2ca8(%rip), %rdi      # 0x42e6
leaq 0x2a5b(%rip), %rsi      # 0x40a0
leaq 0x2aeb(%rip), %rcx      # 0x4137
pushq $0x43
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddPlace(Elf*, char const*, unsigned long)
bool ElfAddPlace    (Elf* elf, const char* func_name, size_t place)
{
    assert (elf);

    if (strcmp (PRINT_STR, func_name) == 0)
        return ElfAddPrintf (elf, place);

    if (strcmp (SCAN_STR, func_name)  == 0)
        return ElfAddScanf  (elf, place);

    FuncPointer* func_p = elf->functions;
    while (func_p)
    {
        if (strcmp (func_p->func_name, func_name) == 0)
            return FuncPointerGetNewPlace (func_p, place);
        
        func_p = func_p->p_next;
    }
    
    if (FuncPointerConstructor (elf, func_name))
        return 1;
    
    return FuncPointerGetNewPlace (elf->functions, place);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1705
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x29a1(%rip), %rdi      # 0x401c
callq 0x1140
testl %eax, %eax
je 0x16c1
leaq 0x299f(%rip), %rdi      # 0x402a
movq %r15, %rsi
callq 0x1140
testl %eax, %eax
je 0x16bd
leaq 0x48(%r14), %r13
movq %r13, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x16c6
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1140
testl %eax, %eax
je 0x16e6
addq $0x18, %r12
jmp 0x169e
addq $0x20, %r14
movq %r14, %rdi
jmp 0x16ef
movq %r14, %rdi
movq %r15, %rsi
callq 0x17d6
testb %al, %al
je 0x16eb
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
jmp 0x16ef
movq (%r13), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x177b
leaq 0x2bda(%rip), %rdi      # 0x42e6
leaq 0x298d(%rip), %rsi      # 0x40a0
leaq 0x2a35(%rip), %rcx      # 0x414f
pushq $0x4f
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerGetNewPlace(FuncPointer*, unsigned long)
bool FuncPointerGetNewPlace (FuncPointer* func_p, size_t place)
{
    assert (func_p);

    PointerPlace* new_place = (PointerPlace*) calloc (1, sizeof (*new_place));
    if (!new_place)
        return 1;
    
    new_place->point = place;
    new_place->next_place = func_p->last_pl;
    func_p->last_pl = new_place;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x17b7
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x1090
testq %rax, %rax
je 0x17ac
movq %r14, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rbx)
testq %rax, %rax
sete %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2b61(%rip), %rdi      # 0x431f
leaq 0x28db(%rip), %rsi      # 0x40a0
leaq 0x2b84(%rip), %rcx      # 0x4350
movl $0x10d, %edx            # imm = 0x10D
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerConstructor(Elf*, char const*)
bool FuncPointerConstructor (Elf* elf, const char* func_name)
{
    assert (elf);
    assert (func_name);

    FuncPointer* func_p = (FuncPointer*) calloc (1, sizeof (*func_p));
    if (!func_p)
        return 1;
    
    func_p->func_name = func_name;
    func_p->p_next    = elf->functions;
    elf->functions    = func_p;
    func_p->func_pl   = elf->text_size;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x181f
movq %rsi, %r14
testq %rsi, %rsi
je 0x183e
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x1090
testq %rax, %rax
je 0x1814
movq %r14, (%rax)
movq 0x48(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x48(%rbx)
movq 0x50(%rbx), %rcx
movq %rcx, 0x8(%rax)
testq %rax, %rax
sete %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2ac0(%rip), %rdi      # 0x42e6
leaq 0x2873(%rip), %rsi      # 0x40a0
leaq 0x2aba(%rip), %rcx      # 0x42ee
movl $0xe5, %edx
callq 0x1080
leaq 0x299e(%rip), %rdi      # 0x41e3
leaq 0x2854(%rip), %rsi      # 0x40a0
leaq 0x2a9b(%rip), %rcx      # 0x42ee
movl $0xe6, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddFunc(Elf*, char const*)
bool ElfAddFunc     (Elf* elf, const char* func_name)
{
    assert (elf);
    assert (func_name);

    FuncPointer* func_p = elf->functions;
    while (func_p)
    {
        if (strcmp (func_p->func_name, func_name) == 0)
        {
            func_p->func_pl = elf->text_size;
            return 0;
        }

        func_p = func_p->p_next;
    }

    return FuncPointerConstructor (elf, func_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18c2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18db
movq %rdi, %r14
leaq 0x48(%rdi), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x1898
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0x18ad
addq $0x18, %r15
jmp 0x187b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x17d6
movq 0x50(%r14), %rax
movq %rax, 0x8(%r15)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a1d(%rip), %rdi      # 0x42e6
leaq 0x27d0(%rip), %rsi      # 0x40a0
leaq 0x28e7(%rip), %rcx      # 0x41be
pushq $0x76
jmp 0x18f2
leaq 0x2901(%rip), %rdi      # 0x41e3
leaq 0x27b7(%rip), %rsi      # 0x40a0
leaq 0x28ce(%rip), %rcx      # 0x41be
pushq $0x77
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfCreateJumps(Elf*)
bool ElfCreateJumps (Elf* elf)
{
    assert (elf);

    FuncPointer* func_p = elf->functions;

    while (func_p)
    {
        if (func_p->func_pl == __SIZE_MAX__)
        {
            printf ("Error: Function \"%s\" isn't defined.\n", func_p->func_name);
            return 1;
        }

        FuncPointerFillPlaces (func_p, elf->text);
        func_p = func_p->p_next;
    }

    if (elf->printf_.last_pl)
        if (ElfAddLibrary (elf, "Libraries/printf.gcmlib", &(elf->printf_)))
            return 1;

    if (elf->scanf_.last_pl)
        if (ElfAddLibrary (elf, "Libraries/scanf.gcmlib", &(elf->scanf_)))
            return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x19fd
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x199e
cmpq $-0x1, 0x8(%r14)
je 0x19e5
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x1a1c
addq $0x18, %r14
jmp 0x197d
cmpq $0x0, 0x10(%rbx)
je 0x19bf
leaq 0x28b7(%rip), %rsi      # 0x4263
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x1a8f
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x19f8
cmpq $0x0, 0x30(%rbx)
je 0x19e1
leaq 0x20(%rbx), %rdx
leaq 0x28aa(%rip), %rsi      # 0x427b
movq %rbx, %rdi
callq 0x1a8f
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x19f8
xorl %eax, %eax
jmp 0x19f8
movq (%r14), %rsi
leaq 0x284f(%rip), %rdi      # 0x423e
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28e2(%rip), %rdi      # 0x42e6
leaq 0x2695(%rip), %rsi      # 0x40a0
leaq 0x2811(%rip), %rcx      # 0x4223
movl $0x9d, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerFillPlaces(FuncPointer*, char*)
void FuncPointerFillPlaces  (FuncPointer* func_p, char* text)
{
    assert (func_p);
    assert (text);

    int func_addr = (int) func_p->func_pl;
    PointerPlace* i_place = func_p->last_pl;

    while (i_place)
    {
        *(int*) (text + i_place->point) = func_addr - JMP_NUM_SIZE - i_place->point;
        i_place = i_place->next_place;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1a51
testq %rsi, %rsi
je 0x1a70
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
addq 0x8(%rdi), %rax
addq $0x10, %rdi
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1a4f
movq (%rdi), %rcx
movl %eax, %edx
subl %ecx, %edx
movl %edx, (%rsi,%rcx)
addq $0x8, %rdi
jmp 0x1a37
popq %rbp
retq
leaq 0x28c7(%rip), %rdi      # 0x431f
leaq 0x2641(%rip), %rsi      # 0x40a0
leaq 0x291d(%rip), %rcx      # 0x4383
movl $0x11b, %edx            # imm = 0x11B
callq 0x1080
leaq 0x293e(%rip), %rdi      # 0x43b5
leaq 0x2622(%rip), %rsi      # 0x40a0
leaq 0x28fe(%rip), %rcx      # 0x4383
movl $0x11c, %edx            # imm = 0x11C
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddLibrary(Elf*, char const*, FuncPointer*)
bool ElfAddLibrary  (Elf* elf, const char* lib_name, FuncPointer* lib_p)
{
    char* lib_text  = nullptr;
    size_t lib_size = ReadTxt (&lib_text, lib_name);
    if (!lib_size)
        return 1;

    lib_p->func_pl = elf->text_size;
    if (ElfAddBytes (elf, lib_text, lib_size))
        return 1;

    FuncPointerFillPlaces (lib_p, elf->text);
    free (lib_text);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rdi
andq $0x0, (%rdi)
callq 0x3281
movb $0x1, %r15b
testq %rax, %rax
je 0x1ae7
movq 0x50(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rbp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x1504
testb %al, %al
jne 0x1ae7
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x1a1c
movq -0x20(%rbp), %rdi
callq 0x1110
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfWrite(Elf*)
bool ElfWrite       (Elf* elf)
{
    assert (elf);

    system ("cp Backend/ServiceFiles/MagicHeader CompileResult/RightProgram.elf");

    FILE* compiled_file = fopen ("CompileResult/RightProgram.elf", "a+b");
    if (!compiled_file)
    {
        printf ("Error: Unable to create or open file: \"CompileResult/RightProgram.elf\".\n");
        return 1;
    }

    fwrite (&(elf->text_size), sizeof (elf->text_size), 1, compiled_file); // p_filesz
    fwrite (&(elf->text_size), sizeof (elf->text_size), 1, compiled_file); // p_memsz
    fwrite (&ALIGN, sizeof (ALIGN), 1, compiled_file); // p_align
    // fseek  (compiled_file, ALIGN, SEEK_SET); It doesn't work (documentation for a) :-(

    size_t align_need_many_zeroes = (ALIGN - ftell (compiled_file)) / 8;
    for (size_t i_8byte = 0; i_8byte < align_need_many_zeroes; i_8byte++)
        fwrite ("\0\0\0\0\0\0\0\0", 1, 8, compiled_file);

    fwrite (elf->text, sizeof (*(elf->text)), elf->aligned_text_size, compiled_file);
    fclose (compiled_file);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1bf8
movq %rdi, %r14
leaq 0x2791(%rip), %rdi      # 0x42a7
callq 0x10c0
leaq 0x27a9(%rip), %rdi      # 0x42cb
leaq 0x27c1(%rip), %rsi      # 0x42ea
callq 0x1100
movq %rax, %rbx
testq %rax, %rax
je 0x1bd7
movq %r14, -0x30(%rbp)
leaq 0x50(%r14), %r13
pushq $0x8
popq %r15
pushq $0x1
popq %r12
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
leaq 0x24d5(%rip), %rdi      # 0x4048
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
callq 0x1030
movl $0x1000, %r14d          # imm = 0x1000
subq %rax, %r14
shrq $0x3, %r14
leaq 0x24b3(%rip), %r13      # 0x4050
subq $0x1, %r14
jb 0x1bb6
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1190
jmp 0x1b9d
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x58(%rax), %rdx
pushq $0x1
popq %rsi
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
callq 0x10e0
jmp 0x1be3
leaq 0x2bf1(%rip), %rdi      # 0x47cf
callq 0x1170
testq %rbx, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26e7(%rip), %rdi      # 0x42e6
leaq 0x249a(%rip), %rsi      # 0x40a0
leaq 0x2685(%rip), %rcx      # 0x4292
movl $0xca, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintDec(Elf*, element*)
bool PrintDec (Elf* elf, element* el)
{
    assert (elf);
    assert (el);
    
    if (el->type != DEC)
        return 1;

    if (PrintFunc (elf, el->left))
        return 1;

    if (el->right && PrintDec (elf, el->right))
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c6a
movq %rsi, %r15
testq %rsi, %rsi
je 0x1c89
movb $0x1, %bl
cmpl $0x1, (%r15)
jne 0x1c5d
movq %rdi, %r14
movq 0x8(%r15), %rsi
callq 0x1ca8
testb %al, %al
jne 0x1c5d
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x1c5b
movq %r14, %rdi
callq 0x1c17
testb %al, %al
jne 0x1c5d
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2675(%rip), %rdi      # 0x42e6
leaq 0x2428(%rip), %rsi      # 0x40a0
leaq 0x2786(%rip), %rcx      # 0x4405
movl $0x145, %edx            # imm = 0x145
callq 0x1080
leaq 0x2795(%rip), %rdi      # 0x4425
leaq 0x2409(%rip), %rsi      # 0x40a0
leaq 0x2767(%rip), %rcx      # 0x4405
movl $0x146, %edx            # imm = 0x146
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintFunc(Elf*, element*)
bool PrintFunc (Elf* elf, element* el)
{
    assert (elf);
    assert (el);
    if (el->type != FUNC)
        return 1;

    ElfAddFunc (elf, el->ind);
    elf->xmm_counter = 0;

    const size_t max_var_num = 32;
    Stack vars_ = {};
    StackConstructor (&vars_, max_var_num);

    char var_count = FIRST_LOCAL_VAR;
    if (TakeFuncVars (el, &vars_, &var_count))
    {
        StackDestructor (&vars_);
        return 1;
    }

    Stack* vars = &vars_;
    ElfStartFunc (elf);
    TryPrint (PrintLR,   right);
    ElfEndFunc (elf);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
testq %rdi, %rdi
je 0x1da5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1dc4
movb $0x1, %al
cmpl $0x2, (%rbx)
jne 0x1d9a
movq %rdi, %r14
movq 0x18(%rbx), %rsi
callq 0x185d
movb $0x0, 0x60(%r14)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
leaq -0x68(%rbp), %r15
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movl $0xc, 0x28(%r15)
movups %xmm0, 0x30(%r15)
movq %rax, 0x40(%r15)
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x37a8
leaq -0x19(%rbp), %rdx
movb $-0x8, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1de3
testb %al, %al
je 0x1d41
leaq -0x68(%rbp), %rdi
callq 0x3b2e
jmp 0x1d8c
movq %r14, %rdi
callq 0x18f8
movq 0x10(%rbx), %rsi
leaq -0x68(%rbp), %rdx
movq %r14, %rdi
callq 0x1f4c
testb %al, %al
je 0x1d90
leaq 0x26e5(%rip), %rdi      # 0x4449
leaq 0x26bd(%rip), %rsi      # 0x4428
movl $0x16b, %edx            # imm = 0x16B
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x26ec(%rip), %rdi      # 0x446e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
jmp 0x1d9a
movq %r14, %rdi
callq 0x192f
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x253a(%rip), %rdi      # 0x42e6
leaq 0x22ed(%rip), %rsi      # 0x40a0
leaq 0x266e(%rip), %rcx      # 0x4428
movl $0x156, %edx            # imm = 0x156
callq 0x1080
leaq 0x265a(%rip), %rdi      # 0x4425
leaq 0x22ce(%rip), %rsi      # 0x40a0
leaq 0x264f(%rip), %rcx      # 0x4428
movl $0x157, %edx            # imm = 0x157
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintLR(Elf*, element*, Stack*)
bool PrintLR    (Elf* elf, element* el, Stack* vars)
{
    print_ass;

    if (el->type == LR)
    {
        if (el->left)
            TryPrint (PrintLR, left);
        if (el->right)
            TryPrint (PrintLR, right);
        return 0;
    }

    elf->xmm_counter = 0;

    switch (el->type)
    {
        case EQUAL:
            return PrintEqual (elf, el, vars);
        case CALL:
            return PrintCall  (elf, el, vars);
        case RET:
            return PrintRet   (elf, el, vars);
        case IF:
        case WHILE:
            return PrintCond  (elf, el, vars);
        default:
            return 1;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2083
movq %rsi, %rbx
testq %rsi, %rsi
je 0x208c
movq %rdx, %r14
testq %rdx, %rdx
je 0x2095
movq %rdi, %r15
movl (%rbx), %eax
cmpl $0x3, %eax
jne 0x1fae
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1fe3
movq %r15, %rdi
movq %r14, %rdx
callq 0x1f4c
testb %al, %al
je 0x1fe3
leaq 0x24a9(%rip), %rdi      # 0x4449
leaq 0x254c(%rip), %rsi      # 0x44f3
movl $0x1bc, %edx            # imm = 0x1BC
jmp 0x200e
movb $0x0, 0x60(%r15)
addl $-0xa, %eax
cmpl $0x4, %eax
ja 0x202a
leaq 0x2046(%rip), %rcx      # 0x4008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2480
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x202e
movq %r15, %rdi
movq %r14, %rdx
callq 0x1f4c
testb %al, %al
je 0x202e
leaq 0x2447(%rip), %rdi      # 0x4449
leaq 0x24ea(%rip), %rsi      # 0x44f3
movl $0x1be, %edx            # imm = 0x1BE
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x244e(%rip), %rdi      # 0x446e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
jmp 0x2030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2151
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23cd
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2258
leaq 0x225c(%rip), %rdi      # 0x42e6
jmp 0x209c
leaq 0x2392(%rip), %rdi      # 0x4425
jmp 0x209c
leaq 0x23f5(%rip), %rdi      # 0x4491
leaq 0x1ffd(%rip), %rsi      # 0x40a0
leaq 0x2449(%rip), %rcx      # 0x44f3
movl $0x1b7, %edx            # imm = 0x1B7
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: VarNumber(Stack*, char const*)
char VarNumber (Stack* vars, const char* var_name)
{
    assert (vars);
    assert (var_name);

    for (size_t result = 0; result < vars->size; result++)
        if (strcmp (var_name, vars->buffer[result].ind) == 0)
            return vars->buffer[result].var_pos;

    return VAR_WASNT_CREATED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2113
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2132
movq %rdi, %r14
movq 0x10(%rdi), %r15
incq %r15
pushq $0x18
popq %r12
decq %r15
je 0x2102
movq 0x8(%r14), %r13
movq (%r13,%r12), %rsi
addq $0x30, %r12
movq %rbx, %rdi
callq 0x1140
testl %eax, %eax
jne 0x20dd
movb -0x20(%r13,%r12), %al
jmp 0x2104
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2377(%rip), %rdi      # 0x4491
leaq 0x1f7f(%rip), %rsi      # 0x40a0
leaq 0x239c(%rip), %rcx      # 0x44c4
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x1080
leaq 0x23b1(%rip), %rdi      # 0x44ea
leaq 0x1f60(%rip), %rsi      # 0x40a0
leaq 0x237d(%rip), %rcx      # 0x44c4
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintEqual(Elf*, element*, Stack*)
bool PrintEqual (Elf* elf, element* el, Stack* vars)
{
    print_ass;
    
    if (!(el->left) || !(el->right) || el->left->type != VAR)
        return 1;

    TryPrint (PrintArith, right);

    char var_num = VarNumber (vars, el->left->ind);
    if (var_num == VAR_WASNT_CREATED)
        return 1;

    ElfAddBytes (elf, "\xF2\x0F\x11\x45", 4); // movsd [rbp - 8*№], xmm0
    return ElfAddBytes (elf, &var_num, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x2227
movq %rsi, %r15
testq %rsi, %rsi
je 0x2230
movq %rdx, %r12
testq %rdx, %rdx
je 0x2239
movq 0x8(%r15), %rax
movb $0x1, %bl
testq %rax, %rax
je 0x2218
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x2218
cmpl $0x8, (%rax)
jne 0x2218
movq %rdi, %r14
movq %r12, %rdx
callq 0x25bc
testb %al, %al
je 0x21de
leaq 0x2295(%rip), %rdi      # 0x4449
leaq 0x2360(%rip), %rsi      # 0x451b
movl $0x1dd, %edx            # imm = 0x1DD
xorl %eax, %eax
callq 0x1040
movq 0x18(%r15), %rdx
leaq 0x229c(%rip), %rdi      # 0x446e
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x2218
movq 0x8(%r15), %rax
movq 0x18(%rax), %rsi
movq %r12, %rdi
callq 0x20b4
movb %al, -0x21(%rbp)
cmpb $0x1, %al
je 0x2218
leaq 0x234a(%rip), %rsi      # 0x4546
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x1504
leaq -0x21(%rbp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x1504
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20b8(%rip), %rdi      # 0x42e6
jmp 0x2240
leaq 0x21ee(%rip), %rdi      # 0x4425
jmp 0x2240
leaq 0x2251(%rip), %rdi      # 0x4491
leaq 0x1e59(%rip), %rsi      # 0x40a0
leaq 0x22cd(%rip), %rcx      # 0x451b
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintCall(Elf*, element*, Stack*)
bool PrintCall  (Elf* elf, element* el, Stack* vars)
{
    print_ass;

    if (strcmp (SQRT_STR, el->ind) == 0)
        return PrintSqrt (elf, el, vars);

    PrintSaveXMM (elf);

    int push_shift = 0; // number of pushes on bytes
    if (PrintCallParam (elf, el->left, vars, &push_shift))
        return 1;

    // ToDo: Sin, cos, pow, sqrt
    
    ElfAddPlace (elf, el->ind, elf->text_size + 1);
    ElfAddBytes (elf, "\xE8\x00\x00\x00\x00", 5); // call 00 00 00 00
    
    // This is delete pushes
    ElfAddBytes (elf, "\x48\x81\xC4", 3); // add rsp, push_shift
    ElfAddBytes (elf, (char*) &push_shift, 4);
    mov_xmm_rax // movq xmm?, rax

    PrintLoadXMM (elf);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x239c
movq %rsi, %r15
testq %rsi, %rsi
je 0x23a5
movq %rdx, %r14
testq %rdx, %rdx
je 0x23ae
movq %rdi, %rbx
movq 0x18(%r15), %rsi
leaq 0x1dda(%rip), %rdi      # 0x406b
callq 0x1140
testl %eax, %eax
je 0x236a
movq %rbx, %rdi
callq 0x2aa2
leaq -0x20(%rbp), %rcx
andl $0x0, (%rcx)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2b5e
movb $0x1, %r14b
testb %al, %al
jne 0x238e
movq 0x18(%r15), %rsi
movq 0x50(%rbx), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x1654
leaq 0x1d99(%rip), %rsi      # 0x407a
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x1504
leaq 0x22ad(%rip), %rsi      # 0x45a0
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1504
leaq -0x20(%rbp), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1504
movb 0x60(%rbx), %al
cmpb $0xf, %al
jg 0x2382
cmpb $0x8, %al
leaq 0x2287(%rip), %rax      # 0x45a4
leaq 0x2285(%rip), %rsi      # 0x45a9
cmovlq %rax, %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1504
movb 0x60(%rbx), %al
movsbl %al, %ecx
movb $0x8, %dl
movl %ecx, %eax
idivb %dl
movsbl %ah, %eax
shlb $0x3, %al
addb $-0x40, %al
leaq -0x19(%rbp), %rsi
movb %al, (%rsi)
incb %cl
movb %cl, 0x60(%rbx)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1504
movq %rbx, %rdi
callq 0x2cb0
xorl %r14d, %r14d
jmp 0x238e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29ae
leaq 0x2529(%rip), %rdi      # 0x48b2
callq 0x1170
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f43(%rip), %rdi      # 0x42e6
jmp 0x23b5
leaq 0x2079(%rip), %rdi      # 0x4425
jmp 0x23b5
leaq 0x20dc(%rip), %rdi      # 0x4491
leaq 0x1ce4(%rip), %rsi      # 0x40a0
leaq 0x21b3(%rip), %rcx      # 0x4576
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintRet(Elf*, element*, Stack*)
bool PrintRet   (Elf* elf, element* el, Stack* vars)
{
    print_ass;

    if (el->type != RET)
        return 1;

    TryPrint (PrintArith, left);

    ElfAddBytes (elf, "\x66\x48\x0F\x7E\xC0", 5); // movq rax, xmm0
    return ElfEndFunc (elf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x244f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2458
testq %rdx, %rdx
je 0x2461
cmpl $0xa, (%rbx)
jne 0x242a
movq %rdi, %r14
movq 0x8(%rbx), %rsi
callq 0x25bc
testb %al, %al
je 0x2431
leaq 0x2047(%rip), %rdi      # 0x4449
leaq 0x21a5(%rip), %rsi      # 0x45ae
movl $0x219, %edx            # imm = 0x219
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x204e(%rip), %rdi      # 0x446e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x219f(%rip), %rsi      # 0x45d7
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x1504
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x192f
leaq 0x1e90(%rip), %rdi      # 0x42e6
jmp 0x2468
leaq 0x1fc6(%rip), %rdi      # 0x4425
jmp 0x2468
leaq 0x2029(%rip), %rdi      # 0x4491
leaq 0x1c31(%rip), %rsi      # 0x40a0
leaq 0x2138(%rip), %rcx      # 0x45ae
movl $0x214, %edx            # imm = 0x214
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintCond(Elf*, element*, Stack*)
bool PrintCond  (Elf* elf, element* el, Stack* vars)
{
    print_ass;
    if (el->type != IF && el->type != WHILE)
        return 1;
    
    int start_of_while = (int) (elf->text_size);

    if (PrintComp (elf, el->left, vars)) 
            return 1;

    size_t jump_from_place = elf->text_size;

    if (el->right)
        TryPrint (PrintLR, right);

    if (el->type == WHILE)
    {   
        ElfAddBytes (elf, "\xE9", 1); // 0xE9 = jmp
        start_of_while -= elf->text_size + JMP_NUM_SIZE;
        ElfAddBytes (elf, (char*) &start_of_while, JMP_NUM_SIZE);
    }

    // Place of conditional jump
    *((int*) (elf->text + jump_from_place - JMP_NUM_SIZE)) = (int) (elf->text_size - jump_from_place);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x258b
movq %rsi, %r14
testq %rsi, %rsi
je 0x2594
movq %rdx, %r12
testq %rdx, %rdx
je 0x259d
movl (%r14), %eax
addl $-0xb, %eax
movb $0x1, %r15b
cmpl $0x1, %eax
ja 0x2579
movq %rdi, %rbx
movl 0x50(%rdi), %r13d
movq 0x8(%r14), %rsi
movq %r12, %rdx
callq 0x2d61
movb $0x1, %r15b
testb %al, %al
jne 0x2579
movq 0x50(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x2533
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1f4c
testb %al, %al
je 0x2533
leaq 0x1f40(%rip), %rdi      # 0x4449
leaq 0x20cd(%rip), %rsi      # 0x45dd
movl $0x22d, %edx            # imm = 0x22D
xorl %eax, %eax
callq 0x1040
movq 0x18(%r14), %rdx
leaq 0x1f47(%rip), %rdi      # 0x446e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x2579
cmpl $0xc, (%r14)
jne 0x2565
leaq 0x20c7(%rip), %rsi      # 0x4607
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1504
subl 0x50(%rbx), %r13d
addl $-0x4, %r13d
leaq -0x34(%rbp), %rsi
movl %r13d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1504
movl 0x50(%rbx), %eax
movq -0x30(%rbp), %rdx
subl %edx, %eax
movq 0x40(%rbx), %rcx
movl %eax, -0x4(%rcx,%rdx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d54(%rip), %rdi      # 0x42e6
jmp 0x25a4
leaq 0x1e8a(%rip), %rdi      # 0x4425
jmp 0x25a4
leaq 0x1eed(%rip), %rdi      # 0x4491
leaq 0x1af5(%rip), %rsi      # 0x40a0
leaq 0x202b(%rip), %rcx      # 0x45dd
movl $0x221, %edx            # imm = 0x221
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintArith(Elf*, element*, Stack*)
bool PrintArith (Elf* elf, element* el, Stack* vars)
{
    print_ass;

    if (el->type == CALL)
        return PrintCall (elf, el, vars);

    if (el->type == NUM)
        return PrintArithNum (elf, el);

    if (el->type == VAR)
        return PrintArithVar (elf, el, vars);

    return PrintArithOper (elf, el, vars);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x25f8
testq %rsi, %rsi
je 0x2601
testq %rdx, %rdx
je 0x260a
movl (%rsi), %eax
cmpl $0x7, %eax
je 0x25ec
cmpl $0x8, %eax
je 0x25e6
cmpl $0xd, %eax
jne 0x25f2
popq %rbp
jmp 0x2258
popq %rbp
jmp 0x272c
popq %rbp
jmp 0x2629
popq %rbp
jmp 0x2821
leaq 0x1ce7(%rip), %rdi      # 0x42e6
jmp 0x2611
leaq 0x1e1d(%rip), %rdi      # 0x4425
jmp 0x2611
leaq 0x1e80(%rip), %rdi      # 0x4491
leaq 0x1a88(%rip), %rsi      # 0x40a0
leaq 0x1f2c(%rip), %rcx      # 0x454b
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintArithNum(Elf*, element*)
bool PrintArithNum  (Elf* elf, element* el)
{
    assert (elf);
    assert (el);

    double num = atof (el->ind);
    ElfAddBytes (elf, "\x48\xB8", 2); // mov rax, number
    ElfAddBytes (elf, (char*) &num, 8);
    mov_xmm_rax // movq xmm?, rax

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x26ee
testq %rsi, %rsi
je 0x270d
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0x1120
leaq -0x20(%rbp), %r14
movsd %xmm0, (%r14)
leaq 0x203c(%rip), %rsi      # 0x469e
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x1504
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1504
movb 0x60(%rbx), %r14b
cmpb $0xf, %r14b
jle 0x2693
leaq 0x2226(%rip), %rdi      # 0x48b2
callq 0x1170
jmp 0x26de
cmpb $0x8, %r14b
leaq 0x1f06(%rip), %rax      # 0x45a4
leaq 0x1f04(%rip), %rsi      # 0x45a9
cmovlq %rax, %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1504
movb 0x60(%rbx), %al
movsbl %al, %ecx
movb $0x8, %dl
movl %ecx, %eax
idivb %dl
movsbl %ah, %eax
shlb $0x3, %al
addb $-0x40, %al
leaq -0x11(%rbp), %rsi
movb %al, (%rsi)
incb %cl
movb %cl, 0x60(%rbx)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1504
cmpb $0x10, %r14b
setge %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bf1(%rip), %rdi      # 0x42e6
leaq 0x19a4(%rip), %rsi      # 0x40a0
leaq 0x1fa4(%rip), %rcx      # 0x46a7
movl $0x2a9, %edx            # imm = 0x2A9
callq 0x1080
leaq 0x1d11(%rip), %rdi      # 0x4425
leaq 0x1985(%rip), %rsi      # 0x40a0
leaq 0x1f85(%rip), %rcx      # 0x46a7
movl $0x2aa, %edx            # imm = 0x2AA
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintArithVar(Elf*, element*, Stack*)
bool PrintArithVar  (Elf* elf, element* el, Stack* vars)
{
    print_ass;
    if (elf->xmm_counter < XMM_MAX)
    {
        char var_num = VarNumber (vars, el->ind);
        if (var_num == VAR_WASNT_CREATED)
            return 1;

        if (elf->xmm_counter < 8)
            ElfAddBytes (elf, "\xF2\x0F\x10", 3); // movsd xmm?, qword [rbp - 8*№]
        else
            ElfAddBytes (elf, "\xF2\x44\x0F\x10", 4); // movsd xmm?, qword [rbp - 8*№]

        char num_register = (elf->xmm_counter % 8) * 8 + 0x45;
        elf->xmm_counter += 1;

        ElfAddBytes (elf, &num_register, 1);
        ElfAddBytes (elf, &var_num, 1);
    }
    else
    {
        printf ("Fucking slave, you are bad programmer! Your math expression is so big.\n");
        return 1;
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x27f0
testq %rsi, %rsi
je 0x27f9
testq %rdx, %rdx
je 0x2802
movq %rdi, %rbx
cmpb $0xf, 0x60(%rdi)
jg 0x2782
movq 0x18(%rsi), %rsi
movq %rdx, %rdi
callq 0x20b4
movb %al, -0x19(%rbp)
cmpb $0x1, %al
sete %r14b
je 0x27e2
cmpb $0x7, 0x60(%rbx)
jg 0x2793
leaq 0x1f7c(%rip), %rsi      # 0x46fa
pushq $0x3
jmp 0x279c
leaq 0x21a0(%rip), %rdi      # 0x4929
callq 0x1170
movb $0x1, %r14b
jmp 0x27e2
leaq 0x1f64(%rip), %rsi      # 0x46fe
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1504
movb 0x60(%rbx), %al
movsbl %al, %ecx
movb $0x8, %dl
movl %ecx, %eax
idivb %dl
movsbl %ah, %eax
shlb $0x3, %al
addb $0x45, %al
leaq -0x1a(%rbp), %rsi
movb %al, (%rsi)
incb %cl
movb %cl, 0x60(%rbx)
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1504
leaq -0x19(%rbp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1504
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1aef(%rip), %rdi      # 0x42e6
jmp 0x2809
leaq 0x1c25(%rip), %rdi      # 0x4425
jmp 0x2809
leaq 0x1c88(%rip), %rdi      # 0x4491
leaq 0x1890(%rip), %rsi      # 0x40a0
leaq 0x1eb5(%rip), %rcx      # 0x46cc
movl $0x2b6, %edx            # imm = 0x2B6
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintSqrt(Elf*, element*, Stack*)
bool PrintSqrt (Elf* elf, element* el, Stack* vars)
{
    print_ass;

    if (el->left->type == NUM)
    {
        if (PrintArithNum (elf, el->left))
            return 1;
    }

    else if (el->left->type == VAR)
    {
        if (PrintArithVar (elf, el->left, vars))
            return 1;
    }
    
    else return 1;

    // sqrtsd xmm(№-1), xmm№
    char num_register = ((elf->xmm_counter - 1) % 8) * 8 + 0xC0;
    if (elf->xmm_counter <= 8)
        ElfAddBytes (elf, "\xF2\x0F\x51", 3); // sqrtsd xmm[0:6], xmm[1:7]
    if (elf->xmm_counter == 8)
        ElfAddBytes (elf, "\xF2\x41\x0F\x51", 4); // sqrtsd xmm7, xmm8
    else
        ElfAddBytes (elf, "\xF2\x45\x0F\x51", 4); // sqrtsd xmm[8:14], xmm[9:15]
    
    return ElfAddBytes (elf, &num_register, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x2a71
testq %rsi, %rsi
je 0x2a7a
testq %rdx, %rdx
je 0x2a83
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movl (%rsi), %eax
movb $0x1, %r14b
cmpl $0x8, %eax
je 0x29f4
cmpl $0x7, %eax
jne 0x2a65
movq %rbx, %rdi
callq 0x2629
jmp 0x29fc
movq %rbx, %rdi
callq 0x272c
testb %al, %al
jne 0x2a65
movsbl 0x60(%rbx), %ecx
movl %ecx, %eax
decl %eax
movw $0x8, %si
cwtd
idivw %si
shlb $0x3, %dl
addb $-0x40, %dl
movb %dl, -0x11(%rbp)
cmpw $0x8, %cx
jg 0x2a41
leaq 0x1d82(%rip), %rsi      # 0x47a9
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1504
cmpb $0x8, 0x60(%rbx)
jne 0x2a41
leaq 0x1d6e(%rip), %rsi      # 0x47ad
jmp 0x2a48
leaq 0x1d6a(%rip), %rsi      # 0x47b2
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1504
leaq -0x11(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1504
movl %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x186e(%rip), %rdi      # 0x42e6
jmp 0x2a8a
leaq 0x19a4(%rip), %rdi      # 0x4425
jmp 0x2a8a
leaq 0x1a07(%rip), %rdi      # 0x4491
leaq 0x160f(%rip), %rsi      # 0x40a0
leaq 0x1ce7(%rip), %rcx      # 0x477f
movl $0x323, %edx            # imm = 0x323
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintSaveXMM(Elf*)
bool PrintSaveXMM   (Elf* elf)
{
    assert (elf);

    for (char i_xmm = elf->xmm_counter - 1; i_xmm >= 0; i_xmm--)
    {
        ElfAddBytes (elf, (i_xmm < 8) ? "\x66\x48\x0F\x7E" : "\x66\x4C\x0F\x7E", 4); // movq rax, xmm?
        char num_register = (i_xmm % 8) * 8 + 0xC0;
        ElfAddBytes (elf, &num_register, 1); 
        ElfAddBytes (elf, "\x50", 1); // \x50 = push rax
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2b3f
movq %rdi, %rbx
movb 0x60(%rdi), %r14b
leal (,%r14,8), %r15d
addb $-0x8, %r15b
decb %r14b
pushq $0x1
popq %r12
leaq 0x1bcb(%rip), %r13      # 0x46a5
testb %r14b, %r14b
js 0x2b2e
cmpb $0x8, %r14b
leaq 0x1c77(%rip), %rsi      # 0x4761
leaq 0x1c6b(%rip), %rax      # 0x475c
cmovbq %rax, %rsi
movq %rbx, %rdi
pushq $0x4
popq %rdx
callq 0x1504
movl %r15d, %eax
orb $-0x40, %al
movb %al, -0x29(%rbp)
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
movq %r12, %rdx
callq 0x1504
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1504
addb $-0x8, %r15b
decb %r14b
jmp 0x2ada
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17a0(%rip), %rdi      # 0x42e6
leaq 0x1553(%rip), %rsi      # 0x40a0
leaq 0x1bef(%rip), %rcx      # 0x4743
movl $0x302, %edx            # imm = 0x302
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintCallParam(Elf*, element*, Stack*, int*)
bool PrintCallParam (Elf* elf, element* el, Stack* vars, int* push_shift)
{
    assert (elf);
    assert (vars);
    assert (push_shift);
    if (!el)
        return 0;

    if (PrintCallParam (elf, el->left, vars, push_shift))
        return 1;

    if (el->type == NUM)
    {
        double num = atof (el->ind);
        ElfAddBytes (elf, "\x48\xB8", 2); // mov rax, num
        ElfAddBytes (elf, (char*) &num, 8);
    }

    else if (el->type == VAR)
    {
        char var_num = VarNumber (vars, el->ind);
        if (var_num == VAR_WASNT_CREATED)
            return 1;

        ElfAddBytes (elf, "\x48\x8B\x45", 3); // mov rax, qword [rbp + var_num]
        ElfAddBytes (elf, &var_num, 1);
    }

    else
        return 1;

    ElfAddBytes (elf, "\x50", 1); // \x50 = push rax
    *push_shift += 8;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2c53
movq %rdx, %r13
testq %rdx, %rdx
je 0x2c72
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2c91
movq %rsi, %r15
testq %rsi, %rsi
je 0x2c3e
movq %rdi, %r14
movq 0x8(%r15), %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2b5e
movb $0x1, %r12b
testb %al, %al
jne 0x2c41
movl (%r15), %eax
cmpl $0x8, %eax
je 0x2bf5
cmpl $0x7, %eax
jne 0x2c41
movq 0x18(%r15), %rdi
callq 0x1120
leaq -0x38(%rbp), %r15
movsd %xmm0, (%r15)
leaq 0x1abf(%rip), %rsi      # 0x469e
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x1504
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x2c24
movq 0x18(%r15), %rsi
movq %r13, %rdi
callq 0x20b4
movb %al, -0x29(%rbp)
cmpb $0x1, %al
je 0x2c41
leaq 0x1a92(%rip), %rsi      # 0x46a1
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1504
leaq -0x29(%rbp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x1504
leaq 0x1a75(%rip), %rsi      # 0x46a5
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x1504
addl $0x8, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x168c(%rip), %rdi      # 0x42e6
leaq 0x143f(%rip), %rsi      # 0x40a0
leaq 0x19f5(%rip), %rcx      # 0x465d
movl $0x285, %edx            # imm = 0x285
callq 0x1080
leaq 0x1818(%rip), %rdi      # 0x4491
leaq 0x1420(%rip), %rsi      # 0x40a0
leaq 0x19d6(%rip), %rcx      # 0x465d
movl $0x286, %edx            # imm = 0x286
callq 0x1080
leaq 0x19fb(%rip), %rdi      # 0x4693
leaq 0x1401(%rip), %rsi      # 0x40a0
leaq 0x19b7(%rip), %rcx      # 0x465d
movl $0x287, %edx            # imm = 0x287
callq 0x1080