LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14e8
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x48(%rbx), %rdi
callq 0x1507
movq $0x0, 0x48(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3df7(%rip), %rdi      # 0x52e6
leaq 0x3baa(%rip), %rsi      # 0x50a0
leaq 0x3bd2(%rip), %rcx      # 0x50cf
movl $0x1f, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x154b
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1530
movq 0x8(%rdi), %r14
callq 0x1120
movq %r14, %rdi
testq %r14, %r14
jne 0x151f
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x1120
movq %r14, %rbx
testq %r14, %r14
jne 0x1516
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3dcd(%rip), %rdi      # 0x531f
leaq 0x3b47(%rip), %rsi      # 0x50a0
leaq 0x3dc6(%rip), %rcx      # 0x5326
movl $0xf5, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15c9
movq %rsi, %r15
testq %rsi, %rsi
je 0x15e8
movq %rdx, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq %rax, 0x58(%r14)
jae 0x15a9
movq %r14, %rdi
callq 0x1607
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x15be
movq 0x50(%r14), %rdi
addq 0x40(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10c0
addq %rbx, 0x50(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d16(%rip), %rdi      # 0x52e6
leaq 0x3ac9(%rip), %rsi      # 0x50a0
leaq 0x3b0b(%rip), %rcx      # 0x50e9
movl $0x2c, %edx
callq 0x1090
leaq 0x3b28(%rip), %rdi      # 0x5117
leaq 0x3aaa(%rip), %rsi      # 0x50a0
leaq 0x3aec(%rip), %rcx      # 0x50e9
movl $0x2d, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x1663
movq %rdi, %r14
movq 0x40(%rdi), %rdi
movl $0x1000, %esi           # imm = 0x1000
addq 0x58(%r14), %rsi
callq 0x1190
movq %rax, 0x40(%r14)
movb $0x1, %bl
testq %rax, %rax
je 0x165c
movq 0x58(%r14), %rcx
leaq 0x1000(%rcx), %rdx
movq %rdx, 0x58(%r14)
cmpq $-0x1001, %rcx          # imm = 0xEFFF
ja 0x165c
xorl %ebx, %ebx
movl $0x2000, %edx           # imm = 0x2000
movq %rax, %rdi
xorl %esi, %esi
callq 0x1080
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3c7c(%rip), %rdi      # 0x52e6
leaq 0x3a2f(%rip), %rsi      # 0x50a0
leaq 0x3aa5(%rip), %rcx      # 0x511d
movl $0x39, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16bb
movq 0x58(%rdi), %rbx
cmpq $0x1000, %rbx           # imm = 0x1000
jb 0x16aa
movq 0x40(%rdi), %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x1080
cmpq $0x1000, %rbx           # imm = 0x1000
setb %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3c24(%rip), %rdi      # 0x52e6
leaq 0x39d7(%rip), %rsi      # 0x50a0
leaq 0x3a67(%rip), %rcx      # 0x5137
movl $0x43, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x17e3
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x391e(%rip), %rdi      # 0x501c
callq 0x1150
testl %eax, %eax
je 0x173a
leaq 0x391c(%rip), %rdi      # 0x502a
movq %r15, %rsi
callq 0x1150
testl %eax, %eax
je 0x178a
movq 0x48(%r14), %r12
testq %r12, %r12
je 0x1763
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1150
testl %eax, %eax
je 0x17af
movq 0x18(%r12), %r12
jmp 0x171e
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
testq %rax, %rax
je 0x17d8
movq %rbx, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%r14)
jmp 0x17d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x191f
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x17da
movq 0x48(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x18c0
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
testq %rax, %rax
je 0x17d8
movq %rbx, (%rax)
movq 0x30(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x30(%r14)
jmp 0x17d4
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
testq %rax, %rax
je 0x17d8
movq %rbx, (%rax)
movq 0x10(%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%r12)
xorl %eax, %eax
jmp 0x17da
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3afc(%rip), %rdi      # 0x52e6
leaq 0x38af(%rip), %rsi      # 0x50a0
leaq 0x3957(%rip), %rcx      # 0x514f
movl $0x4f, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1900
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
testq %rax, %rax
je 0x18f5
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 0x3a18(%rip), %rdi      # 0x531f
leaq 0x3792(%rip), %rsi      # 0x50a0
leaq 0x3a3b(%rip), %rcx      # 0x5350
movl $0x10d, %edx            # imm = 0x10D
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x196c
movq %rsi, %r14
testq %rsi, %rsi
je 0x198b
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
testq %rax, %rax
je 0x1961
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 0x3973(%rip), %rdi      # 0x52e6
leaq 0x3726(%rip), %rsi      # 0x50a0
leaq 0x396d(%rip), %rcx      # 0x52ee
movl $0xe5, %edx
callq 0x1090
leaq 0x3851(%rip), %rdi      # 0x51e3
leaq 0x3707(%rip), %rsi      # 0x50a0
leaq 0x394e(%rip), %rcx      # 0x52ee
movl $0xe6, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x1a22
movq %rsi, %r14
testq %rsi, %rsi
je 0x1a41
movq %rdi, %rbx
movq 0x48(%rdi), %r12
testq %r12, %r12
je 0x19e9
movq %r12, %r15
movq (%r15), %rdi
movq %r14, %rsi
callq 0x1150
testl %eax, %eax
je 0x1a0b
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x19d1
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
testq %rax, %rax
je 0x1a17
movq %rax, %r15
movq %r14, (%rax)
movq %r12, 0x18(%rax)
movq %rax, 0x48(%rbx)
movq 0x50(%rbx), %rax
movq %rax, 0x8(%r15)
xorl %eax, %eax
jmp 0x1a19
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38bd(%rip), %rdi      # 0x52e6
leaq 0x3670(%rip), %rsi      # 0x50a0
leaq 0x3787(%rip), %rcx      # 0x51be
movl $0x76, %edx
callq 0x1090
leaq 0x379b(%rip), %rdi      # 0x51e3
leaq 0x3651(%rip), %rsi      # 0x50a0
leaq 0x3768(%rip), %rcx      # 0x51be
movl $0x77, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b66
movq %rdi, %rbx
movq 0x48(%rdi), %r14
testq %r14, %r14
je 0x1b07
cmpq $-0x1, 0x8(%r14)
je 0x1b4e
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x1b85
movq 0x18(%r14), %r14
jmp 0x1ae9
cmpq $0x0, 0x10(%rbx)
je 0x1b28
leaq 0x374e(%rip), %rsi      # 0x5263
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x1bf8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1b61
cmpq $0x0, 0x30(%rbx)
je 0x1b4a
leaq 0x20(%rbx), %rdx
leaq 0x3741(%rip), %rsi      # 0x527b
movq %rbx, %rdi
callq 0x1bf8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1b61
xorl %eax, %eax
jmp 0x1b61
movq (%r14), %rsi
leaq 0x36e6(%rip), %rdi      # 0x523e
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3779(%rip), %rdi      # 0x52e6
leaq 0x352c(%rip), %rsi      # 0x50a0
leaq 0x36a8(%rip), %rcx      # 0x5223
movl $0x9d, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bba
testq %rsi, %rsi
je 0x1bd9
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1bb8
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
addq 0x8(%rdi), %rcx
movq (%rax), %rdx
movl %ecx, %edi
subl %edx, %edi
movl %edi, (%rsi,%rdx)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1ba5
popq %rbp
retq
leaq 0x375e(%rip), %rdi      # 0x531f
leaq 0x34d8(%rip), %rsi      # 0x50a0
leaq 0x37b4(%rip), %rcx      # 0x5383
movl $0x11b, %edx            # imm = 0x11B
callq 0x1090
leaq 0x37d5(%rip), %rdi      # 0x53b5
leaq 0x34b9(%rip), %rsi      # 0x50a0
leaq 0x3795(%rip), %rcx      # 0x5383
movl $0x11c, %edx            # imm = 0x11C
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $0x0, (%rdi)
callq 0x3518
movb $0x1, %r15b
testq %rax, %rax
je 0x1c53
movq 0x50(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rbp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x156a
testb %al, %al
jne 0x1c53
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x1b85
movq -0x20(%rbp), %rdi
callq 0x1120
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x1d60
movq %rdi, %r14
leaq 0x3628(%rip), %rdi      # 0x52a7
callq 0x10d0
leaq 0x3640(%rip), %rdi      # 0x52cb
leaq 0x3658(%rip), %rsi      # 0x52ea
callq 0x1110
movq %rax, %rbx
testq %rax, %rax
je 0x1d45
leaq 0x50(%r14), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11a0
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11a0
leaq 0x3370(%rip), %rdi      # 0x5048
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11a0
movq %rbx, %rdi
callq 0x1030
movl $0x1000, %r12d          # imm = 0x1000
subq %rax, %r12
cmpq $0x8, %r12
jb 0x1d26
shrq $0x3, %r12
leaq 0x3344(%rip), %r15      # 0x5050
movl $0x1, %esi
movl $0x8, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11a0
decq %r12
jne 0x1d0c
movq 0x40(%r14), %rdi
movq 0x58(%r14), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x11a0
movq %rbx, %rdi
callq 0x10f0
jmp 0x1d51
leaq 0x3a83(%rip), %rdi      # 0x57cf
callq 0x1180
testq %rbx, %rbx
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x357f(%rip), %rdi      # 0x52e6
leaq 0x3332(%rip), %rsi      # 0x50a0
leaq 0x351d(%rip), %rcx      # 0x5292
movl $0xca, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1dd2
movq %rsi, %r15
testq %rsi, %rsi
je 0x1df1
movb $0x1, %bl
cmpl $0x1, (%r15)
jne 0x1dc5
movq %rdi, %r14
movq 0x8(%r15), %rsi
callq 0x1e10
testb %al, %al
jne 0x1dc5
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x1dc3
movq %r14, %rdi
callq 0x1d7f
testb %al, %al
jne 0x1dc5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x350d(%rip), %rdi      # 0x52e6
leaq 0x32c0(%rip), %rsi      # 0x50a0
leaq 0x361e(%rip), %rcx      # 0x5405
movl $0x145, %edx            # imm = 0x145
callq 0x1090
leaq 0x362d(%rip), %rdi      # 0x5425
leaq 0x32a1(%rip), %rsi      # 0x50a0
leaq 0x35ff(%rip), %rcx      # 0x5405
movl $0x146, %edx            # imm = 0x146
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f27
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1f46
movb $0x1, %al
cmpl $0x2, (%rbx)
jne 0x1f1c
movq %rdi, %r14
movq 0x18(%rbx), %rsi
callq 0x19aa
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)
movl $0x20, %esi
movq %r15, %rdi
callq 0x3a5c
leaq -0x19(%rbp), %rdx
movb $-0x8, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f65
testb %al, %al
je 0x1eab
leaq -0x68(%rbp), %rdi
callq 0x3ec9
jmp 0x1f02
leaq 0x3186(%rip), %rsi      # 0x5038
movl $0xb, %edx
movq %r14, %rdi
callq 0x156a
movq 0x10(%rbx), %rsi
leaq -0x68(%rbp), %rdx
movq %r14, %rdi
callq 0x20eb
testb %al, %al
je 0x1f06
leaq 0x356f(%rip), %rdi      # 0x5449
leaq 0x3547(%rip), %rsi      # 0x5428
movl $0x16b, %edx            # imm = 0x16B
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x3576(%rip), %rdi      # 0x546e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
jmp 0x1f1c
leaq 0x3310(%rip), %rsi      # 0x521d
movl $0x5, %edx
movq %r14, %rdi
callq 0x156a
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33b8(%rip), %rdi      # 0x52e6
leaq 0x316b(%rip), %rsi      # 0x50a0
leaq 0x34ec(%rip), %rcx      # 0x5428
movl $0x156, %edx            # imm = 0x156
callq 0x1090
leaq 0x34d8(%rip), %rdi      # 0x5425
leaq 0x314c(%rip), %rsi      # 0x50a0
leaq 0x34cd(%rip), %rcx      # 0x5428
movl $0x157, %edx            # imm = 0x157
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2222
movq %rsi, %rbx
testq %rsi, %rsi
je 0x222b
movq %rdx, %r14
testq %rdx, %rdx
je 0x2234
movq %rdi, %r15
movl (%rbx), %eax
cmpl $0x3, %eax
jne 0x214d
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2182
movq %r15, %rdi
movq %r14, %rdx
callq 0x20eb
testb %al, %al
je 0x2182
leaq 0x330a(%rip), %rdi      # 0x5449
leaq 0x33ad(%rip), %rsi      # 0x54f3
movl $0x1bc, %edx            # imm = 0x1BC
jmp 0x21ad
movb $0x0, 0x60(%r15)
addl $-0xa, %eax
cmpl $0x4, %eax
ja 0x21c9
leaq 0x2ea7(%rip), %rcx      # 0x5008
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 0x264d
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x21cd
movq %r15, %rdi
movq %r14, %rdx
callq 0x20eb
testb %al, %al
je 0x21cd
leaq 0x32a8(%rip), %rdi      # 0x5449
leaq 0x334b(%rip), %rsi      # 0x54f3
movl $0x1be, %edx            # imm = 0x1BE
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x32af(%rip), %rdi      # 0x546e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
jmp 0x21cf
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 0x22e9
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2580
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23f8
leaq 0x30bd(%rip), %rdi      # 0x52e6
jmp 0x223b
leaq 0x31f3(%rip), %rdi      # 0x5425
jmp 0x223b
leaq 0x3256(%rip), %rdi      # 0x5491
leaq 0x2e5e(%rip), %rsi      # 0x50a0
leaq 0x32aa(%rip), %rcx      # 0x54f3
movl $0x1b7, %edx            # imm = 0x1B7
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x22ab
movq %rsi, %rbx
testq %rsi, %rsi
je 0x22ca
movq 0x10(%rdi), %r15
movb $0x1, %r14b
testq %r15, %r15
je 0x229f
movq 0x8(%rdi), %r12
addq $0x28, %r12
movq -0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
je 0x229b
addq $0x30, %r12
decq %r15
jne 0x227f
jmp 0x229f
movb (%r12), %r14b
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31df(%rip), %rdi      # 0x5491
leaq 0x2de7(%rip), %rsi      # 0x50a0
leaq 0x3204(%rip), %rcx      # 0x54c4
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x1090
leaq 0x3219(%rip), %rdi      # 0x54ea
leaq 0x2dc8(%rip), %rsi      # 0x50a0
leaq 0x31e5(%rip), %rcx      # 0x54c4
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23c7
movq %rsi, %r15
testq %rsi, %rsi
je 0x23d0
movq %rdx, %r12
testq %rdx, %rdx
je 0x23d9
movq 0x8(%r15), %rax
movb $0x1, %bl
testq %rax, %rax
je 0x23b8
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x23b8
cmpl $0x8, (%rax)
jne 0x23b8
movq %rdi, %r14
movq %r12, %rdx
callq 0x278d
testb %al, %al
je 0x237a
leaq 0x30f9(%rip), %rdi      # 0x5449
leaq 0x31c4(%rip), %rsi      # 0x551b
movl $0x1dd, %edx            # imm = 0x1DD
xorl %eax, %eax
callq 0x1040
movq 0x18(%r15), %rdx
leaq 0x3100(%rip), %rdi      # 0x546e
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x23b8
movq 0x8(%r15), %rax
movq 0x18(%rax), %rsi
movq %r12, %rdi
callq 0x2253
movb %al, -0x21(%rbp)
cmpb $0x1, %al
je 0x23b8
leaq 0x31ae(%rip), %rsi      # 0x5546
movl $0x4, %edx
movq %r14, %rdi
callq 0x156a
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x156a
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f18(%rip), %rdi      # 0x52e6
jmp 0x23e0
leaq 0x304e(%rip), %rdi      # 0x5425
jmp 0x23e0
leaq 0x30b1(%rip), %rdi      # 0x5491
leaq 0x2cb9(%rip), %rsi      # 0x50a0
leaq 0x312d(%rip), %rcx      # 0x551b
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x254f
movq %rsi, %r15
testq %rsi, %rsi
je 0x2558
movq %rdx, %r14
testq %rdx, %rdx
je 0x2561
movq %rdi, %rbx
movq 0x18(%r15), %rsi
leaq 0x2c3a(%rip), %rdi      # 0x506b
callq 0x1150
testl %eax, %eax
je 0x251d
movq %rbx, %rdi
callq 0x2cbd
leaq -0x20(%rbp), %rcx
movl $0x0, (%rcx)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2d7b
movb $0x1, %r14b
testb %al, %al
jne 0x2541
movq 0x18(%r15), %rsi
movq 0x50(%rbx), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x16da
leaq 0x2bf6(%rip), %rsi      # 0x507a
movl $0x5, %edx
movq %rbx, %rdi
callq 0x156a
leaq 0x3108(%rip), %rsi      # 0x55a0
movl $0x3, %edx
movq %rbx, %rdi
callq 0x156a
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
movb 0x60(%rbx), %al
cmpb $0xf, %al
jg 0x2535
cmpb $0x8, %al
leaq 0x30de(%rip), %rax      # 0x55a4
leaq 0x30dc(%rip), %rsi      # 0x55a9
cmovlq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
movb 0x60(%rbx), %al
movl %eax, %ecx
sarb $0x7, %cl
shrb $0x5, %cl
addb %al, %cl
andb $0x18, %cl
movl %eax, %edx
subb %cl, %dl
shlb $0x3, %dl
addb $-0x40, %dl
leaq -0x19(%rbp), %rsi
movb %dl, (%rsi)
incb %al
movb %al, 0x60(%rbx)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x156a
movq %rbx, %rdi
callq 0x2edb
xorl %r14d, %r14d
jmp 0x2541
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2bb6
leaq 0x3376(%rip), %rdi      # 0x58b2
callq 0x1180
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d90(%rip), %rdi      # 0x52e6
jmp 0x2568
leaq 0x2ec6(%rip), %rdi      # 0x5425
jmp 0x2568
leaq 0x2f29(%rip), %rdi      # 0x5491
leaq 0x2b31(%rip), %rsi      # 0x50a0
leaq 0x3000(%rip), %rcx      # 0x5576
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x261c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2625
testq %rdx, %rdx
je 0x262e
cmpl $0xa, (%rbx)
jne 0x25e9
movq %rdi, %r14
movq 0x8(%rbx), %rsi
callq 0x278d
testb %al, %al
je 0x25f0
leaq 0x2e88(%rip), %rdi      # 0x5449
leaq 0x2fe6(%rip), %rsi      # 0x55ae
movl $0x219, %edx            # imm = 0x219
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x2e8f(%rip), %rdi      # 0x546e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2fe0(%rip), %rsi      # 0x55d7
movl $0x5, %edx
movq %r14, %rdi
callq 0x156a
leaq 0x2c12(%rip), %rsi      # 0x521d
movl $0x5, %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x156a
leaq 0x2cc3(%rip), %rdi      # 0x52e6
jmp 0x2635
leaq 0x2df9(%rip), %rdi      # 0x5425
jmp 0x2635
leaq 0x2e5c(%rip), %rdi      # 0x5491
leaq 0x2a64(%rip), %rsi      # 0x50a0
leaq 0x2f6b(%rip), %rcx      # 0x55ae
movl $0x214, %edx            # imm = 0x214
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x275c
movq %rsi, %r14
testq %rsi, %rsi
je 0x2765
movq %rdx, %r12
testq %rdx, %rdx
je 0x276e
movl (%r14), %eax
addl $-0xb, %eax
movb $0x1, %r15b
cmpl $0x1, %eax
ja 0x274a
movq %rdi, %rbx
movl 0x50(%rdi), %r13d
movq 0x8(%r14), %rsi
movq %r12, %rdx
callq 0x2fb3
movb $0x1, %r15b
testb %al, %al
jne 0x274a
movq 0x50(%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x2700
movq %rbx, %rdi
movq %r12, %rdx
callq 0x20eb
testb %al, %al
je 0x2700
leaq 0x2d73(%rip), %rdi      # 0x5449
leaq 0x2f00(%rip), %rsi      # 0x55dd
movl $0x22d, %edx            # imm = 0x22D
xorl %eax, %eax
callq 0x1040
movq 0x18(%r14), %rdx
leaq 0x2d7a(%rip), %rdi      # 0x546e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x274a
cmpl $0xc, (%r14)
jne 0x2736
leaq 0x2efa(%rip), %rsi      # 0x5607
movl $0x1, %edx
movq %rbx, %rdi
callq 0x156a
subl 0x50(%rbx), %r13d
addl $-0x4, %r13d
leaq -0x34(%rbp), %rsi
movl %r13d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
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 0x2b83(%rip), %rdi      # 0x52e6
jmp 0x2775
leaq 0x2cb9(%rip), %rdi      # 0x5425
jmp 0x2775
leaq 0x2d1c(%rip), %rdi      # 0x5491
leaq 0x2924(%rip), %rsi      # 0x50a0
leaq 0x2e5a(%rip), %rcx      # 0x55dd
movl $0x221, %edx            # imm = 0x221
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27c9
testq %rsi, %rsi
je 0x27d2
testq %rdx, %rdx
je 0x27db
movl (%rsi), %eax
cmpl $0x7, %eax
je 0x27bd
cmpl $0x8, %eax
je 0x27b7
cmpl $0xd, %eax
jne 0x27c3
popq %rbp
jmp 0x23f8
popq %rbp
jmp 0x290b
popq %rbp
jmp 0x27fa
popq %rbp
jmp 0x2a0a
leaq 0x2b16(%rip), %rdi      # 0x52e6
jmp 0x27e2
leaq 0x2c4c(%rip), %rdi      # 0x5425
jmp 0x27e2
leaq 0x2caf(%rip), %rdi      # 0x5491
leaq 0x28b7(%rip), %rsi      # 0x50a0
leaq 0x2d5b(%rip), %rcx      # 0x554b
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28cd
testq %rsi, %rsi
je 0x28ec
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0x1130
leaq -0x20(%rbp), %r14
movsd %xmm0, (%r14)
leaq 0x2e6b(%rip), %rsi      # 0x569e
movl $0x2, %edx
movq %rbx, %rdi
callq 0x156a
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x156a
movb 0x60(%rbx), %r14b
cmpb $0xf, %r14b
jle 0x2868
leaq 0x3051(%rip), %rdi      # 0x58b2
callq 0x1180
jmp 0x28bd
cmpb $0x8, %r14b
leaq 0x2d31(%rip), %rax      # 0x55a4
leaq 0x2d2f(%rip), %rsi      # 0x55a9
cmovlq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
movb 0x60(%rbx), %al
movl %eax, %ecx
sarb $0x7, %cl
shrb $0x5, %cl
addb %al, %cl
andb $0x18, %cl
movl %eax, %edx
subb %cl, %dl
shlb $0x3, %dl
addb $-0x40, %dl
leaq -0x11(%rbp), %rsi
movb %dl, (%rsi)
incb %al
movb %al, 0x60(%rbx)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x156a
cmpb $0x10, %r14b
setge %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2a12(%rip), %rdi      # 0x52e6
leaq 0x27c5(%rip), %rsi      # 0x50a0
leaq 0x2dc5(%rip), %rcx      # 0x56a7
movl $0x2a9, %edx            # imm = 0x2A9
callq 0x1090
leaq 0x2b32(%rip), %rdi      # 0x5425
leaq 0x27a6(%rip), %rsi      # 0x50a0
leaq 0x2da6(%rip), %rcx      # 0x56a7
movl $0x2aa, %edx            # imm = 0x2AA
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x29d9
testq %rsi, %rsi
je 0x29e2
testq %rdx, %rdx
je 0x29eb
movq %rdi, %rbx
cmpb $0xf, 0x60(%rdi)
jg 0x2965
movq 0x18(%rsi), %rsi
movq %rdx, %rdi
callq 0x2253
movb %al, -0x11(%rbp)
cmpb $0x1, %al
sete %r14b
je 0x29cd
cmpb $0x7, 0x60(%rbx)
jg 0x2976
leaq 0x2d9c(%rip), %rsi      # 0x56fa
movl $0x3, %edx
jmp 0x2982
leaq 0x2fbd(%rip), %rdi      # 0x5929
callq 0x1180
movb $0x1, %r14b
jmp 0x29cd
leaq 0x2d81(%rip), %rsi      # 0x56fe
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
movb 0x60(%rbx), %al
movl %eax, %ecx
sarb $0x7, %cl
shrb $0x5, %cl
addb %al, %cl
andb $0x18, %cl
movl %eax, %edx
subb %cl, %dl
shlb $0x3, %dl
addb $0x45, %dl
leaq -0x12(%rbp), %rsi
movb %dl, (%rsi)
incb %al
movb %al, 0x60(%rbx)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x156a
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x156a
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2906(%rip), %rdi      # 0x52e6
jmp 0x29f2
leaq 0x2a3c(%rip), %rdi      # 0x5425
jmp 0x29f2
leaq 0x2a9f(%rip), %rdi      # 0x5491
leaq 0x26a7(%rip), %rsi      # 0x50a0
leaq 0x2ccc(%rip), %rcx      # 0x56cc
movl $0x2b6, %edx            # imm = 0x2B6
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c8c
testq %rsi, %rsi
je 0x2c95
testq %rdx, %rdx
je 0x2c9e
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movl (%rsi), %eax
movb $0x1, %r14b
cmpl $0x8, %eax
je 0x2c00
cmpl $0x7, %eax
jne 0x2c80
movq %rbx, %rdi
callq 0x27fa
jmp 0x2c08
movq %rbx, %rdi
callq 0x290b
testb %al, %al
jne 0x2c80
movsbl 0x60(%rbx), %eax
leal -0x1(%rax), %ecx
leal 0x6(%rax), %edx
testw %cx, %cx
cmovnsl %ecx, %edx
andl $0x18, %edx
negl %edx
leal (%rax,%rdx), %ecx
decl %ecx
shlb $0x3, %cl
addb $-0x40, %cl
movb %cl, -0x11(%rbp)
cmpw $0x8, %ax
jg 0x2c58
leaq 0x2b6d(%rip), %rsi      # 0x57a9
movl $0x3, %edx
movq %rbx, %rdi
callq 0x156a
cmpb $0x8, 0x60(%rbx)
jne 0x2c58
leaq 0x2b57(%rip), %rsi      # 0x57ad
jmp 0x2c5f
leaq 0x2b53(%rip), %rsi      # 0x57b2
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x156a
movl %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2653(%rip), %rdi      # 0x52e6
jmp 0x2ca5
leaq 0x2789(%rip), %rdi      # 0x5425
jmp 0x2ca5
leaq 0x27ec(%rip), %rdi      # 0x5491
leaq 0x23f4(%rip), %rsi      # 0x50a0
leaq 0x2acc(%rip), %rcx      # 0x577f
movl $0x323, %edx            # imm = 0x323
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d5c
movq %rdi, %rbx
movb 0x60(%rdi), %r12b
movl %r12d, %r13d
decb %r13b
js 0x2d4b
shlb $0x3, %r12b
addb $-0x8, %r12b
leaq -0x29(%rbp), %r14
leaq 0x29af(%rip), %r15      # 0x56a5
cmpb $0x8, %r13b
leaq 0x2a60(%rip), %rsi      # 0x5761
leaq 0x2a54(%rip), %rax      # 0x575c
cmovbq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
movl %r12d, %eax
orb $-0x40, %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x156a
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x156a
addb $-0x8, %r12b
addb $-0x1, %r13b
jb 0x2cf6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2583(%rip), %rdi      # 0x52e6
leaq 0x2336(%rip), %rsi      # 0x50a0
leaq 0x29d2(%rip), %rcx      # 0x5743
movl $0x302, %edx            # imm = 0x302
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e7e
movq %rdx, %r13
testq %rdx, %rdx
je 0x2e9d
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2ebc
movq %rsi, %r15
testq %rsi, %rsi
je 0x2e69
movq %rdi, %r14
movq 0x8(%r15), %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2d7b
movb $0x1, %r12b
testb %al, %al
jne 0x2e6c
movl (%r15), %eax
cmpl $0x8, %eax
je 0x2e1a
cmpl $0x7, %eax
jne 0x2e6c
movq 0x18(%r15), %rdi
callq 0x1130
leaq -0x38(%rbp), %r15
movsd %xmm0, (%r15)
leaq 0x289e(%rip), %rsi      # 0x569e
movl $0x2, %edx
movq %r14, %rdi
callq 0x156a
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x2e4d
movq 0x18(%r15), %rsi
movq %r13, %rdi
callq 0x2253
movb %al, -0x29(%rbp)
cmpb $0x1, %al
je 0x2e6c
leaq 0x286d(%rip), %rsi      # 0x56a1
movl $0x3, %edx
movq %r14, %rdi
callq 0x156a
leaq -0x29(%rbp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x156a
leaq 0x284c(%rip), %rsi      # 0x56a5
movl $0x1, %edx
movq %r14, %rdi
callq 0x156a
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 0x2461(%rip), %rdi      # 0x52e6
leaq 0x2214(%rip), %rsi      # 0x50a0
leaq 0x27ca(%rip), %rcx      # 0x565d
movl $0x285, %edx            # imm = 0x285
callq 0x1090
leaq 0x25ed(%rip), %rdi      # 0x5491
leaq 0x21f5(%rip), %rsi      # 0x50a0
leaq 0x27ab(%rip), %rcx      # 0x565d
movl $0x286, %edx            # imm = 0x286
callq 0x1090
leaq 0x27d0(%rip), %rdi      # 0x5693
leaq 0x21d6(%rip), %rsi      # 0x50a0
leaq 0x278c(%rip), %rcx      # 0x565d
movl $0x287, %edx            # imm = 0x287
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintLoadXMM(Elf*)
bool PrintLoadXMM   (Elf* elf)
{
    assert (elf);

    for (char i_xmm = 0; i_xmm < elf->xmm_counter - 1; i_xmm++) // - 1 --- arg was added
    {
        ElfAddBytes (elf, "\x58", 1); // 0x58 = pop rax

        ElfAddBytes (elf, (i_xmm < 8) ? "\x66\x48\x0F\x6E": // movq xmm?, rax
                                        "\x66\x4C\x0F\x6E", // movq xmm?, rax
                                        4);
        char num_register = (i_xmm % 8) * 8 + 0xC0;
        ElfAddBytes (elf, &num_register, 1);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2f94
movq %rdi, %rbx
cmpb $0x2, 0x60(%rdi)
jl 0x2f83
movb $0x1, %r14b
leaq 0x26a0(%rip), %r13      # 0x55a9
leaq -0x29(%rbp), %r15
leal -0x1(%r14), %r12d
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x281d(%rip), %rsi      # 0x573d
callq 0x156a
cmpb $0x8, %r12b
movq %r13, %rsi
leaq 0x2671(%rip), %rax      # 0x55a4
cmovlq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x156a
movl %r12d, %eax
sarb $0x7, %al
shrb $0x5, %al
addb %r12b, %al
andb $0x18, %al
subb %al, %r12b
shlb $0x3, %r12b
addb $-0x40, %r12b
movb %r12b, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x156a
movsbl %r14b, %eax
movsbl 0x60(%rbx), %ecx
decl %ecx
leal 0x1(%rax), %r14d
cmpl %eax, %ecx
jg 0x2f0d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x234b(%rip), %rdi      # 0x52e6
leaq 0x20fe(%rip), %rsi      # 0x50a0
leaq 0x27bd(%rip), %rcx      # 0x5766
movl $0x311, %edx            # imm = 0x311
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: TreeConstructor(Tree*)
void TreeConstructor (Tree* tree)
{
    assert (tree);

    const size_t stk_size = 1000;
    tree->head = nullptr;
    StackConstructor (&(tree->stk), stk_size);
    return;
}

// Assembly:
testq %rdi, %rdi
je 0x3176
movq $0x0, (%rdi)
addq $0x8, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
jmp 0x3a5c
pushq %rbp
movq %rsp, %rbp
leaq 0x2849(%rip), %rdi      # 0x59ca
leaq 0x2847(%rip), %rsi      # 0x59cf
leaq 0x2852(%rip), %rcx      # 0x59e1
movl $0xc, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: TreeDestructor(Tree*)
void TreeDestructor (Tree* tree)
{
    assert (tree);

    StackDestructor (&(tree->stk));
    tree->head = nullptr;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x31be
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x3ec9
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2805(%rip), %rdi      # 0x59ca
leaq 0x2803(%rip), %rsi      # 0x59cf
leaq 0x282b(%rip), %rcx      # 0x59fe
movl $0x16, %edx
callq 0x1090