LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e69
jmp 0x1e88
leaq 0x456e(%rip), %rdi      # 0x63de
leaq 0x429f(%rip), %rsi      # 0x6116
movl $0x11b, %edx            # imm = 0x11B
leaq 0x45bf(%rip), %rcx      # 0x6442
callq 0x1080
cmpq $0x0, -0x10(%rbp)
je 0x1e91
jmp 0x1eb0
leaq 0x45dc(%rip), %rdi      # 0x6474
leaq 0x4277(%rip), %rsi      # 0x6116
movl $0x11c, %edx            # imm = 0x11C
leaq 0x4597(%rip), %rcx      # 0x6442
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1efb
movslq -0x14(%rbp), %rax
subq $0x4, %rax
movq -0x20(%rbp), %rcx
subq (%rcx), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movl %edx, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ec7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x42b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1f4a
movb $0x1, -0x1(%rbp)
jmp 0x1f95
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1690
testb $0x1, %al
jne 0x1f71
jmp 0x1f77
movb $0x1, -0x1(%rbp)
jmp 0x1f95
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x1e50
movq -0x28(%rbp), %rdi
callq 0x1110
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1fb5
jmp 0x1fd4
leaq 0x43a0(%rip), %rdi      # 0x635c
leaq 0x4153(%rip), %rsi      # 0x6116
movl $0xca, %edx
leaq 0x4339(%rip), %rcx      # 0x6308
callq 0x1080
leaq 0x4342(%rip), %rdi      # 0x631d
callq 0x10c0
leaq 0x435a(%rip), %rdi      # 0x6341
leaq 0x4372(%rip), %rsi      # 0x6360
callq 0x1100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2015
leaq 0x435f(%rip), %rdi      # 0x6364
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x20e6
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x1170
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x1170
movq -0x18(%rbp), %rcx
leaq 0x4082(%rip), %rdi      # 0x60d8
movl $0x8, %esi
movl $0x1, %edx
callq 0x1170
movq -0x18(%rbp), %rdi
callq 0x1030
movq %rax, %rcx
movl $0x1000, %eax           # imm = 0x1000
subq %rcx, %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x20bb
movq -0x18(%rbp), %rcx
leaq 0x4042(%rip), %rdi      # 0x60e0
movl $0x1, %esi
movl $0x8, %edx
callq 0x1170
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2089
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x1170
movq -0x18(%rbp), %rdi
callq 0x10e0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2119
jmp 0x2138
leaq 0x423c(%rip), %rdi      # 0x635c
leaq 0x3fef(%rip), %rsi      # 0x6116
movl $0x145, %edx            # imm = 0x145
leaq 0x43aa(%rip), %rcx      # 0x64dd
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x2141
jmp 0x2160
leaq 0x43b5(%rip), %rdi      # 0x64fd
leaq 0x3fc7(%rip), %rsi      # 0x6116
movl $0x146, %edx            # imm = 0x146
leaq 0x4382(%rip), %rcx      # 0x64dd
callq 0x1080
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0x216f
movb $0x1, -0x1(%rbp)
jmp 0x21b8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x21d0
testb $0x1, %al
jne 0x2186
jmp 0x218c
movb $0x1, -0x1(%rbp)
jmp 0x21b8
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x21b4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2100
testb $0x1, %al
jne 0x21ae
jmp 0x21b4
movb $0x1, -0x1(%rbp)
jmp 0x21b8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x21ec
jmp 0x220b
leaq 0x4169(%rip), %rdi      # 0x635c
leaq 0x3f1c(%rip), %rsi      # 0x6116
movl $0x156, %edx            # imm = 0x156
leaq 0x42fa(%rip), %rcx      # 0x6500
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x2214
jmp 0x2233
leaq 0x42e2(%rip), %rdi      # 0x64fd
leaq 0x3ef4(%rip), %rsi      # 0x6116
movl $0x157, %edx            # imm = 0x157
leaq 0x42d2(%rip), %rcx      # 0x6500
callq 0x1080
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x2245
movb $0x1, -0x1(%rbp)
jmp 0x2364
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x1bc0
movq -0x10(%rbp), %rax
movb $0x0, 0x60(%rax)
movq $0x20, -0x20(%rbp)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movl $0xc, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x20, %esi
callq 0x4a50
movb $-0x8, -0x69(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x69(%rbp), %rdx
callq 0x2380
testb $0x1, %al
jne 0x22e2
jmp 0x22f1
leaq -0x68(%rbp), %rdi
callq 0x5000
movb $0x1, -0x1(%rbp)
jmp 0x2364
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x78(%rbp), %rdx
callq 0x25f0
testb $0x1, %al
jne 0x231d
jmp 0x2357
leaq 0x41fd(%rip), %rdi      # 0x6521
leaq 0x41d5(%rip), %rsi      # 0x6500
movl $0x16b, %edx            # imm = 0x16B
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x41fc(%rip), %rdi      # 0x6546
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x2364
movq -0x10(%rbp), %rdi
callq 0x1cf0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2819
jmp 0x2838
leaq 0x3d49(%rip), %rdi      # 0x6569
leaq 0x38ef(%rip), %rsi      # 0x6116
movl $0x1ab, %edx            # imm = 0x1AB
leaq 0x3e08(%rip), %rcx      # 0x663b
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x2841
jmp 0x2860
leaq 0x3e19(%rip), %rdi      # 0x6661
leaq 0x38c7(%rip), %rsi      # 0x6116
movl $0x1ac, %edx            # imm = 0x1AC
leaq 0x3de0(%rip), %rcx      # 0x663b
callq 0x1080
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x28c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
callq 0x1130
cmpl $0x0, %eax
jne 0x28b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movb 0x28(%rax), %al
movb %al, -0x1(%rbp)
jmp 0x28c4
jmp 0x28b2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2868
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x28ed
jmp 0x290c
leaq 0x3a68(%rip), %rdi      # 0x635c
leaq 0x381b(%rip), %rsi      # 0x6116
movl $0x1d8, %edx            # imm = 0x1D8
leaq 0x3d8b(%rip), %rcx      # 0x6692
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x2915
jmp 0x2934
leaq 0x3be1(%rip), %rdi      # 0x64fd
leaq 0x37f3(%rip), %rsi      # 0x6116
movl $0x1d8, %edx            # imm = 0x1D8
leaq 0x3d63(%rip), %rcx      # 0x6692
callq 0x1080
cmpq $0x0, -0x20(%rbp)
je 0x293d
jmp 0x295c
leaq 0x3c25(%rip), %rdi      # 0x6569
leaq 0x37cb(%rip), %rsi      # 0x6116
movl $0x1d8, %edx            # imm = 0x1D8
leaq 0x3d3b(%rip), %rcx      # 0x6692
callq 0x1080
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x297f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x297f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
je 0x2988
movb $0x1, -0x1(%rbp)
jmp 0x2a32
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2f30
testb $0x1, %al
jne 0x29a3
jmp 0x29dd
leaq 0x3b77(%rip), %rdi      # 0x6521
leaq 0x3ce1(%rip), %rsi      # 0x6692
movl $0x1dd, %edx            # imm = 0x1DD
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x3b76(%rip), %rdi      # 0x6546
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x2a32
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x2800
movb %al, -0x21(%rbp)
movsbq -0x21(%rbp), %rax
cmpq $0x1, %rax
jne 0x2a06
movb $0x1, -0x1(%rbp)
jmp 0x2a32
movq -0x10(%rbp), %rdi
leaq 0x3cac(%rip), %rsi      # 0x66bd
movl $0x4, %edx
callq 0x1690
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2c6d
jmp 0x2c8c
leaq 0x36e8(%rip), %rdi      # 0x635c
leaq 0x349b(%rip), %rsi      # 0x6116
movl $0x214, %edx            # imm = 0x214
leaq 0x3b16(%rip), %rcx      # 0x679d
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x2c95
jmp 0x2cb4
leaq 0x3861(%rip), %rdi      # 0x64fd
leaq 0x3473(%rip), %rsi      # 0x6116
movl $0x214, %edx            # imm = 0x214
leaq 0x3aee(%rip), %rcx      # 0x679d
callq 0x1080
cmpq $0x0, -0x20(%rbp)
je 0x2cbd
jmp 0x2cdc
leaq 0x38a5(%rip), %rdi      # 0x6569
leaq 0x344b(%rip), %rsi      # 0x6116
movl $0x214, %edx            # imm = 0x214
leaq 0x3ac6(%rip), %rcx      # 0x679d
callq 0x1080
movq -0x18(%rbp), %rax
cmpl $0xa, (%rax)
je 0x2ceb
movb $0x1, -0x1(%rbp)
jmp 0x2d63
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2f30
testb $0x1, %al
jne 0x2d06
jmp 0x2d40
leaq 0x3814(%rip), %rdi      # 0x6521
leaq 0x3a89(%rip), %rsi      # 0x679d
movl $0x219, %edx            # imm = 0x219
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x3813(%rip), %rdi      # 0x6546
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x2d63
movq -0x10(%rbp), %rdi
leaq 0x3a7b(%rip), %rsi      # 0x67c6
movl $0x5, %edx
callq 0x1690
movq -0x10(%rbp), %rdi
callq 0x1cf0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2d8d
jmp 0x2dac
leaq 0x35c8(%rip), %rdi      # 0x635c
leaq 0x337b(%rip), %rsi      # 0x6116
movl $0x221, %edx            # imm = 0x221
leaq 0x3a25(%rip), %rcx      # 0x67cc
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x2db5
jmp 0x2dd4
leaq 0x3741(%rip), %rdi      # 0x64fd
leaq 0x3353(%rip), %rsi      # 0x6116
movl $0x221, %edx            # imm = 0x221
leaq 0x39fd(%rip), %rcx      # 0x67cc
callq 0x1080
cmpq $0x0, -0x20(%rbp)
je 0x2ddd
jmp 0x2dfc
leaq 0x3785(%rip), %rdi      # 0x6569
leaq 0x332b(%rip), %rsi      # 0x6116
movl $0x221, %edx            # imm = 0x221
leaq 0x39d5(%rip), %rcx      # 0x67cc
callq 0x1080
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
je 0x2e17
movq -0x18(%rbp), %rax
cmpl $0xc, (%rax)
je 0x2e17
movb $0x1, -0x1(%rbp)
jmp 0x2f1c
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3ad0
testb $0x1, %al
jne 0x2e3d
jmp 0x2e46
movb $0x1, -0x1(%rbp)
jmp 0x2f1c
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2eb4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x25f0
testb $0x1, %al
jne 0x2e78
jmp 0x2eb2
leaq 0x36a2(%rip), %rdi      # 0x6521
leaq 0x3946(%rip), %rsi      # 0x67cc
movl $0x22d, %edx            # imm = 0x22D
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x36a1(%rip), %rdi      # 0x6546
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x2f1c
jmp 0x2eb4
movq -0x18(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x2efa
movq -0x10(%rbp), %rdi
leaq 0x392e(%rip), %rsi      # 0x67f6
movl $0x1, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x4, %rcx
movslq -0x24(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
subq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x30(%rbp), %rcx
movl %edx, -0x4(%rax,%rcx)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2f4d
jmp 0x2f6c
leaq 0x3408(%rip), %rdi      # 0x635c
leaq 0x31bb(%rip), %rsi      # 0x6116
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0x375b(%rip), %rcx      # 0x66c2
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x2f75
jmp 0x2f94
leaq 0x3581(%rip), %rdi      # 0x64fd
leaq 0x3193(%rip), %rsi      # 0x6116
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0x3733(%rip), %rcx      # 0x66c2
callq 0x1080
cmpq $0x0, -0x20(%rbp)
je 0x2f9d
jmp 0x2fbc
leaq 0x35c5(%rip), %rdi      # 0x6569
leaq 0x316b(%rip), %rsi      # 0x6116
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0x370b(%rip), %rcx      # 0x66c2
callq 0x1080
movq -0x18(%rbp), %rax
cmpl $0xd, (%rax)
jne 0x2fdd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a40
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3031
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x2ffa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3040
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3031
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x301b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3190
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3031
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3300
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3059
jmp 0x3078
leaq 0x32fc(%rip), %rdi      # 0x635c
leaq 0x30af(%rip), %rsi      # 0x6116
movl $0x2a9, %edx            # imm = 0x2A9
leaq 0x3823(%rip), %rcx      # 0x6896
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x3081
jmp 0x30a0
leaq 0x3475(%rip), %rdi      # 0x64fd
leaq 0x3087(%rip), %rsi      # 0x6116
movl $0x2aa, %edx            # imm = 0x2AA
leaq 0x37fb(%rip), %rcx      # 0x6896
callq 0x1080
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1120
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x37d0(%rip), %rsi      # 0x688d
movl $0x2, %edx
callq 0x1690
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x10, %eax
jge 0x316a
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x8, %eax
jge 0x310c
leaq 0x3615(%rip), %rax      # 0x671b
movq %rax, -0x38(%rbp)
jmp 0x3119
leaq 0x360d(%rip), %rax      # 0x6720
movq %rax, -0x38(%rbp)
jmp 0x3119
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x4, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %eax
shll $0x3, %eax
addl $0xc0, %eax
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %ecx
addl $0x1, %ecx
movb %cl, 0x60(%rax)
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
jmp 0x317e
leaq 0x35b4(%rip), %rdi      # 0x6725
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x3182
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x31ad
jmp 0x31cc
leaq 0x31a8(%rip), %rdi      # 0x635c
leaq 0x2f5b(%rip), %rsi      # 0x6116
movl $0x2b6, %edx            # imm = 0x2B6
leaq 0x36f4(%rip), %rcx      # 0x68bb
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x31d5
jmp 0x31f4
leaq 0x3321(%rip), %rdi      # 0x64fd
leaq 0x2f33(%rip), %rsi      # 0x6116
movl $0x2b6, %edx            # imm = 0x2B6
leaq 0x36cc(%rip), %rcx      # 0x68bb
callq 0x1080
cmpq $0x0, -0x20(%rbp)
je 0x31fd
jmp 0x321c
leaq 0x3365(%rip), %rdi      # 0x6569
leaq 0x2f0b(%rip), %rsi      # 0x6116
movl $0x2b6, %edx            # imm = 0x2B6
leaq 0x36a4(%rip), %rcx      # 0x68bb
callq 0x1080
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x10, %eax
jge 0x32dd
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2800
movb %al, -0x21(%rbp)
movsbq -0x21(%rbp), %rax
cmpq $0x1, %rax
jne 0x3255
movb $0x1, -0x1(%rbp)
jmp 0x32f5
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x8, %eax
jge 0x3279
movq -0x10(%rbp), %rdi
leaq 0x367c(%rip), %rsi      # 0x68e9
movl $0x3, %edx
callq 0x1690
jmp 0x328e
movq -0x10(%rbp), %rdi
leaq 0x3669(%rip), %rsi      # 0x68ed
movl $0x4, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %eax
shll $0x3, %eax
addl $0x45, %eax
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %ecx
addl $0x1, %ecx
movb %cl, 0x60(%rax)
movq -0x10(%rbp), %rdi
leaq -0x22(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
jmp 0x32f1
leaq 0x360e(%rip), %rdi      # 0x68f2
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x32f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x35cd
jmp 0x35ec
leaq 0x2d88(%rip), %rdi      # 0x635c
leaq 0x2b3b(%rip), %rsi      # 0x6116
movl $0x323, %edx            # imm = 0x323
leaq 0x33cf(%rip), %rcx      # 0x69b6
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x35f5
jmp 0x3614
leaq 0x2f01(%rip), %rdi      # 0x64fd
leaq 0x2b13(%rip), %rsi      # 0x6116
movl $0x323, %edx            # imm = 0x323
leaq 0x33a7(%rip), %rcx      # 0x69b6
callq 0x1080
cmpq $0x0, -0x20(%rbp)
je 0x361d
jmp 0x363c
leaq 0x2f45(%rip), %rdi      # 0x6569
leaq 0x2aeb(%rip), %rsi      # 0x6116
movl $0x323, %edx            # imm = 0x323
leaq 0x337f(%rip), %rcx      # 0x69b6
callq 0x1080
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x7, (%rax)
jne 0x366b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3040
testb $0x1, %al
jne 0x3660
jmp 0x3669
movb $0x1, -0x1(%rbp)
jmp 0x373b
jmp 0x36a9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
jne 0x369e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3190
testb $0x1, %al
jne 0x3693
jmp 0x369c
movb $0x1, -0x1(%rbp)
jmp 0x373b
jmp 0x36a7
movb $0x1, -0x1(%rbp)
jmp 0x373b
jmp 0x36a9
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
subl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %eax
shll $0x3, %eax
addl $0xc0, %eax
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x8, %eax
jg 0x36eb
movq -0x10(%rbp), %rdi
leaq 0x32ff(%rip), %rsi      # 0x69e0
movl $0x3, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movsbl 0x60(%rax), %eax
cmpl $0x8, %eax
jne 0x370f
movq -0x10(%rbp), %rdi
leaq 0x32e1(%rip), %rsi      # 0x69e4
movl $0x4, %edx
callq 0x1690
jmp 0x3724
movq -0x10(%rbp), %rdi
leaq 0x32cf(%rip), %rsi      # 0x69e9
movl $0x4, %edx
callq 0x1690
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3765
jmp 0x3784
leaq 0x2bf0(%rip), %rdi      # 0x635c
leaq 0x29a3(%rip), %rsi      # 0x6116
movl $0x302, %edx            # imm = 0x302
leaq 0x31fb(%rip), %rcx      # 0x697a
callq 0x1080
movq -0x8(%rbp), %rax
movsbl 0x60(%rax), %eax
subl $0x1, %eax
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jl 0x3829
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x8, %eax
jge 0x37bd
leaq 0x31dc(%rip), %rax      # 0x6993
movq %rax, -0x20(%rbp)
jmp 0x37ca
leaq 0x31d4(%rip), %rax      # 0x6998
movq %rax, -0x20(%rbp)
jmp 0x37ca
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1690
movsbl -0x9(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %eax
shll $0x3, %eax
addl $0xc0, %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
movq -0x8(%rbp), %rdi
leaq 0x3082(%rip), %rsi      # 0x6894
movl $0x1, %edx
callq 0x1690
movb -0x9(%rbp), %al
addb $-0x1, %al
movb %al, -0x9(%rbp)
jmp 0x3792
xorl %eax, %eax
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3861
jmp 0x3880
leaq 0x2af4(%rip), %rdi      # 0x635c
leaq 0x28a7(%rip), %rsi      # 0x6116
movl $0x285, %edx            # imm = 0x285
leaq 0x2fd1(%rip), %rcx      # 0x684c
callq 0x1080
cmpq $0x0, -0x20(%rbp)
je 0x3889
jmp 0x38a8
leaq 0x2cd9(%rip), %rdi      # 0x6569
leaq 0x287f(%rip), %rsi      # 0x6116
movl $0x286, %edx            # imm = 0x286
leaq 0x2fa9(%rip), %rcx      # 0x684c
callq 0x1080
cmpq $0x0, -0x28(%rbp)
je 0x38b1
jmp 0x38d0
leaq 0x2fca(%rip), %rdi      # 0x6882
leaq 0x2857(%rip), %rsi      # 0x6116
movl $0x287, %edx            # imm = 0x287
leaq 0x2f81(%rip), %rcx      # 0x684c
callq 0x1080
cmpq $0x0, -0x18(%rbp)
jne 0x38e0
movb $0x0, -0x1(%rbp)
jmp 0x39cf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x3840
testb $0x1, %al
jne 0x38ff
jmp 0x3908
movb $0x1, -0x1(%rbp)
jmp 0x39cf
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x394c
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1120
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2f5f(%rip), %rsi      # 0x688d
movl $0x2, %edx
callq 0x1690
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x1690
jmp 0x39ab
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x39a3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2800
movb %al, -0x31(%rbp)
movsbq -0x31(%rbp), %rax
cmpq $0x1, %rax
jne 0x397a
movb $0x1, -0x1(%rbp)
jmp 0x39cf
movq -0x10(%rbp), %rdi
leaq 0x2f0b(%rip), %rsi      # 0x6890
movl $0x3, %edx
callq 0x1690
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
jmp 0x39a9
movb $0x1, -0x1(%rbp)
jmp 0x39cf
jmp 0x39ab
movq -0x10(%rbp), %rdi
leaq 0x2ede(%rip), %rsi      # 0x6894
movl $0x1, %edx
callq 0x1690
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x8, %ecx
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x39f5
jmp 0x3a14
leaq 0x2960(%rip), %rdi      # 0x635c
leaq 0x2713(%rip), %rsi      # 0x6116
movl $0x311, %edx            # imm = 0x311
leaq 0x2f8e(%rip), %rcx      # 0x699d
callq 0x1080
movb $0x0, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl 0x60(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3ab9
movq -0x8(%rbp), %rdi
leaq 0x2f3a(%rip), %rsi      # 0x6974
movl $0x1, %edx
callq 0x1690
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x8, %eax
jge 0x3a62
leaq 0x2cbf(%rip), %rax      # 0x671b
movq %rax, -0x20(%rbp)
jmp 0x3a6f
leaq 0x2cb7(%rip), %rax      # 0x6720
movq %rax, -0x20(%rbp)
jmp 0x3a6f
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1690
movsbl -0x9(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %eax
shll $0x3, %eax
addl $0xc0, %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
callq 0x1690
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x3a18
xorl %eax, %eax
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3da5
jmp 0x3dc4
leaq 0x2c9c(%rip), %rdi      # 0x6a48
leaq 0x2c9a(%rip), %rsi      # 0x6a4d
movl $0xc, %edx
leaq 0x2ca0(%rip), %rcx      # 0x6a5f
callq 0x1080
movq $0x3e8, -0x10(%rbp)     # imm = 0x3E8
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x4a50
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e05
jmp 0x3e24
leaq 0x2c3c(%rip), %rdi      # 0x6a48
leaq 0x2c3a(%rip), %rsi      # 0x6a4d
movl $0x16, %edx
leaq 0x2c5d(%rip), %rcx      # 0x6a7c
callq 0x1080
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x5000
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: ElementConstructor(Tree*, Types, char**, unsigned long)
bool ElementConstructor (Tree* tree, Types type, char** ind, size_t len)
{
    char* str = nullptr;

    if (*ind)
    {
        str = (char*) calloc (len + 1, sizeof (*str));
        if (!str)
        {
            printf ("Memory error!\n");
            return 1;
        }

        strncpy (str, *ind, len);
        *ind += len;
    }
    else
        assert (!len);

    element push = { type, nullptr, nullptr, str, len };
    StackPush (&(tree->stk), push);

    if (tree->stk.status_error != STK_GOOD)
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3ed4
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x1090
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3eb0
leaq 0x2bf8(%rip), %rdi      # 0x6a98
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x3f92
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x1070
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x3f07
cmpq $0x0, -0x28(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3ee4
jmp 0x3ee6
jmp 0x3f05
leaq 0x2bba(%rip), %rdi      # 0x6aa7
leaq 0x2b59(%rip), %rsi      # 0x6a4d
movl $0x2f, %edx
leaq 0x2bac(%rip), %rcx      # 0x6aac
callq 0x1080
jmp 0x3f07
movl -0x14(%rbp), %eax
movl %eax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x30, %edx
callq 0x10b0
movq -0x98(%rbp), %rdi
movups -0x90(%rbp), %xmm0
movups -0x80(%rbp), %xmm1
movups -0x70(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x5240
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x3f8e
movb $0x1, -0x1(%rbp)
jmp 0x3f92
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: ElementDestructor(element*)
void ElementDestructor (element* el)
{
    assert (el);

    free (el->ind);
    *el = STK_POISON;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3fb5
jmp 0x3fd4
leaq 0x2541(%rip), %rdi      # 0x64fd
leaq 0x2a8a(%rip), %rsi      # 0x6a4d
movl $0x3c, %edx
leaq 0x2b15(%rip), %rcx      # 0x6ae4
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2e3c(%rip), %rsi      # 0x6e28
movl $0x29, %edx
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: CreateGraph(Tree*)
void CreateGraph (Tree* tree)
{
    assert (tree);

    FILE* graph = fopen ("AllDumps/out.dot", "w");
    assert (graph);
    fprintf (graph, "digraph G{\n" "rankdir = HR;\n node[shape=box];\n");

    if (tree->head)
    {
        fprintf (graph, "\"Point: %p\\n Type: %d\\n %s\";\n",
            tree->head, tree->head->type, tree->head->ind);
        ElementGraph (graph, tree->head);
    }
    else
        fprintf (graph, "\"No elements\";\n");

    fprintf (graph, "}");
    fclose (graph);

    system ("dot -Tpng AllDumps/out.dot -o AllDumps/gr.png");
    // system ("start AllDumps/gr.png");

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4015
jmp 0x4034
leaq 0x2a2c(%rip), %rdi      # 0x6a48
leaq 0x2a2a(%rip), %rsi      # 0x6a4d
movl $0x45, %edx
leaq 0x2ad7(%rip), %rcx      # 0x6b06
callq 0x1080
leaq 0x2ae4(%rip), %rdi      # 0x6b1f
leaq 0x2d63(%rip), %rsi      # 0x6da5
callq 0x1100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4054
jmp 0x4073
leaq 0x2ad5(%rip), %rdi      # 0x6b30
leaq 0x29eb(%rip), %rsi      # 0x6a4d
movl $0x48, %edx
leaq 0x2a98(%rip), %rcx      # 0x6b06
callq 0x1080
movq -0x10(%rbp), %rdi
leaq 0x2ab8(%rip), %rsi      # 0x6b36
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x40ce
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %r8
leaq 0x2b31(%rip), %rsi      # 0x6be6
movb $0x0, %al
callq 0x1140
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4110
jmp 0x40e0
movq -0x10(%rbp), %rdi
leaq 0x2a89(%rip), %rsi      # 0x6b62
movb $0x0, %al
callq 0x1140
movq -0x10(%rbp), %rdi
leaq 0x2a87(%rip), %rsi      # 0x6b72
movb $0x0, %al
callq 0x1140
movq -0x10(%rbp), %rdi
callq 0x10e0
leaq 0x2a72(%rip), %rdi      # 0x6b74
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: ElementGraph(_IO_FILE*, element*)
void ElementGraph (FILE* graph, element* el)
{
    assert (graph);
    assert (el);

    if (el->left > PARSE_ERR)
    {
        fprintf (graph, "\"Point: %p\\n Type: %d\\n %s\" -> "
                        "\"Point: %p\\n Type: %d\\n %s\";\n",
                el,             el->type,       el->ind,
                el->left, el->left->type, el->left->ind);

        ElementGraph (graph, el->left);
    }

    if (el->right > PARSE_ERR)
    {
        fprintf (graph, "\"Point: %p\\n Type: %d\\n %s\" -> "
                        "\"Point: %p\\n Type: %d\\n %s\";\n",
                        el,        el->type,        el->ind,
                 el->right, el->right->type, el->right->ind);

        ElementGraph (graph, el->right);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4129
jmp 0x4148
leaq 0x2a00(%rip), %rdi      # 0x6b30
leaq 0x2916(%rip), %rsi      # 0x6a4d
movl $0x5f, %edx
leaq 0x2a5f(%rip), %rcx      # 0x6ba2
callq 0x1080
cmpq $0x0, -0x10(%rbp)
je 0x4151
jmp 0x4170
leaq 0x23a5(%rip), %rdi      # 0x64fd
leaq 0x28ee(%rip), %rsi      # 0x6a4d
movl $0x60, %edx
leaq 0x2a37(%rip), %rcx      # 0x6ba2
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq 0x5fd1(%rip), %rax      # 0xa150
jbe 0x41de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %r10d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
leaq 0x2a0a(%rip), %rsi      # 0x6bc7
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4110
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x5f63(%rip), %rax      # 0xa150
jbe 0x424c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %r9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %r10d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
leaq 0x299c(%rip), %rsi      # 0x6bc7
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: CountSize(_IO_FILE*)
int CountSize (FILE* file)
{
    fseek (file, 0, SEEK_END);
    size_t num_symbols = ftell (file);
    fseek (file, 0, SEEK_SET);

    return num_symbols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10f0
movq -0x8(%rbp), %rdi
callq 0x1030
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: ReadTxt(char**, char const*)
size_t ReadTxt (char** text, const char* file_name)
{
    assert (text);
    assert (file_name);

    FILE* file = fopen (file_name, "r");
    if (file == nullptr)
    {
        printf ("[Input error] Unable to open file \"%s\"\n", file_name);
        return 0;
    }

    size_t num_symbols = CountSize (file);

    *text = (char*)calloc (num_symbols + 4, sizeof (**text));

    if (*text == nullptr)
    {
        printf ("[Error] Unable to allocate memory\n");
        return 0;
    }

    fread (*text, sizeof (**text), num_symbols, file);
    fclose (file);

    (*text)[num_symbols] = '\0';

    return num_symbols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42c9
jmp 0x42e8
leaq 0x21a4(%rip), %rdi      # 0x6474
leaq 0x2776(%rip), %rsi      # 0x6a4d
movl $0x84, %edx
leaq 0x2921(%rip), %rcx      # 0x6c04
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x42f1
jmp 0x4310
leaq 0x2932(%rip), %rdi      # 0x6c2a
leaq 0x274e(%rip), %rsi      # 0x6a4d
movl $0x85, %edx
leaq 0x28f9(%rip), %rcx      # 0x6c04
callq 0x1080
movq -0x18(%rbp), %rdi
leaq 0x2bff(%rip), %rsi      # 0x6f1a
callq 0x1100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x434a
movq -0x18(%rbp), %rsi
leaq 0x28fe(%rip), %rdi      # 0x6c34
movb $0x0, %al
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x43d0
movq -0x20(%rbp), %rdi
callq 0x4260
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
movl $0x1, %esi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4397
leaq 0x28d6(%rip), %rdi      # 0x6c5c
movb $0x0, %al
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x43d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1150
movq -0x20(%rbp), %rdi
callq 0x10e0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: SaveTree(Tree*)
void SaveTree (Tree* tree)
{
    assert (tree);

    FILE* tree_file = fopen ("CompileResult/CreatedTree.txt", "w");
    if (!tree_file)
    {
        printf ("Save error: Unable to open file \"CompileResult/CreatedTree.txt\"\n");
        return;
    }

    SaveElem (tree->head, tree_file, 0);
    fclose (tree_file);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x43f5
jmp 0x4414
leaq 0x264c(%rip), %rdi      # 0x6a48
leaq 0x264a(%rip), %rsi      # 0x6a4d
movl $0xa2, %edx
leaq 0x2870(%rip), %rcx      # 0x6c7f
callq 0x1080
leaq 0x287a(%rip), %rdi      # 0x6c95
leaq 0x2983(%rip), %rsi      # 0x6da5
callq 0x1100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4442
leaq 0x287a(%rip), %rdi      # 0x6cb3
movb $0x0, %al
callq 0x1040
jmp 0x445d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x4470
movq -0x10(%rbp), %rdi
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)